PersistentOStream.h

// -*- C++ -*-
//
// PersistentOStream.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// ThePEG is licenced under version 3 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 "ThePEG/Utilities/Debug.h"
#include "PersistentOStream.fh"
#include "PersistentOStream.xh"
#include <valarray>
 
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) {
    if ( ! isfinite(d) )
      throw WriteError()
        << "Tried to write a NaN or Inf double to a persistent stream."
        << Exception::runerror;
    os() << setprecision(18) << d;
    put(tSep);
    return *this;
  }
 
  PersistentOStream & operator<<(float f) {
    if ( ! isfinite(f) )
      throw WriteError()
        << "Tried to write a NaN or Inf float to a persistent stream."
        << Exception::runerror;
    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 {};
  struct WriteError: 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 &) = delete;
 
};
 
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, size_t N>
inline PersistentOStream & operator<<(PersistentOStream & os,
              const array<T,N> & a) {
  for ( auto it = a.cbegin(); it != a.cend() && os.good() ; ++it )
      os << *it;
  return os;
}
 
template <typename T, typename A>
inline PersistentOStream & operator<<(PersistentOStream & os,
                                      const deque<T,A> & d) {
  os.putContainer(d);
  return os;
}
 
template <typename T>
inline PersistentOStream & operator<<(PersistentOStream & os,
                                      const std::valarray<T> & v) {
  os << v.size();
  for ( int i = 0, N = v.size(); i < N; ++i ) os << v[i];
  return os;
}
 
}
 
#endif /* ThePEG_PersistentOStream_H */