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 */