ByteDataStreamBase.h

[詳解]

// -*- C++ -*-
#ifndef RTC_BYTEDATASTREAMBASE_H
#define RTC_BYTEDATASTREAMBASE_H
 
#include <coil/Properties.h>
#include <coil/Factory.h>
#include <rtm/Typename.h>
 
namespace RTC
{
  class ByteDataStreamBase
  {
  public:
     ByteDataStreamBase();
 
     virtual ~ByteDataStreamBase();
 
     virtual void init(const coil::Properties &prop);
     virtual void writeData(const unsigned char *buffer, unsigned long length) = 0;
     virtual void readData(unsigned char *buffer, unsigned long length) const = 0;
     virtual unsigned long getDataLength() const = 0;
     virtual void isLittleEndian(bool little_endian);
  };
 
  template <typename DataType>
  class ByteDataStream : public ByteDataStreamBase
  {
  public:
     ByteDataStream() = default;
 
     ~ByteDataStream() override = default;
 
     virtual bool serialize(const DataType &data) = 0;
     virtual bool deserialize(DataType &data) = 0;
  };
 
  using SerializerFactory = coil::GlobalFactory<ByteDataStreamBase>;
 
  template <class DataType>
  std::string addDataTypeToMarshalingType(const std::string &marshalingtype)
  {
     std::string mtype{std::string(::CORBA_Util::toRepositoryId<DataType>()) + ":" + marshalingtype};
     return mtype;
  }
 
  template <class DataType, class SerializerType>
  void addSerializer(const std::string &marshalingtype)
  {
     std::string mtype = addDataTypeToMarshalingType<DataType>(marshalingtype);
     SerializerFactory::instance()
             .addFactory(mtype,
                         ::coil::Creator<::RTC::ByteDataStreamBase,
                                         SerializerType>,
                         ::coil::Destructor<::RTC::ByteDataStreamBase,
                                            SerializerType>);
  }
 
  template <class DataType>
  void removeSerializer(const std::string &marshalingtype)
  {
     std::string mtype = addDataTypeToMarshalingType<DataType>(marshalingtype);
     SerializerFactory::instance().removeFactory(mtype);
  }
 
  template <class DataType>
  ::RTC::ByteDataStreamBase *createSerializer(const std::string &marshalingtype)
  {
     std::string mtype = addDataTypeToMarshalingType<DataType>(marshalingtype);
     return SerializerFactory::instance().createObject(mtype);
  }
 
  template <class DataType>
  std::vector<std::string> getSerializerList()
  {
     std::vector<std::string> available_types;
     std::vector<std::string> types = SerializerFactory::instance().getIdentifiers();
 
     for (auto type : types)
     {
        std::string id{::CORBA_Util::toRepositoryId<DataType>()};
        if (type.size() >= id.size() && std::equal(std::begin(id), std::end(id), std::begin(type)))
        {
           type.erase(0, id.size() + 1);
           available_types.push_back(type);
        }
     }
     return available_types;
  }
 
} // namespace RTC
 
EXTERN template class DLL_PLUGIN coil::GlobalFactory<::RTC::ByteDataStreamBase>;
 
#endif // RTC_BYTEDATASTREAMBASE_H