More about persistane

New comment
 
Up until now, all that is found in the forum and even outside the forum, about object persistence is how to serialize the object itself. While this is a basic part of the problem, it does not represent the whole problem. 
The questions left as I see it are:
1. What about the super classes, the ancestors?
    Lets say we have a super class with private members, which can be accessed through protected methods by the subclass - 
    We need to save/load those too. 
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class S
  {
private:
   int               m_data;
protected:
   int               GetData()
     {
      return(m_data);
     }
   void              SetData(int data)
     {
      m_data=data;
     }
public:
   virtual bool      Save(const int handle){return false;}
   virtual bool      Load(const int handle){return false;}
  };
class B : public S
  {
private:
   double            m_area;
  };
public:
   virtual bool      Save(const int handle) override;
   virtual bool      Load(const int handle) override;
void              OnStart()
  {
   int h=FileOpen("file""testsave",FILE_WRITE|FILE_BIN);
   B *b=new S();
   b.Save(h);  // this serializes only class B, not class S data
   FileClose(h);
   delete b;
   h=FileOpen("testsave",FILE_READ|FILE_BIN);
   b=new S();
   b.Load(h);
   FileClose(h);
  };
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+

Which means - the Save method on class B will have to call the super class Save to serialize all the ancestors as well.
This is relatively easy.

2. Do we save each object in a different file, or all the objects in the same file? 
If it's on a different file - this raises the question - how will we distinguish different objects of same class?
Let's say we save an array of objects (lines) implemented with CArrayObj - and another collection of orders also implemented with CArrayObj - then we have to give each collection a file name that never changes. 
If we use one file name for all objects - still we have the problem of knowing which CArrayObj serialization belongs to which collection - the lines or the orders? 

3. What about embedded objects? If I have an order for instance, which has an internal object like trendline for stop or take profit or whatever? how can this connection be maintained between the objects saved/loaded?
If they are in different files or within the same file. 
because there can be many orders saved - each with it's own line.

The last two problems are the the hard part to solve IMHO if we want a methodology to save/load systems. 
Appreciate any thoughts on that. 

New comment