// ObjTableTest.hpp

// Classes to test object table and its consumers.

#include "objstream/ObjData.hpp"
#include "objstream/ObjTable.hpp"

#include <ostream>
#include <list>
#include <set>
#include <vector>

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

class Figure : public ObjType {
public:  // static functions
  static TypeName get_type_name() { return "Figure"; }
  static ObjCreator get_creator();
public:
  ObjData write_data() const { return ObjData("Figure"); }
};

ObjPtr create_Figure(const ObjData& data) {
  return ObjPtr(new Figure);
}

ObjCreator Figure::get_creator() { return create_Figure; }

typedef const Figure* FigurePtr;
typedef std::set<FigurePtr> FigureList;

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

class Table : public ObjType {
public:  // static functions
  static TypeName get_type_name() { return "Table"; }
  static ObjCreator get_creator();
public:
  ObjData write_data() const { return ObjData("Table"); }
};

ObjPtr create_Table(const ObjData& data) {
  return ObjPtr(new Table);
}

ObjCreator Table::get_creator() { return create_Table; }

typedef Ptr<const Table,LocalSharedDeletePolicy> TablePtr;
typedef std::list<TablePtr> TableList;

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

class Page : public ObjType {

public:
  typedef const Page* BPtr;
  typedef Ptr<const Page, LocalSharedDeletePolicy> SPtr;

private:
  int _number;       // Page nummber
  double _length;    // Max length for text lines
  bool _start;       // Is the start of a new chapter?
  string _text;      // text appearing on this page
  BPtr _prev;
  SPtr _first;
#ifdef ObjData_supports_lists
  std::set<int> _refs;
  std::vector<double> _lens;
  std::list<bool> _isrefs;
  std::vector<string> _paras;
  FigureList _figs;
  TableList _tabs;
#endif

public:  // static functions
  static TypeName get_type_name() { return "Page"; }
  static ObjCreator get_creator();

public:
  Page(int number, double length, bool start, string text,
       BPtr prev, SPtr first
#ifdef ObjData_supports_lists
     , std::set<int> refs, std::vector<double> lens,
       std::list<bool> isrefs, std::vector<string> paras,
       const FigureList& figs, const TableList& tabs
#endif
  ) : _number(number), _length(length), _start(start), _text(text),
      _prev(prev), _first(first)
#ifdef ObjData_supports_lists
    , _refs(refs), _lens(lens),
     _isrefs(isrefs), _paras(paras), _figs(figs), _tabs(tabs)
#endif
  { }
  Page(int number, double length=0.0, bool start=false, string text ="")
  : _number(number), _length(length), _start(start), _text(text),
    _prev(0), _first() { }
  int number() const { return _number; }
  double length() const { return _length; }
  double start() const { return _start; }
  string text() const { return _text; }
  BPtr prev() const { return _prev; }
  SPtr first() const { return _first; }
#ifdef ObjData_supports_lists
  const std::set<int>& refs() const { return _refs; }
  const std::vector<double> lens() const { return _lens; }
  const std::list<bool> isrefs() const { return _isrefs; }
  const std::vector<string> paras() const { return _paras; }
  const FigureList& figs() const { return _figs; }
  const TableList tabs() const { return _tabs; }
#endif

  ObjData write_data() const {
    ObjData data("Page");
    data.add_int("number",_number);
    data.add_double("length",_length);
    data.add_bool("start",_start);
    data.add_string("text",_text);
    data.add_bare_pointer("prev",_prev);
    data.add_share_pointer("first",_first);
#ifdef ObjData_supports_lists
    data.add_int_list("refs",_refs);
    data.add_double_list("lens",_lens);
    data.add_bool_list("isrefs",_isrefs);
    data.add_string_list("paras",_paras);
    data.add_bare_ptr_list("figs",_figs);
    data.add_share_ptr_list("tabs",_tabs);
#endif
    return data;
  }
};

typedef std::set<int> IntSet;
typedef std::vector<double> DoubleVector;
typedef std::list<bool> BoolList;
typedef std::vector<string> StringVector;

std::ostream& operator<<(std::ostream& stream, const Page& page) {
  stream << page.number() << " "
         << page.length() << " "
         << page.start() << " "
         << '"' << page.text() << "\" "
         << page.prev() << " "
         << page.first();
#ifdef ObjData_supports_lists
  stream << " ( ";
  const std::set<int>& refs = page.refs();
  for ( IntSet::const_iterator ival=refs.begin();
        ival!=refs.end(); ++ival )
    stream << *ival << ' ';
  stream << ')';
  {
    stream << " { ";
    const std::vector<double>& vals = page.lens();
    for ( DoubleVector::const_iterator ival=vals.begin();
          ival!=vals.end(); ++ival ) stream << *ival << ' ';
    stream << "}";
  }
  {
    stream << " [ ";
    const std::list<bool>& vals = page.isrefs();
    for ( BoolList::const_iterator ival=vals.begin();
          ival!=vals.end(); ++ival ) stream << *ival << ' ';
    stream << "]";
  }
  {
    stream << " { ";
    const std::vector<string>& vals = page.paras();
    for ( StringVector::const_iterator ival=vals.begin();
          ival!=vals.end(); ++ival ) stream << *ival << ' ';
    stream << "}";
  }
  {
    stream << " ( ";
    const FigureList& vals = page.figs();
    for ( FigureList::const_iterator ival=vals.begin();
          ival!=vals.end(); ++ival ) stream << *ival << ' ';
    stream << ")";
  }
  {
    stream << " ( ";
    const TableList& vals = page.tabs();
    for ( TableList::const_iterator ival=vals.begin();
          ival!=vals.end(); ++ival ) stream << *ival << ' ';
    stream << ")";
  }
#endif
  return stream;
}

bool operator==(const Page& lhs, const Page& rhs) {
  if ( lhs.number() != rhs.number() ) return false;
  if ( lhs.length() != rhs.length() ) {
    return false;
  }
  if ( lhs.start() != rhs.start() ) return false;
  if ( lhs.text() != rhs.text() ) return false;
  if ( lhs.prev() != rhs.prev() ) return false;
  if ( lhs.first() != rhs.first() ) return false;
#ifdef ObjData_supports_lists
  if ( lhs.refs() != rhs.refs() ) return false;
  if ( lhs.lens() != rhs.lens() ) return false;
  if ( lhs.isrefs() != rhs.isrefs() ) return false;
  if ( lhs.paras() != rhs.paras() ) return false;
  if ( lhs.figs() != rhs.figs() ) return false;
  if ( lhs.tabs() != rhs.tabs() ) return false;
#endif
  return true;
}

// Creator for class Page.
ObjPtr create_Page(const ObjData& data) {
  int num = data.get_int("number");
  double length = data.get_double("length");
  bool start = data.get_bool("start");
  string text = data.get_string("text");
  // Pointers require casts.
  Page::BPtr prev =
    dynamic_cast<Page::BPtr>( data.get_bare_pointer("prev") );
  Page::SPtr first;
  first.assign_with_dynamic_cast( data.get_share_pointer("first") );
#ifdef ObjData_supports_lists
  std::set<int> refset;
  data.get_int_list("refs",refset);
  std::vector<double> lens;
  data.get_double_list("lens",lens);
  std::list<bool> isrefs;
  data.get_bool_list("isrefs",isrefs);
  std::vector<string> paras;
  data.get_string_list("paras",paras);
  FigureList figs;
  data.get_bare_ptr_list("figs",figs);
  TableList tabs;
  data.get_share_ptr_list("tabs",tabs);
#endif
  return ObjPtr( new Page(num, length, start, text, prev, first
#ifdef ObjData_supports_lists
                , refset, lens, isrefs, paras, figs, tabs
#endif
  ) );
}

ObjCreator Page::get_creator() { return create_Page; }

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

// Register creators.
#ifdef NT_MSVCPP
ObjTable::Status regstat_Figure = obj_table_register_type<Figure>();
ObjTable::Status regstat_Table = ObjTable::register_type(Table());
ObjTable::Status regstat_Page = ObjTable::register_type(Page(1,2,false,""));
#else
ObjTable::Status regstat_Figure = ObjTable::register_type<Figure>();
ObjTable::Status regstat_Table = ObjTable::register_type<Table>();
ObjTable::Status regstat_Page = ObjTable::register_type<Page>();
#endif

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