// ObjData.hpp

#ifndef ObjData_H
#define ObjData_H

// Enable lists.
#define ObjData_supports_lists 1

//**********************************************************************

// This class holds the named data for an object.
// Persistent objects provide a method to bundle their data in an
// object of this type and provide a function to create themselves
// from such an object.
//
// The tyes of data supported are:
// INT - int
// DOUBLE - double
// BOOL - bool
// STRING - string
// BARE_PTR - const ObjType*
// SHARE_PTR - Ptr<T,Pol>  p which can be assigned with
//   Ptr<const ObjType,LocalSharedDeletePolicy>::assign_with_dynamic_cast(p)
//
// It also hold containers of any of these object types.  Supported
// containers include vector, list and set.
//
// Thes containers are defined only if the flag ObjData_supports_lists
// is defined.

//**********************************************************************

#include "objstream/ObjException.hpp"
#include "objstream/ObjType.hpp"

#include <functional>
#include <iosfwd>
#include <list>
#include <map>
#include <set>
#include <string>
#include <vector>

#ifdef NT_MSVCPP
#include "objstream/ObjData_inlined.hpp"
#else


class ObjData {

public:  // enums

  // Enum listing the known types of data.
  // PTR is a pointer which shares 
  enum Type { INT, DOUBLE, BOOL, STRING, BARE_PTR, SHARE_PTR
#ifdef ObjData_supports_lists
            , INT_LIST, DOUBLE_LIST, BOOL_LIST, STRING_LIST,
              BARE_PTR_LIST, SHARE_PTR_LIST
#endif
  };

public:  // typedefs

  // Type name.
  typedef std::string TypeName;

  // Datum name.
  typedef std::string Name;

  // ordered list of Datum names.
  typedef std::vector<Name> NameList;

  // list of Datum names.
  typedef std::set<Name> NameSet;

  // Comparator for names.
  typedef std::less<Name> CmpName;

  // Map of types indexed by name.
  typedef std::map<Name,Type,CmpName> TypeMap;

  // Bare pointer.
  typedef const ObjType* BarePtr;

  // Shared management pointer.
  typedef ObjPtr SharePtr;

#ifdef ObjData_supports_lists
  // Data Lists.
  typedef std::vector<int>      IntList;
  typedef std::vector<double>   DoubleList;
#ifdef __KCC
  typedef std::list<bool>       BoolList;
#else
  typedef std::vector<bool>     BoolList;
#endif
  typedef std::vector<std::string>   StringList;
  typedef std::vector<BarePtr>  BarePtrList;
  typedef std::vector<SharePtr> SharePtrList;
#endif

  // Data maps.
  typedef std::map<Name,int,CmpName>      IntMap;
  typedef std::map<Name,double,CmpName>   DoubleMap;
  typedef std::map<Name,bool,CmpName>     BoolMap;
  typedef std::map<Name,std::string,CmpName>   StringMap;
  typedef std::map<Name,BarePtr,CmpName>  BarePtrMap;
  typedef std::map<Name,SharePtr,CmpName> SharePtrMap;
#ifdef ObjData_supports_lists
  typedef std::map<Name,IntList,CmpName>       IntListMap;
  typedef std::map<Name,DoubleList,CmpName>    DoubleListMap;
  typedef std::map<Name,BoolList,CmpName>      BoolListMap;
  typedef std::map<Name,StringList,CmpName>    StringListMap;
  typedef std::map<Name,BarePtrList,CmpName>   BarePtrListMap;
  typedef std::map<Name,SharePtrList,CmpName>  SharePtrListMap;
#endif

private:  // data

  TypeName    _type;
  NameList    _ordered_names;
  NameSet     _names;
  TypeMap     _types;
  IntMap      _ints;
  DoubleMap   _doubles;
  BoolMap     _bools;
  StringMap   _strings;
  BarePtrMap  _bare_ptrs;
  SharePtrMap _share_ptrs;
#ifdef ObjData_supports_lists
  IntListMap       _int_lists;
  DoubleListMap    _double_lists;
  BoolListMap      _bool_lists;
  StringListMap    _string_lists;
  BarePtrListMap   _bare_ptr_lists;
  SharePtrListMap  _share_ptr_lists;
#endif

public:  //  Constructor.

  // Constructor.
  // User may specify the type name.
  ObjData(TypeName name ="");

public:  //  Methods to add data.

  // Add an int.
  void add_int(Name name, int val);

  // Add a double.
  void add_double(Name name, double val);

  // Add a bool.
  void add_bool(Name name, bool val);

  // Add a string.
  void add_string(Name name, std::string val);

  // Add a bare pointer.
  void add_bare_pointer(Name name, BarePtr val);

  // Add a share pointer.
  template <class T, class Pol>
  void add_share_pointer(Name name, const Ptr<T,Pol>& ptr);

#ifdef ObjData_supports_lists

public:  //  Methods to add data lists.

  // Add ints.
  template<class C>
  void add_int_list(Name name, C&);

  // Add doubles.
  template<class C>
  void add_double_list(Name name, C&);

  // Add bools.
  template<class C>
  void add_bool_list(Name name, C&);

  // Add strings.
  template<class C>
  void add_string_list(Name name, C&);

  // Add bare pointers.
  template<class C>
  void add_bare_ptr_list(Name name, C&);

  // Add share pointers.
  template<class C>
  void add_share_ptr_list(Name name, C&);

#endif

public:  // Methods to retrieve data.

  // Return if data name is used.
  bool has(Name name) const;

  // Return the type name.
  TypeName get_object_type() const { return _type; }

  // Retrieve the list of names.
  const NameList& get_names() const { return _ordered_names; }

  // Retrieve the type for given name.
  Type get_type(Name name) const;
  
  // Retrieve an int.
  int get_int(Name name) const;

  // Retrieve a double.
  double get_double(Name name) const;

  // Retrieve a bool.
  bool get_bool(Name name) const;

  // Retrieve a string.
  std::string get_string(Name name) const;

  // Retrieve a bare pointer.
  BarePtr get_bare_pointer(Name name) const;

  // Retrieve a typed bare pointer.
  template<class T>
  void get_bare_pointer(Name name, const T*& ptr) const;

  // Retrieve a share pointer.
  SharePtr get_share_pointer(Name name) const;

  // Retrieve a typed share pointer.
  template <class T, class Pol>
  void get_share_pointer(Name name, Ptr<T,Pol>& ptr) const;

#ifdef ObjData_supports_lists

public:  // Methods to retrieve data lists.

  // Retrieve ints.
  template<class C>
  void get_int_list(Name name, C&) const;

  // Retrieve doubles.
  template<class C>
  void get_double_list(Name name, C&) const;

  // Retrieve bools.
  template<class C>
  void get_bool_list(Name name, C&) const;

  // Reteve strings.
  template<class C>
  void get_string_list(Name name, C&) const;

  // Retrieve bare pointers.
  template<class C>
  void get_bare_ptr_list(Name name, C&) const;

  // RetRieve share pointers.
  template<class C>
  void get_share_ptr_list(Name name, C&) const;

#endif

};

#endif  // end NT_MSVCPP

//**********************************************************************

// Exceptions used by this class.

// Base for exceptions from this class.
class ObjDataException : public ObjException { };

// Duplicate datum name.
class DuplicateDatumName : public ObjDataException { };

// Unknown datum name.
class UnknownDatumName : public ObjDataException { };

// Type mismatch.
class TypeNameMismatch: public ObjDataException {
public:
  TypeNameMismatch(std::string type, std::string name);
};

// Unknown type.
class UnknownType : public ObjDataException { };

// Invalid cast.
class InvalidCast : public ObjDataException { };

//**********************************************************************

// Output stream.

std::ostream& operator<<(std::ostream& stream, const ObjData& rhs);

//**********************************************************************

#ifndef NT_MSVCPP
#include "objstream/ObjData.tpp"
#endif

#endif