使用boost::序列化来序列化TAO/CORBA对象

Serializing TAO/CORBA objects with boost::serialization

本文关键字：序列化 CORBA 对象 boost 使用 TAO      更新时间：2023-10-16

我在序列化由corba生成的类时遇到了一个问题——特别是对于任何类型的序列——TAO::unbouded_value_sequence、TAO::unbouded_basic_string_sequence等。

对于CORBA结构的序列化是否有任何"好的"解决方案，或者我是否需要对CORBA类的代码进行反向工程，并尝试为每个类编写序列化函数?

编辑:

      struct Something;
      typedef
        TAO_Var_Var_T<
            Something
          >
        Something_var;
      typedef
        TAO_Out_T<
            Something
          >
        Something_out;

      struct  Something
      {
        typedef Something_var _var_type;
        typedef Something_out _out_type;
        static void _tao_any_destructor (void *);
        TAO::String_Manager member1;
      };
    class SequenceOfSomething;
  typedef
    TAO_VarSeq_Var_T<
        SequenceOfSomething
      >
    SequenceOfSomething_var;
  typedef
    TAO_Seq_Out_T<
        SequenceOfSomething
      >
    SequenceOfSomething_out;
  class  SequenceOfSomething
    : public
        TAO::unbounded_value_sequence<
            Something
          >
  {
  public:
    SequenceOfSomething (void);
    SequenceOfSomething ( ::CORBA::ULong max);
    SequenceOfSomething (
        ::CORBA::ULong max,
        ::CORBA::ULong length,
        SequenceOfSomething* buffer, 
        ::CORBA::Boolean release = false
      );
    SequenceOfSomething (const SequenceOfSomething &);
    virtual ~SequenceOfSomething (void);
    static void _tao_any_destructor (void *);
    typedef SequenceOfSomething_var _var_type;
    typedef SequenceOfSomething_out _out_type;

  };

这是一些从IDL定义生成的示例代码。

我安装了ACE+TAO框架，摆弄了一下。¹

看起来从实际的IDL更容易。

解析IDL的代码包含在SDK中，所以也许您可以利用它来生成一些序列化代码。

旁注:为什么Boost序列化已经完全实现了IIOP序列化的东西?您是否可以考虑使用ACE序列化来Boost序列化二进制缓冲区?如果不是，为什么不呢?

¹实际编译代码:http://paste.ubuntu.com/12907686/

感谢@sehe，这似乎正在工作:

namespace boost { namespace serialization {
    template <typename Archive, typename T>
        inline void save(Archive& ar, const TAO::unbounded_value_sequence<T>& varSequence, unsigned int /*version*/)
        {
            size_t length = varSequence.length();
            ar & length
               & boost::serialization::make_array(varSequence.get_buffer(), varSequence.length());
        }
    template <typename Archive, typename T>
        void load(Archive& ar, TAO::unbounded_value_sequence<T>& varSequence, unsigned int /*version*/)
        {
            size_t length;
            ar & length;
            varSequence.length(length);
            ar & boost::serialization::make_array(varSequence.get_buffer(), varSequence.length());
        }
    template <typename Archive, typename T>
        inline void serialize(Archive& ar, TAO::unbounded_value_sequence<T>& varSequence, const unsigned int version)
        {
            split_free(ar, varSequence, version); 
        }
    template <class Archive>
        inline void serialize(Archive& ar, SequenceOfSomething& seq, unsigned int version)
        {
            ar & base_object<TAO::unbounded_value_sequence<Something>>(seq);
        }
} }
相关文章：