1. Introduction

Whenever an application needs to save objects in a file or send it over a network it must serialize these objects to a formated byte stream that stores all attributes. If the application reads the byte stream again it creates a corresponding object and sets the parameter or the object itself reads the attributes. If more than one object type is used a unique type-id is need to recreate the correct object from byte stream.

For i/o facilities C++ uses different kind of streams like Io-streams for standard input/output or fstreams for files. A stream offers operators (normally the operator<< to write and operator>> to read from stream) to read/write the generic data-types. These predefined operators can be extended with additional operators for user defined data-types. A disadvantage of standard C++ streams is the lack of type information. Objects written to a stream loose any type information and if an object is recreated the stream can not be asked for type of the actual element. So the application developer must write some kind of 'magic number' to identify elements written to a stream. Therefore NMM uses so called ValueStreams which stores the type information of each element. These type information are used for a runtime type safe object serialization/deserialization.

In this context we use the following class as example to show the use of ValueStreams.

namespace MyNamespace {
  class MyStruct {
  public:
                     MyStruct();
                     MyStruct(const MyStruct&);

        string&      getName()            {return __name;}
  const string&      getName()      const {return __name;}

  const list<float>& getValueList() const {return __value_list;}
        list<float>& getValueList()       {return __value_list;}
        int          getCounter()   const {return __counter;}
        void         setCounter(int i)    {__counter = i;}

  private: //The attributes
    string      __name;
    int         __counter;
    list<float> __value_list;
  };
}