CORBA_CdrMemoryStream.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef RTC_CORBA_CDRMEMORYSTREAM_H
#define RTC_CORBA_CDRMEMORYSTREAM_H
 
#include <rtm/RTC.h>
#include <rtm/idl/DataPort_OpenRTMSkel.h>
#include <rtm/ByteDataStreamBase.h>
 
 
 
namespace RTC
{
    class CORBA_CdrMemoryStream
    {
    public:
        CORBA_CdrMemoryStream();
 
        template<class ExDataType>
        bool serializeCDR(const ExDataType& data)
        {
#ifdef ORB_IS_ORBEXPRESS
            try
            {
                m_cdr.rewind();
                m_cdr.is_little_endian(m_endian);
                m_cdr << data;
                return true;
            }
            catch (...)
            {
                return false;
            }
#elif defined(ORB_IS_TAO)
            try
            {
                m_cdr.reset();
                m_cdr << data;
                return true;
            }
            catch (...)
            {
                return false;
            }
#else
            try
            {
                m_cdr.rewindPtrs();
                m_cdr.setByteSwapFlag(m_endian);
                data >>= m_cdr;
                return true;
            }
            catch (...)
            {
                return false;
            }
#endif
        }
 
        template<class ExDataType>
        bool deserializeCDR(ExDataType& data)
        {
#ifdef ORB_IS_ORBEXPRESS
            try
            {
                m_cdr >> data;
                return true;
            }
            catch (...)
            {
                return false;
            }
#elif defined(ORB_IS_TAO)
            try
            {
                TAO_InputCDR tao_cdr = TAO_InputCDR(m_cdr);
                tao_cdr >> data;
                return true;
            }
            catch (...)
            {
                return false;
            }
#else
            try
            {
                data <<= m_cdr;
                return true;
            }
            catch (...)
            {
                return false;
            }
#endif
        }
 
        void setEndian(bool little_endian);
 
        const unsigned char* getBuffer();
        unsigned long getCdrDataLength() const;
 
#ifdef ORB_IS_ORBEXPRESS
        CORBA::Stream& getCdr();
#elif defined(ORB_IS_TAO)
        TAO_OutputCDR& getCdr();
#else
        cdrMemoryStream& getCdr();
#endif
 
        void writeCdrData(const unsigned char* buffer, unsigned long length);
 
        void readCdrData(unsigned char* buffer, unsigned long length) const;
 
        CORBA_CdrMemoryStream(const CORBA_CdrMemoryStream &rhs)
        {
#ifdef ORB_IS_ORBEXPRESS
            m_cdr.copy(rhs.m_cdr);
#elif defined(ORB_IS_TAO)
        for (const ACE_Message_Block *i = rhs.m_cdr.begin(); i != nullptr; i = i->cont())
        {
            m_cdr.write_octet_array_mb(i);
        }
#else
            m_cdr = rhs.m_cdr;
#endif
        }
 
 
        CORBA_CdrMemoryStream& operator= (const CORBA_CdrMemoryStream &rhs)
        {
#ifdef ORB_IS_ORBEXPRESS
            m_cdr.copy(rhs.m_cdr);
            return *this;
#elif defined(ORB_IS_TAO)
            for (const ACE_Message_Block *i = rhs.m_cdr.begin(); i != nullptr; i = i->cont())
            {
                m_cdr.write_octet_array_mb(i);
            }
            return *this;
#else
            m_cdr = rhs.m_cdr;
            return *this;
#endif
        }
 
    protected:
#ifdef ORB_IS_ORBEXPRESS
        CORBA::Stream m_cdr;
#elif defined(ORB_IS_TAO)
        TAO_OutputCDR m_cdr;
#else
        cdrMemoryStream m_cdr;
#endif
        bool m_endian{true};
    };
    template <class DataType>
    class CORBA_CdrSerializer : public ByteDataStream<DataType>
    {
    public:
        CORBA_CdrSerializer() = default;
 
        ~CORBA_CdrSerializer() override = default;
 
        void init(const coil::Properties& /*prop*/) override
        {
        }
        void writeData(const unsigned char* buffer, unsigned long length) override
        {
            m_cdr.writeCdrData(buffer, length);
        }
 
        void readData(unsigned char* buffer, unsigned long length) const override
        {
            m_cdr.readCdrData(buffer, length);
        }
 
        unsigned long getDataLength() const override
        {
            return m_cdr.getCdrDataLength();
        }
 
        bool serialize(const DataType& data) override
        {
            return m_cdr.serializeCDR(data);
        }
 
        bool deserialize(DataType& data) override
        {
            return m_cdr.deserializeCDR(data);
        }
 
        CORBA_CdrSerializer<DataType>(const CORBA_CdrSerializer<DataType> &rhs)
        {
            m_cdr = rhs.m_cdr;
        }
 
        CORBA_CdrSerializer<DataType>& operator= (const CORBA_CdrSerializer<DataType> &rhs)
        {
            m_cdr = rhs.m_cdr;
            return *this;
        }
 
        void isLittleEndian(bool little_endian) override
        {
            m_cdr.setEndian(little_endian);
        }
    protected:
        CORBA_CdrMemoryStream m_cdr;
        
 
    };
 
 
 
 
 
} // namespace RTC
 
 
 
 
 
 
template <class DataType>
void CdrMemoryStreamInit()
{
    ::RTC::addSerializer<DataType, ::RTC::CORBA_CdrSerializer<DataType>>("cdr");
}
 
 
 
 
 
#endif  // RTC_CORBA_CDRMEMORYSTREAM_H