statein.h

//
// statein.h
//
// Copyright (C) 1998 Limit Point Systems, Inc.
//
// Author: Curtis Janssen <cljanss@limitpt.com>
// Maintainer: LPS
//
// This file is part of the SC Toolkit.
//
// The SC Toolkit is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// The SC Toolkit is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public License
// along with the SC Toolkit; see the file COPYING.LIB.  If not, write to
// the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
//
// The U.S. Government is granted a limited license as per AL 91-7.
//
 
#ifndef _util_state_statein_h
#define _util_state_statein_h
 
#include <string>
#include <map>
 
#include <util/state/state.h>
#include <util/keyval/keyval.h>
 
namespace sc {
 
  template <typename T> void FromStateIn(T& t, StateIn& si, int& count);
 
class StateInData {
  public:
    Ref<SavableState> ptr;
    int size;
    int type;
    int offset;
 
    StateInData(): size(0), type(0), offset(0) {}
};
 
class StateClassData {
  public:
    int version;
    char *name;
    const ClassDesc *classdesc;
    int ninstance;
  public:
    StateClassData(int v=-1, const ClassDesc *c=0, char *name=0):
      version(v), name(name), classdesc(c), ninstance(0) {}
    StateClassData(const StateClassData &d) { operator=(d); }
    ~StateClassData();
    StateClassData &operator=(const StateClassData &d);
};
 
class StateIn:  public DescribedClass {
    friend class SavableState;
    friend class TranslateDataIn;
  private:
    // do not allow copy constructor or assignment
    StateIn(const StateIn&);
    void operator=(const StateIn&);
    int have_cd_;
    int dir_loc_;
    char key_[KeyVal::MaxKeywordLength];
    int keylength_;
  protected:
    Ref<KeyVal> override_;
    TranslateDataIn *translate_;
    std::map<int,StateInData> ps_;
    int expected_object_num_;
    std::map<ClassDescP,int> classidmap_;
    std::map<int,StateClassData> classdatamap_;
    int nextclassid_;
    int node_to_node_;
    int version_;
    int date_;
    char userid_[9];
    char format_;
    virtual int get_array_void(void*,int);
 
    int push_key(const char *key);
    void pop_key(int n) { key_[n] = '\0'; keylength_ = n; }
    const char *key() { return key_; }
 
    void get_directory();
    int directory_location() const { return dir_loc_; }
    void find_and_get_directory();
 
    // The following members are called by friend SavableState
 
    virtual int getobject(Ref<SavableState> &);
 
    virtual int dir_getobject(Ref<SavableState> &, const char *name);
 
    virtual void haveobject(int,const Ref<SavableState> &);
 
    virtual void nextobject(int);
    virtual void haveobject(const Ref<SavableState> &);
 
    void have_classdesc() { have_cd_ = 1; }
    int need_classdesc() { int tmp = have_cd_; have_cd_ = 0; return !tmp; }
 
    virtual int get(const ClassDesc**);
  public:
    StateIn();
    virtual ~StateIn();
 
    virtual void get_header();
 
    virtual int version(const ClassDesc*);
 
    virtual int getstring(char*&);
 
 
    virtual int get(std::string&);
    virtual int get(char&r, const char *keyword = 0);
    virtual int get(unsigned int&r, const char *keyword = 0);
    virtual int get(int&r, const char *keyword = 0);
    virtual int get(unsigned long int&r, const char *keyword = 0);
    virtual int get(long int&r, const char *keyword = 0);
    virtual int get(bool&r, const char *keyword = 0);
    virtual int get(float&r, const char *keyword = 0);
    virtual int get(double&r, const char *keyword = 0);
 
 
    virtual int get(char*&);
    virtual int get(unsigned int*&);
    virtual int get(int*&);
    virtual int get(unsigned long int*&);
    virtual int get(long int*&);
    virtual int get(float*&);
    virtual int get(double*&);
 
    virtual int get_array_char(char*p,int size);
    virtual int get_array_uint(unsigned int*p,int size);
    virtual int get_array_int(int*p,int size);
    virtual int get_array_ulong(unsigned long*p,int size);
    virtual int get_array_long(long*p,int size);
    virtual int get_array_float(float*p,int size);
    virtual int get_array_double(double*p,int size);
 
    template <template <typename, typename> class Container, class T, class A>
    int get(Container<T,A> &v) {
      size_t l;
      int r = get(l);
      for (size_t i=0; i<l; i++) {
        T tmp;
        FromStateIn(tmp,*this,r);
        v.push_back(tmp);
      }
      return r;
    }
 
    template <class T, class A>
    int get(std::vector<T, A> &v) {
      size_t l;
      int r = get(l);
      v.reserve(l);
      for (size_t i=0; i<l; i++) {
        T e;
        FromStateIn(e,*this,r);
        v.push_back(e);
      }
      return r;
    }
 
    template <typename Key, typename Compare, typename Alloc>
    int get(std::set<Key,Compare,Alloc>& s) {
      typedef std::set<Key,Compare,Alloc> Set;
      size_t size;
      int r = get(size);
      if (size) {
        for(size_t i=0; i<size; ++i) {
          Key k;
          FromStateIn(k,*this,r);
          s.insert(k);
        }
      }
      return r;
    }
 
    template <typename Key, typename Value>
    int get(std::map<Key,Value>& map) {
      typedef std::map<Key,Value> Map;
      size_t size;
      int r = get(size);
      if (size) {
        for(size_t i=0; i<size; ++i) {
          std::pair<Key,Value> v;
          r += get(v);
          map[v.first] = v.second;
        }
      }
      return r;
    }
 
    template <typename L, typename R>
    int get(std::pair<L,R>& v) {
      int s = 0;
      FromStateIn(v.first,*this,s);
      FromStateIn(v.second,*this,s);
      return s;
    }
 
    int node_to_node() const { return node_to_node_; }
 
    virtual int use_directory();
 
    virtual int tell();
    virtual void seek(int);
    virtual int seekable();
    int has_directory() const { return dir_loc_ != 0; }
 
    virtual void list_objects(std::ostream& = ExEnv::out0());
 
    void set_override(const Ref<KeyVal>&kv) { override_ = kv; }
    const Ref<KeyVal> &override() const { return override_; }
  };
 
  template <typename T> void FromStateIn(T& t, StateIn& so, int& count) {
    count += so.get(t);
  }
 
  template <typename T> void FromStateIn(Ref<T>& t, StateIn& so, int& count) {
    t << SavableState::restore_state(so);
  }
 
} // namespace sc
 
#endif
 
// Local Variables:
// mode: c++
// c-file-style: "CLJ"
// End: