PersistentOStream.h

// -*- C++ -*-
//
// PersistentOStream.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2007 Leif Lonnblad
//
// ThePEG is licenced under version 2 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef ThePEG_PersistentOStream_H
#define ThePEG_PersistentOStream_H
// This is the declaration of the PersistentOStream class.

#include "ThePEG/Config/ThePEG.h"
#include "ThePEG/Utilities/ClassDescription.h"
#include "ThePEG/Utilities/Exception.h"
#include "PersistentOStream.fh"
#include "PersistentOStream.xh"

namespace ThePEG {

class PersistentOStream {

public:

  ThePEG_DECLARE_POINTERS(PersistentBase,BPtr);

  ThePEG_DECLARE_MAP(cBPtr, int, ObjectMap);

  ThePEG_DECLARE_MAP(const ClassDescriptionBase *, int, ClassMap);

  typedef ClassDescriptionBase::DescriptionVector DescriptionVector;

public:

  PersistentOStream(ostream &, const vector<string> & libs = vector<string>());

  PersistentOStream(string, const vector<string> & libs = vector<string>());

  ~PersistentOStream();

  template <typename T>
  PersistentOStream & operator<<(const RCPtr<T> & p) { 
    return outputPointer(p); 
  }

  template <typename T>
  PersistentOStream & operator<<(const ConstRCPtr<T> & p) { 
    return outputPointer(p); 
  }

  template <typename T>
  PersistentOStream & operator<<(const TransientRCPtr<T> & p) { 
    return outputPointer(p); 
  }

  template <typename T>
  PersistentOStream & operator<<(const TransientConstRCPtr<T> & p) {
    return outputPointer(p);
  }


  PersistentOStream & operator<<(string s) {
    for ( string::const_iterator i = s.begin(); i < s.end(); ++i ) escape(*i);
    put(tSep);
    return *this;
  }

  PersistentOStream & operator<<(char c) {
    escape(c);
    put(tSep);
    return *this;
  }

  PersistentOStream & operator<<(signed char c) {
    return (*this) << static_cast<char>(c);
  }
  
  PersistentOStream & operator<<(unsigned char c) {
    return (*this) << static_cast<char>(c);
  }
  
  PersistentOStream & operator<<(int i) {
    os() << i;
    put(tSep);
    return *this;
  }

  PersistentOStream & operator<<(unsigned int i) {
    os() << i;
    put(tSep);
    return *this;
  }

  PersistentOStream & operator<<(long i) {
    os() << i;
    put(tSep);
    return *this;
  }

  PersistentOStream & operator<<(unsigned long i) {
    os() << i;
    put(tSep);
    return *this;
  }

  PersistentOStream & operator<<(short i) {
    os() << i;
    put(tSep);
    return *this;
  }

  PersistentOStream & operator<<(unsigned short i) {
    os() << i;
    put(tSep);
    return *this;
  }

  PersistentOStream & operator<<(double d) {
    os() << setprecision(18) << d;
    put(tSep);
    return *this;
  }

  PersistentOStream & operator<<(float f) {
    os() << setprecision(9) << f;
    put(tSep);
    return *this;
  }

  PersistentOStream & operator<<(bool t) {
    if (t) put(tYes);
    else put(tNo);
    // This is a workaround for a possible bug in gcc 4.0.0
    // which inserts tYes and tNo as global symbols although
    // they are private
    //  put(t? tYes: tNo);
    put(tSep);
    return *this;
  }

  PersistentOStream & operator<<(const char * s) {
    *this << string(s);
    return *this;
  }

  PersistentOStream & operator<<(Complex z) {
    *this << z.real() << z.imag();
    return *this;
  }

  template <typename Container>
  void putContainer(const Container & c) {
    *this << c.size();
    for ( typename Container::const_iterator it = c.begin();
          it != c.end() && good() ; ++it )
      *this << *it;
  }

  PersistentOStream & outputPointer(tcBPtr);

  void putObjectPart(tcBPtr obj, const ClassDescriptionBase * cd);

  PersistentOStream & flush();
  
  PersistentOStream & push() {
    lastSavedObject.push(writtenObjects.size() - 1);
    return *this;
  }

  PersistentOStream & pop() {
    lastSavedObject.pop();
    return *this;
  }

  bool good() const { return !badState && os(); }

  operator bool() const { return good(); }

  bool operator!() const { return !good(); }

private:

  struct MissingClass: public Exception {};
  static const int version = 0;

  static const int subVersion = 3;

  static const char tBegin = '{';

  static const char tEnd = '}';

  static const char tNext = '|';

  static const char tNull = '\\';

  static const char tSep = '\n';

  static const char tNoSep = 'n';

  static const char tYes = 'y';

  static const char tNo = 'n';

  bool isToken(char c) const {
    return c == tBegin || c == tEnd || c == tNext || c == tSep || c == tNull;
  }

  void setBadState() {
    breakThePEG();
    badState = true;
  }

  void checkState() { if ( ! os() ) badState = true; }

  const ClassDescriptionBase * writeClassId(tcBPtr);

  void writeClassDescription(const ClassDescriptionBase *);

  void beginObject() { put(tBegin); }

  void endObject() { put(tEnd); }

  void endBase() { put(tNext); }

  void put(char c) { os().put(c); }

  void escape(char c) { 
    if ( isToken(c) ) {
      put(tNull);
      put( c == tSep? tNoSep: c );
    } else
      put(c);
  }

  ostream & os() { return *theOStream; }

  const ostream & os() const { return *theOStream; }

  void init(const vector<string> & libs);

  ObjectMap writtenObjects;

  stack<int> lastSavedObject;

  ClassMap writtenClasses;

  ostream * theOStream;

  bool badState;

  bool allocStream;

private:

  PersistentOStream();

  PersistentOStream(const PersistentOStream &);

  PersistentOStream & operator=(const PersistentOStream &);

};

inline PersistentOStream &
operator<<(PersistentOStream & os, PersistentOManip func) {
  return (*func)(os);
}


inline PersistentOStream & flush(PersistentOStream & os) { return os.flush(); }

inline PersistentOStream & push(PersistentOStream & os) { return os.push(); }

inline PersistentOStream & pop(PersistentOStream & os) { return os.pop(); }


template <typename T1, typename T2>
inline PersistentOStream & operator<<(PersistentOStream & os,
                                      const pair<T1,T2> & p) {
  return os << p.first << p.second;
}

template <typename Key, typename T, typename Cmp, typename A>
inline PersistentOStream & operator<<(PersistentOStream & os,
                                      const multimap<Key,T,Cmp,A> & m) {
  os.putContainer(m);
  return os;
}

template <typename Key, typename T, typename Cmp, typename A>
inline PersistentOStream & operator<<(PersistentOStream & os,
                                      const map<Key,T,Cmp,A> & m) {
  os.putContainer(m);
  return os;
}

template <typename Key, typename Cmp, typename A>
inline PersistentOStream & operator<<(PersistentOStream & os,
                                      const set<Key,Cmp,A> & s) {
  os.putContainer(s);
  return os;
}


template <typename Key, typename Cmp, typename A>
inline PersistentOStream & operator<<(PersistentOStream & os,
                                      const multiset<Key,Cmp,A> & s) {
  os.putContainer(s);
  return os;
}


template <typename T, typename A>
inline PersistentOStream & operator<<(PersistentOStream & os,
                                      const list<T,A> & l) {
  os.putContainer(l);
  return os;
}


template <typename T, typename A>
inline PersistentOStream & operator<<(PersistentOStream & os,
                                      const vector<T,A> & v) {
  os.putContainer(v);
  return os;
}

template <typename T, typename A>
inline PersistentOStream & operator<<(PersistentOStream & os,
                                      const deque<T,A> & d) {
  os.putContainer(d);
  return os;
}

}

#endif /* ThePEG_PersistentOStream_H */

---