用boost序列化TAO/CORBA对象：：

Question

我在序列化由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定义生成的一些示例代码。

Answer 1

多亏了@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);
        }
} }

Answer 2

我安装了ACE+TAO框架，并摆弄了一些东西。

从实际的IDL来看，它似乎更容易实现。

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

Sidenote:为什么要推动已经为其完全实现了IIOP序列化的东西？您能考虑用ACE序列化来提升二进制缓冲区的序列化吗？若否，原因为何？

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