it_bus/param.h

#ifndef _PARAM_H_
#define _PARAM_H_

//
//  Copyright (c) 2002 IONA Technologies PLC. All Rights Reserved.
//

#error "This file is obsolete."

#include <it_bus/message_writer.h>
#include <it_bus/message_reader.h>
#include <it_bus/serialization_exception.h>
#include <it_bus/deserialization_exception.h>

namespace IT_Bus
{
    class IT_BUS_API InParam
    {
      public:
        InParam() {}
        virtual ~InParam();

        virtual void
        write(
            MessageWriter &
        ) const throw((SerializationException)) = 0;

        virtual const String &
        get_name() const = 0;

      protected:
        InParam(const InParam &);
        InParam & operator=(const InParam &);
    };

    class IT_BUS_API OutParam
    {
      public:
        OutParam() {}
        virtual ~OutParam();

        virtual void
        read(
            MessageReader &
        ) throw((SerializationException)) = 0;

        virtual const String &
        get_name() const = 0;

      protected:
        OutParam(const OutParam &);
        OutParam & operator=(const OutParam &);
    };

    class IT_BUS_API InOutParam : public InParam, public OutParam
    {
      public:
        InOutParam() {}
        virtual ~InOutParam();

        virtual void
        write(
            MessageWriter &
        ) const throw((SerializationException)) = 0;

        virtual void
        read(
            MessageReader &
        ) throw((SerializationException)) = 0;

        virtual const String &
        get_name() const = 0;

      protected:
        InOutParam(const InOutParam &);
        InOutParam & operator=(const InOutParam &);
    };

    template <class T>
    class InParamImpl : public InParam
    {
      public:
        InParamImpl(
            const String& param_name,
            const T&      value
        ) :
            m_value(value), m_name(param_name) {}

        virtual void
        write(
            MessageWriter & writer
        ) const throw((SerializationException))
        {
            writer.write(QName(m_name), m_value);
        }

        virtual const String &
        get_name() const
        {
            return m_name;
        }

      protected:
        InParamImpl(const InParamImpl<T> &);
        InParamImpl<T> & operator=(const InParamImpl<T> &);

        String m_name;
        const T & m_value;
    };

    template <class T>
    class OutParamImpl : public OutParam
    {
      public:
        OutParamImpl(
            const String& param_name,
            T&            value
        ) :
            m_value(value), m_name(param_name) {}

        virtual void
        read(
            MessageReader & reader
        ) throw((SerializationException))
        {
            reader.read(m_value);
        }

        virtual const String &
        get_name() const
        {
            return m_name;
        }

      protected:
        OutParamImpl(const OutParamImpl<T> &);
        OutParamImpl<T> & operator=(const OutParamImpl<T> &);

        String m_name;
        T & m_value;
    };

    template <class T>
    class InOutParamImpl : public InOutParam
    {
      public:
        InOutParamImpl(
            const String& param_name,
            T&            value
        ) :
            m_value(value), m_name(param_name) {}

        virtual void
        write(
            MessageWriter & writer
        ) const throw((SerializationException))
        {
            writer.write(QName(m_name), m_value);
        }

        virtual void
        read(
            MessageReader & reader
        ) throw((SerializationException))
        {
            reader.read(m_value);
        }

        virtual const String &
        get_name() const
        {
            return m_name;
        }

      protected:
        InOutParamImpl(const InOutParamImpl<T> &);
        InOutParamImpl<T> & operator=(const InOutParamImpl<T> &);

        String m_name;
        T & m_value;
    };
};

#endif  

---