PersistentIStream.h

// -*- C++ -*-
//
// PersistentIStream.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_PersistentIStream_H
#define ThePEG_PersistentIStream_H
// This is the declaration of the PersistentIStream class.
 
#include "ThePEG/Config/ThePEG.h"
#include "InputDescription.h"
#include "PersistentIStream.fh"
#include "ThePEG/Utilities/Exception.h"
#include <climits>
#include <valarray>
 
namespace ThePEG {
 
class PersistentIStream {
 
public:
 
  ThePEG_DECLARE_POINTERS(PersistentBase,BPtr);
 
  typedef vector<BPtr> ObjectVector;
 
  typedef InputDescription::DescriptionVector DescriptionVector;
 
public:
 
  PersistentIStream(istream & is) 
    : theIStream(&is), isPedantic(true), 
      allocStream(false), badState(false)
  {
    init();
  }
 
 
 
  PersistentIStream(string);
 
  ~PersistentIStream();
 
  template <typename T>
  PersistentIStream & operator>>(RCPtr<T> & ptr) {
    BPtr b = getObject();
    ptr = dynamic_ptr_cast< RCPtr<T> >(b);
    if ( b && !ptr ) setBadState();
    return *this;
  }
 
  template <typename T>
  PersistentIStream & operator>>(ConstRCPtr<T> & ptr) {
    BPtr b = getObject();
    ptr = dynamic_ptr_cast< ConstRCPtr<T> >(b);
    if ( b && !ptr ) setBadState();
    return *this;
  }
 
  template <typename T>
  PersistentIStream & operator>>(TransientRCPtr<T> & ptr) {
    BPtr b = getObject();
    ptr = dynamic_ptr_cast< TransientRCPtr<T> >(b);
    if ( b && !ptr ) setBadState();
    return *this;
  }
 
  template <typename T>
  PersistentIStream & operator>>(TransientConstRCPtr<T> & ptr) {
    BPtr b = getObject();
    ptr = dynamic_ptr_cast< TransientConstRCPtr<T> >(b);
    if ( b && !ptr ) setBadState();
    return *this;
  }
 
 
  PersistentIStream & operator>>(string &);
 
  PersistentIStream & operator>>(char &);
 
  PersistentIStream & operator>>(signed char &);
 
  PersistentIStream & operator>>(unsigned char &);
 
  PersistentIStream & operator>>(int & i) {
    is() >> i;
    getSep();
    return *this;
  }
 
  PersistentIStream & operator>>(unsigned int & i) {
    is() >> i;
    getSep();
    return *this;
  }
 
  PersistentIStream & operator>>(long & i) {
    is() >> i;
    getSep();
    return *this;
  }
 
  PersistentIStream & operator>>(unsigned long & i) {
    is() >> i;
    getSep();
    return *this;
  }
 
  PersistentIStream & operator>>(short & i) {
    is() >> i;
    getSep();
    return *this;
  }
 
  PersistentIStream & operator>>(unsigned short & i) {
    is() >> i;
    getSep();
    return *this;
  }
 
  PersistentIStream & operator>>(double & d) {
    is() >> d;
    getSep();
    return *this;
  }
 
  PersistentIStream & operator>>(float & f) {
    is() >> f;
    getSep();
    return *this;
  }
 
  PersistentIStream & operator>>(bool &);
 
  PersistentIStream & operator>>(Complex &);
 
  template <typename Container> void getContainer(Container & c) {
    long size;
    typename Container::value_type val;
    c.clear();
    *this >> size;
    while ( size-- && good() ) {
      *this >> val;
      c.insert(c.end(), val);
    }
  }
 
  BPtr getObject();
 
  void getObjectPart(tBPtr obj, const InputDescription * pid);
 
  const InputDescription * getClass();
  
  PersistentIStream & setPedantic() {
    isPedantic = true;
    return *this;
  }
 
  PersistentIStream & setTolerant() {
    isPedantic = false;
    return *this;
  }
 
  bool good() const { return !badState && is(); }
  
  bool operator!() const { return !good(); }
 
  operator bool() const { return good(); }
 
  bool pedantic() const { return isPedantic; }
 
  const vector<string> & globalLibraries() const {
    return theGlobalLibraries;
  }
 
private:
 
  struct MissingClass: public Exception {};
 
  struct MissingObject: public Exception {};
 
  struct ReadFailure: public Exception {};
  void init();
 
  char get() { return is().get(); }
 
  char escaped() {
    char c = get();
    return c == tNoSep? tSep: c;
  }
 
  void setBadState() {
    breakThePEG();
    badState = true;
  }
 
  void getSep() {
    if ( !pedantic() ) skipField();
    else if ( get() != tSep ) setBadState();
  }
 
  void skipField() {
    is().ignore(INT_MAX, tSep);
    if ( !is() ) setBadState();
  }
 
 
  bool beginObject() { return is().peek() == tBegin; }
 
  void endObject();
 
  void endBase(string classname);
 
  istream & is() { return *theIStream; }
 
  const istream & is() const { return *theIStream; }
 
  ObjectVector readObjects;
 
  DescriptionVector readClasses;
 
  istream * theIStream;
 
  bool isPedantic;
 
  bool allocStream;
 
  bool badState;
 
  int version;
 
  int subVersion;
 
  vector<string> theGlobalLibraries;
 
  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';
 
private:
 
  PersistentIStream();
 
  PersistentIStream(const PersistentIStream &);
 
  PersistentIStream & operator=(const PersistentIStream &) = delete;
 
};
 
 
inline PersistentIStream & operator>>(PersistentIStream & is, 
                                      PersistentIManip func) {
  return (*func)(is);
}
  
inline PersistentIStream & pedantic(PersistentIStream & is) {
  return is.setPedantic();
}
 
 
inline PersistentIStream & tolerant(PersistentIStream & is) {
  return is.setTolerant();
}
 
 
template <typename T1, typename T2>
inline PersistentIStream & operator>>(PersistentIStream & is, pair<T1,T2> & p) {
  return is >> p.first >> p.second;
}
 
template <typename Key, typename T, typename Cmp, typename A>
inline PersistentIStream & operator>>(PersistentIStream & is, map<Key,T,Cmp,A> & m) {
  m.clear();
  long size;
  Key k;
  is >> size;
  while ( size-- && is ) {
    is >> k;
    is >> m[k];
  }
  return is;
}
 
template <typename Key, typename T, typename Cmp, typename A>
inline PersistentIStream & operator>>(PersistentIStream & is,
                                      multimap<Key,T,Cmp,A> & m) {
  m.clear();
  long size;
  Key k;
  T t;
  is >> size;
  while ( size-- && is ) {
    is >> k;
    is >> t;
    m.insert(make_pair(k, t));
  }
  return is;
}
 
 
template <typename Key, typename Cmp, typename A>
inline PersistentIStream & operator>>(PersistentIStream & is, 
                                      set<Key,Cmp,A> & s) {
  is.getContainer(s);
  return is;
}
 
template <typename Key, typename Cmp, typename A>
inline PersistentIStream & operator>>(PersistentIStream & is,
                                      multiset<Key,Cmp,A> & s) {
  is.getContainer(s);
  return is;
}
 
 
template <typename T, typename A>
inline PersistentIStream & operator>>(PersistentIStream & is, 
                                      list<T,A> & l) {
  is.getContainer(l);
  return is;
}
 
 
template <typename T, typename A>
inline PersistentIStream & operator>>(PersistentIStream & is, 
              vector<T,A> & v) {
  is.getContainer(v);
  return is;
}
 
template <typename T, size_t N>
inline PersistentIStream & operator>>(PersistentIStream & is, 
              array<T,N> & a) {
  for ( size_t i = 0; i < N && is.good(); ++i ) 
    is >> a[i];
  return is;
}
 
template <typename T, typename A>
inline PersistentIStream & operator>>(PersistentIStream & is, 
                                      deque<T,A> & d) {
  is.getContainer(d);
  return is;
}
 
template <typename T>
inline PersistentIStream & operator>>(PersistentIStream & is, 
                                      std::valarray<T> & v) {
  long size;
  is >> size;
  v = std::valarray<T>(size);
  for ( int i = 0; i < size && is.good(); ++i ) is >> v[i];
  return is;
}
 
}
 
#endif /* ThePEG_PersistentIStream_H */