PersistentData.H

Go to the documentation of this file.

#ifndef PERSISTENT_D_H
#define PERSISTENT_D_H

// written by Thorsten Reinecke (reinecke@thorstenreinecke.de)
// last change: 2004-10-06

extern "C"
{
 #include <unistd.h>
}

#include <map>
#include <string>
#include <iostream>
#include <fstream>

class CPersistentDataInterface
{
 public:
  virtual void Load(std::istream &is) = 0;
  virtual void Save(std::ostream &os) const = 0;
  virtual ~CPersistentDataInterface() = 0;
};
CPersistentDataInterface::~CPersistentDataInterface() { }

// gcc-4.0 (experimental) issued warnings about missing virtual destructors.
// Although we don't need destructors for our implementation, we *do* define
// a virtual destructor in the interface. That's because if the interface
// doesn't declare a virtual destructor (and also defines a default
// destructor), then no destructor will be called for the dynamically
// constructed items inside CPersistentDataCollection!


template <typename T>
class CPersistentData : protected CPersistentDataInterface
{
 protected:
  T &data; // reference of the variable to load/save
  CPersistentData(T &mydata) : data(mydata) { }
  virtual ~CPersistentData() { }
  virtual void Load(std::istream &is)
   {
     is >> data;
#ifdef VERBOSE
     cout << data << endl;
#endif
   }
  virtual void Save(std::ostream &os) const { os << data << std::endl; }
  friend class CPersistentDataCollection;
};


class CPersistentDataCollection : private ForbidAssignment
{
 protected:
  typedef std::map<std::string,CPersistentDataInterface*> TCollection;
  const std::string filename;
  TCollection collection;

 public:

  void ClearStream()
   {
     // remove stream
     unlink(filename.c_str());
   }

  void ClearCollection()
   {
    while (!collection.empty())
     {
       delete collection.begin()->second;
       collection.erase(collection.begin());
     }
   }

  explicit CPersistentDataCollection(const std::string myFilename)
   : filename(myFilename) { }
  
  ~CPersistentDataCollection() { ClearCollection();  }

  template<typename T> inline void RegisterVar(const std::string ID, T &data)
   {
     if (collection.find(ID)!=collection.end()) // check for presence
      {
        // was already present!
        exit(1); // for debugging (we could throw an exception instead)
      }
     else collection[ID] = new CPersistentData<T>(data);
   }

  template<typename T> inline void UnregisterVar(const std::string ID)
   {
     if (collection.find(ID)==collection.end()) // check for presence
      {
        // wasn't present!
        exit(1); // for debugging (we could throw an exception instead)
      }
     else
      {
        delete collection[ID];
        collection.erase(ID);
      }
   }

  void Load()
   {
     std::ifstream istr(filename.c_str());
     while (istr)
      {
        while (isspace(istr.peek())) istr.get();

        // it seems that gcc-3.2.3 has some problems detecting eof,
        // I hope this helps...
        istr.get();
        if (istr.eof()) break;
        istr.unget();

        std::string ID;
        istr >> ID;
        if (collection.find(ID)==collection.end()) // check for presence
         {
           MARK;
           cout << "ID " << ID << " not found!" << endl;
           exit(1); // isn't present!
         }
        else
         {
#ifdef VERBOSE
           cout << "Loading ID " << ID << "= "; 
#endif
           collection[ID]->Load(istr);
         }
      }
     istr.close();
   }

  void Save()
   {
     std::ofstream ostr(filename.c_str(),std::ios::out|std::ios::trunc);
     for (TCollection::const_iterator p=collection.begin(); p!=collection.end(); ++p)
      {
        ostr << p->first << " ";
        p->second->Save(ostr);
      }
     ostr.close();
   }

};

#endif /* PERSISTENT_D_H */

---