votpp.hh

// ----------------------------------------------------------------------^
// Copyright (C) 2004, 2005, 2006, 2007 Giorgio Calderone <gcalderone@ifc.inaf.it>
// 
// This file is part of VOTPP.
// 
// VOTPP is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// VOTPP 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 General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with VOTPP; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
// 
// ----------------------------------------------------------------------$





#ifndef DEF_VOTPPVO_HH
#define DEF_VOTPPVO_HH
#include <mcs.hh>

namespace votpp {

enum Nodetype {
  VOTABLE,
  RESOURCE,
  DESCRIPTION,
  DEFINITIONS,
  INFO,
  PARAM,
  TABLE,
  FIELD,
  GROUP,
  FIELDref,
  PARAMref,
  VALUES,
  MIN,
  MAX,
  OPTION,
  LINK,
  DATA,
  TABLEDATA,
  TD,
  TR,
  FITS,
  BINARY,
  STREAM,
  COOSYS
};


enum Datatype {
  BOOLEAN,
  BIT,
  UNSIGNEDBYTE,
  SHORT,
  INT,
  LONG,
  CHAR,
  UNICODECHAR,
  FLOAT,
  DOUBLE,
  FLOATCOMPLEX,
  DOUBLECOMPLEX
};


enum EncodingType {
  ENCODING_GZIP,
  ENCODING_BASE64,
  ENCODING_DYNAMIC,
  ENCODING_NONE
};


enum Field_type {
//Deprecated in VOTable specification vers. 1.1
  FIELD_HIDDEN,
  FIELD_NO_QUERY,
  FIELD_TRIGGER,
  FIELD_LOCATION
};


enum Resource_type {
  RESOURCE_RESULTS,
  RESOURCE_META
};


enum Values_Type {
  VALUES_LEGAL,
  VALUES_ACTUAL
};


enum Link_content_role {
  LINK_QUERY,
  LINK_HINTS,
  LINK_DOC,
  LINK_LOCATION
};


enum Stream_type {
  STREAM_TYPE_LOCATOR,
  STREAM_TYPE_OTHER
};


enum Stream_actuate {
  STREAM_ACTUATE_ONLOAD,
  STREAM_ACTUATE_ONREQUEST,
  STREAM_ACTUATE_OTHER,
  STREAM_ACTUATE_NONE
};


enum Coosys_system {
  COOSYS_EQ_FK4,
  COOSYS_EQ_FK5,
  COOSYS_ICRS,
  COOSYS_ECL_FK4,
  COOSYS_ECL_FK5,
  COOSYS_GALACTIC,
  COOSYS_SUPERGALACTIC,
  COOSYS_XY,
  COOSYS_BARYCENTRIC,
  COOSYS_GEO_APP
};



enum Data_format {
  DATA_TABLEDATA,
  DATA_FITS,
  DATA_BINARY
};





//Forward declaration
class Field;
class Parser_Stream;


class Element {
protected:
  static const std::string def_empty;

  static const enum Resource_type def_Resource_type;

  static const enum Values_Type def_Values_type;

  static const bool def_inclusive;

  static const enum Stream_type def_Stream_type;

  static const enum Stream_actuate def_Stream_actuate;

  static const enum EncodingType def_encoding;

  virtual void hk_reset();
  virtual void hk_setAttribute(std::string name, std::string value);
  virtual void hk_setChild(Element* child);

  enum Nodetype lnodetype;

  string lclassname;

  Element* lnext;

  Element* lprev;

  Element* lparent;


  unsigned int ldepth;

  unsigned int lord;

  friend class Parser_Stream;

  void setParentInChild(Element* child);

public:
  virtual ~Element();

  enum Nodetype nodeType();

  string className();

  virtual void print(bool verbose);

  virtual void reset();

  virtual void done();

  virtual bool setAttribute(std::string name, std::string value);

  virtual bool setChild(Element* child);

  bool setNext(Element* next);

  Element* next();

  Element* prev();

  Element* parent();

  Element* makeCopy();

  unsigned int depth();

  unsigned int ord();

  static enum Nodetype sto_Nodetype(std::string s);

  static enum Datatype sto_Datatype(std::string s);

  static enum EncodingType sto_EncodingType(std::string s);

  static enum Resource_type sto_Resource_type(std::string s);

  static enum Field_type sto_Field_type(std::string s);

  static enum Values_Type sto_Values_type(std::string s);

  static enum Link_content_role sto_Link_content_role(std::string s);

  static enum Stream_type sto_Stream_type(std::string s);

  static enum Stream_actuate sto_Stream_actuate(std::string s);

  static enum Coosys_system sto_Coosys_system(std::string s);

  static bool sto_bool(std::string s);

  static std::string space_indent(int d);
};

//#define S_CHILD_DEF(NAME)                           //private:  NAME *_ch_ ## NAME;                       //public:   NAME * child_ ## NAME();


//
//
//#define M_CHILD_DEF(NAME)                           //private:  NAME **_ch_ ## NAME;                      //private: unsigned int _ch_ ## NAME ## _count;       //public:   NAME * child_ ## NAME(unsigned int i);    //public:  unsigned int child_ ## NAME ## _count();

//-------------------------------------------------------------------------------------

/*
  Template

  CLASS(Classname, Nodename, , , , , , , , , , , , , , , ,          , , ,          , , , , , );
 );
*/


class Description : public Element {
private: bool constructor;
private: string _value;
private: bool _value_isnull;
public: string value();
public: bool value_isNull();
public: Description();
virtual ~Description();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};


class Coosys : public Element {
private: bool constructor;
private: string _ID;
private: bool _ID_isnull;
public: string ID();
public: bool ID_isNull();
private: string _equinox;
private: bool _equinox_isnull;
public: string equinox();
public: bool equinox_isNull();
private: string _epoch;
private: bool _epoch_isnull;
public: string epoch();
public: bool epoch_isNull();
private: enum Coosys_system _system;
private: bool _system_isnull;
public: enum Coosys_system system();
public: bool system_isNull();
public: Coosys();
virtual ~Coosys();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};

class Info : public Element {
private: bool constructor;
private: string _ID;
private: bool _ID_isnull;
public: string ID();
public: bool ID_isNull();
private: string _name;
private: bool _name_isnull;
public: string name();
public: bool name_isNull();
private: string _value;
private: bool _value_isnull;
public: string value();
public: bool value_isNull();
public: Info();
virtual ~Info();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};

class Link : public Element {
private: bool constructor;
private: string _ID;
private: bool _ID_isnull;
public: string ID();
public: bool ID_isNull();
private: enum Link_content_role _content_role;
private: bool _content_role_isnull;
public: enum Link_content_role content_role();
public: bool content_role_isNull();
private: string _content_type;
private: bool _content_type_isnull;
public: string content_type();
public: bool content_type_isNull();
private: string _title;
private: bool _title_isnull;
public: string title();
public: bool title_isNull();
private: string _value;
private: bool _value_isnull;
public: string value();
public: bool value_isNull();
private: string _href;
private: bool _href_isnull;
public: string href();
public: bool href_isNull();
private: string _gref;
private: bool _gref_isnull;
public: string gref();
public: bool gref_isNull();
private: string _action;
private: bool _action_isnull;
public: string action();
public: bool action_isNull();
public: Link();
virtual ~Link();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};

class FieldRef : public Element {
private: bool constructor;
private: string _ref;
private: bool _ref_isnull;
public: string ref();
public: bool ref_isNull();
public: FieldRef();
virtual ~FieldRef();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};

class ParamRef : public Element {
private: bool constructor;
private: string _ref;
private: bool _ref_isnull;
public: string ref();
public: bool ref_isNull();
public: ParamRef();
virtual ~ParamRef();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};

class Stream : public Element {
private: bool constructor;
private: enum Stream_type _type;
private: bool _type_isnull;
public: enum Stream_type type();
public: bool type_isNull();
private: string _href;
private: bool _href_isnull;
public: string href();
public: bool href_isNull();
private: enum Stream_actuate _actuate;
private: bool _actuate_isnull;
public: enum Stream_actuate actuate();
public: bool actuate_isNull();
private: enum EncodingType _encoding;
private: bool _encoding_isnull;
public: enum EncodingType encoding();
public: bool encoding_isNull();
private: string _expires;
private: bool _expires_isnull;
public: string expires();
public: bool expires_isNull();
private: string _rights;
private: bool _rights_isnull;
public: string rights();
public: bool rights_isNull();
public: Stream();
virtual ~Stream();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};

class Column : public Element {
private: bool constructor;
private: enum EncodingType _encoding;
private: bool _encoding_isnull;
public: enum EncodingType encoding();
public: bool encoding_isNull();
private: string _value;
private: bool _value_isnull;
public: string value();
public: bool value_isNull();
public: Column();
virtual ~Column();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;



//  void done();
//  Record data;
};


class Min : public Element {
private: bool constructor;
private: string _value;
private: bool _value_isnull;
public: string value();
public: bool value_isNull();
private: bool _inclusive;
private: bool _inclusive_isnull;
public: bool inclusive();
public: bool inclusive_isNull();
public: Min();
virtual ~Min();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};

class Max : public Element {
private: bool constructor;
private: string _value;
private: bool _value_isnull;
public: string value();
public: bool value_isNull();
private: bool _inclusive;
private: bool _inclusive_isnull;
public: bool inclusive();
public: bool inclusive_isNull();
public: Max();
virtual ~Max();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};

class Option : public Element {
private: bool constructor;
private: string _name;
private: bool _name_isnull;
public: string name();
public: bool name_isNull();
private: string _value;
private: bool _value_isnull;
public: string value();
public: bool value_isNull();
private: Option **_ch_Option;
private: unsigned int _ch_Option_count;
public: Option * option(unsigned int i);
public: unsigned int option_count();
public: Option();
virtual ~Option();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};


class Row : public Element {
private: bool constructor;
private: Column **_ch_Column;
private: unsigned int _ch_Column_count;
public: Column * column(unsigned int i);
public: unsigned int column_count();
public: Row();
virtual ~Row();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};


class Tabledata : public Element {
private: bool constructor;
private: Row **_ch_Row;
private: unsigned int _ch_Row_count;
public: Row * row(unsigned int i);
public: unsigned int row_count();
public: Tabledata();
virtual ~Tabledata();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};


class Fits : public Element {
private: bool constructor;
private: int _extnum;
private: bool _extnum_isnull;
public: int extnum();
public: bool extnum_isNull();
private: Stream *_ch_Stream;
public: Stream * stream();
public: Fits();
virtual ~Fits();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};


class Binary : public Element {
private: bool constructor;
private: Stream *_ch_Stream;
public: Stream * stream();
public: Binary();
virtual ~Binary();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};


class Values : public Element {
private: bool constructor;
private: string _ID;
private: bool _ID_isnull;
public: string ID();
public: bool ID_isNull();
private: enum Values_Type _type;
private: bool _type_isnull;
public: enum Values_Type type();
public: bool type_isNull();
private: string _null;
private: bool _null_isnull;
public: string null();
public: bool null_isNull();
private: string _ref;
private: bool _ref_isnull;
public: string ref();
public: bool ref_isNull();
private: Min *_ch_Min;
public: Min * min();
private: Max *_ch_Max;
public: Max * max();
private: Option **_ch_Option;
private: unsigned int _ch_Option_count;
public: Option * option(unsigned int i);
public: unsigned int option_count();
public: Values();
virtual ~Values();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};


class Field : public Element {
private: bool constructor;
private: string _ID;
private: bool _ID_isnull;
public: string ID();
public: bool ID_isNull();
private: string _unit;
private: bool _unit_isnull;
public: string unit();
public: bool unit_isNull();
private: enum Datatype _datatype;
private: bool _datatype_isnull;
public: enum Datatype datatype();
public: bool datatype_isNull();
private: string _precision;
private: bool _precision_isnull;
public: string precision();
public: bool precision_isNull();
private: int _width;
private: bool _width_isnull;
public: int width();
public: bool width_isNull();
private: string _ref;
private: bool _ref_isnull;
public: string ref();
public: bool ref_isNull();
private: string _name;
private: bool _name_isnull;
public: string name();
public: bool name_isNull();
private: string _ucd;
private: bool _ucd_isnull;
public: string ucd();
public: bool ucd_isNull();
private: string _utype;
private: bool _utype_isnull;
public: string utype();
public: bool utype_isNull();
private: string _arraysize;
private: bool _arraysize_isnull;
public: string arraysize();
public: bool arraysize_isNull();
private: enum Field_type _type;
private: bool _type_isnull;
public: enum Field_type type();
public: bool type_isNull();
private: Description *_ch_Description;
public: Description * description();
private: Values *_ch_Values;
public: Values * values();
private: Link **_ch_Link;
private: unsigned int _ch_Link_count;
public: Link * link(unsigned int i);
public: unsigned int link_count();
public: Field();
virtual ~Field();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;



  //  void done();

};


class Param : public Element {
private: bool constructor;
private: string _ID;
private: bool _ID_isnull;
public: string ID();
public: bool ID_isNull();
private: string _unit;
private: bool _unit_isnull;
public: string unit();
public: bool unit_isNull();
private: enum Datatype _datatype;
private: bool _datatype_isnull;
public: enum Datatype datatype();
public: bool datatype_isNull();
private: string _precision;
private: bool _precision_isnull;
public: string precision();
public: bool precision_isNull();
private: int _width;
private: bool _width_isnull;
public: int width();
public: bool width_isNull();
private: string _ref;
private: bool _ref_isnull;
public: string ref();
public: bool ref_isNull();
private: string _name;
private: bool _name_isnull;
public: string name();
public: bool name_isNull();
private: string _ucd;
private: bool _ucd_isnull;
public: string ucd();
public: bool ucd_isNull();
private: string _utype;
private: bool _utype_isnull;
public: string utype();
public: bool utype_isNull();
private: string _value;
private: bool _value_isnull;
public: string value();
public: bool value_isNull();
private: string _arraysize;
private: bool _arraysize_isnull;
public: string arraysize();
public: bool arraysize_isNull();
private: Description *_ch_Description;
public: Description * description();
private: Values *_ch_Values;
public: Values * values();
private: Link **_ch_Link;
private: unsigned int _ch_Link_count;
public: Link * link(unsigned int i);
public: unsigned int link_count();
public: Param();
virtual ~Param();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};


class Group : public Element {
private: bool constructor;
private: string _ID;
private: bool _ID_isnull;
public: string ID();
public: bool ID_isNull();
private: string _name;
private: bool _name_isnull;
public: string name();
public: bool name_isNull();
private: string _ref;
private: bool _ref_isnull;
public: string ref();
public: bool ref_isNull();
private: string _ucd;
private: bool _ucd_isnull;
public: string ucd();
public: bool ucd_isNull();
private: string _utype;
private: bool _utype_isnull;
public: string utype();
public: bool utype_isNull();
private: Description *_ch_Description;
public: Description * description();
private: FieldRef **_ch_FieldRef;
private: unsigned int _ch_FieldRef_count;
public: FieldRef * fieldref(unsigned int i);
public: unsigned int fieldref_count();
private: Param **_ch_Param;
private: unsigned int _ch_Param_count;
public: Param * param(unsigned int i);
public: unsigned int param_count();
private: ParamRef **_ch_ParamRef;
private: unsigned int _ch_ParamRef_count;
public: ParamRef * paramref(unsigned int i);
public: unsigned int paramref_count();
private: Group **_ch_Group;
private: unsigned int _ch_Group_count;
public: Group * group(unsigned int i);
public: unsigned int group_count();
public: Group();
virtual ~Group();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};


class Data : public Element {
private: bool constructor;
private: Tabledata *_ch_Tabledata;
public: Tabledata * tabledata();
private: Binary *_ch_Binary;
public: Binary * binary();
private: Fits *_ch_Fits;
public: Fits * fits();
public: Data();
virtual ~Data();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};



//The Table class is used by Parser_Data to read table's data
class Table : public Element {
private: bool constructor;
private: string _ID;
private: bool _ID_isnull;
public: string ID();
public: bool ID_isNull();
private: string _name;
private: bool _name_isnull;
public: string name();
public: bool name_isNull();
private: string _ref;
private: bool _ref_isnull;
public: string ref();
public: bool ref_isNull();
private: string _ucd;
private: bool _ucd_isnull;
public: string ucd();
public: bool ucd_isNull();
private: string _utype;
private: bool _utype_isnull;
public: string utype();
public: bool utype_isNull();
private: int _nrows;
private: bool _nrows_isnull;
public: int nrows();
public: bool nrows_isNull();
private: Description *_ch_Description;
public: Description * description();
private: Data *_ch_Data;
public: Data * data();
private: Field **_ch_Field;
private: unsigned int _ch_Field_count;
public: Field * field(unsigned int i);
public: unsigned int field_count();
private: Param **_ch_Param;
private: unsigned int _ch_Param_count;
public: Param * param(unsigned int i);
public: unsigned int param_count();
private: Group **_ch_Group;
private: unsigned int _ch_Group_count;
public: Group * group(unsigned int i);
public: unsigned int group_count();
private: Link **_ch_Link;
private: unsigned int _ch_Link_count;
public: Link * link(unsigned int i);
public: unsigned int link_count();
public: Table();
virtual ~Table();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;



  //  void hk_reset();
  string filename;

};


class Resource : public Element {
private: bool constructor;
private: string _ID;
private: bool _ID_isnull;
public: string ID();
public: bool ID_isNull();
private: string _name;
private: bool _name_isnull;
public: string name();
public: bool name_isNull();
private: string _utype;
private: bool _utype_isnull;
public: string utype();
public: bool utype_isNull();
private: enum Resource_type _type;
private: bool _type_isnull;
public: enum Resource_type type();
public: bool type_isNull();
private: Description *_ch_Description;
public: Description * description();
private: Info **_ch_Info;
private: unsigned int _ch_Info_count;
public: Info * info(unsigned int i);
public: unsigned int info_count();
private: Coosys **_ch_Coosys;
private: unsigned int _ch_Coosys_count;
public: Coosys * coosys(unsigned int i);
public: unsigned int coosys_count();
private: Param **_ch_Param;
private: unsigned int _ch_Param_count;
public: Param * param(unsigned int i);
public: unsigned int param_count();
private: Link **_ch_Link;
private: unsigned int _ch_Link_count;
public: Link * link(unsigned int i);
public: unsigned int link_count();
private: Table **_ch_Table;
private: unsigned int _ch_Table_count;
public: Table * table(unsigned int i);
public: unsigned int table_count();
private: Resource **_ch_Resource;
private: unsigned int _ch_Resource_count;
public: Resource * resource(unsigned int i);
public: unsigned int resource_count();
public: Resource();
virtual ~Resource();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};


class Definitions : public Element {
private: bool constructor;
private: Coosys **_ch_Coosys;
private: unsigned int _ch_Coosys_count;
public: Coosys * coosys(unsigned int i);
public: unsigned int coosys_count();
public: Definitions();
virtual ~Definitions();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};


class VOTable : public Element {
private: bool constructor;
private: string _xmlns;
private: bool _xmlns_isnull;
public: string xmlns();
public: bool xmlns_isNull();
private: string _ID;
private: bool _ID_isnull;
public: string ID();
public: bool ID_isNull();
private: string _version;
private: bool _version_isnull;
public: string version();
public: bool version_isNull();
private: Description *_ch_Description;
public: Description * description();
private: Definitions *_ch_Definitions;
public: Definitions * definitions();
private: Coosys **_ch_Coosys;
private: unsigned int _ch_Coosys_count;
public: Coosys * coosys(unsigned int i);
public: unsigned int coosys_count();
private: Param **_ch_Param;
private: unsigned int _ch_Param_count;
public: Param * param(unsigned int i);
public: unsigned int param_count();
private: Info **_ch_Info;
private: unsigned int _ch_Info_count;
public: Info * info(unsigned int i);
public: unsigned int info_count();
private: Resource **_ch_Resource;
private: unsigned int _ch_Resource_count;
public: Resource * resource(unsigned int i);
public: unsigned int resource_count();
public: VOTable();
virtual ~VOTable();
static string sta_className();
static string sta_nodeName();
static enum Nodetype sta_nodeType();
void print(bool verbose);
void reset();
bool setAttribute(string name, string value);
bool setChild(Element* child);
Element* makeCopy();
;


};


typedef union NodePointer {
  votpp::Element *element;
  votpp::VOTable *votable;
  votpp::Resource *resource;
  votpp::Description *description;
  votpp::Definitions *definitions;
  votpp::Info *info;
  votpp::Param *param;
  votpp::Table *table;
  votpp::Field *field;
  votpp::Group *group;
  votpp::FieldRef *fieldref;
  votpp::ParamRef *paramref;
  votpp::Values *values;
  votpp::Min *min;
  votpp::Max *max;
  votpp::Option *option;
  votpp::Link *link;
  votpp::Data *data;
  votpp::Tabledata *tabledata;
  votpp::Column *column;
  votpp::Row *row;
  votpp::Fits *fits;
  votpp::Binary *binary;
  votpp::Stream *stream;
  votpp::Coosys *coosys;
};

class VOTableReaderSplit : public mcs::URLReader
{
private:
  static char* NodeStream[2];

  mcs::B64_Codec b64;
  char* pMatch[2];
  int pMatchLen[2];
  int sel, nse;

  unsigned int writeSplit(char* buf, unsigned int len);
  unsigned int Write(void *ptr, unsigned int size, unsigned int nmemb);

  int bin_filecount;
  int bin_outfd;
  string bin_file_prefix;

  mcs::Synchro synchro;
  bool consumerReady;
  mcs::Pipe* lbinpipe;

public:
  void saveBinaryStream(string fn = "");

  mcs::Pipe* binpipe();

  VOTableReaderSplit();
  ~VOTableReaderSplit();
};


class Parser_Stream
{
private:
  //Object used for reading input file.
  VOTableReaderSplit input;

  std::string lfilename;

  enum Nodetype lnodetype;

  unsigned int nodeord;

  void* pReader;

  void* pInput;

  bool flopen;

  bool flnewinfo;

  //bool fleof;

  int next_xmlnode(bool skipSubTree);

  int parse();

  bool continue_read;

  unsigned int ldepth;

  mcs::RecordSet* lbinstream;

  Element* lnode;

  VOTable votable;
  Resource resource;
  Description description;
  Definitions definitions;
  Info info;
  Param param;
  Table table;
  Field field;
  Group group;
  FieldRef fieldref;
  ParamRef paramref;
  Values values;
  Min min;
  Max max;
  Option option;
  Link link;
  Data data;
  Tabledata tabledata;
  Column column;
  Row row;
  Fits fits;
  Binary binary;
  Stream stream;
  Coosys coosys;

public:
  Parser_Stream();

  ~Parser_Stream();

  void open(std::string filename);

  void close();

  std::string filename();

  enum Nodetype nodeType();

  unsigned int depth();

  NodePointer node();

  NodePointer next(bool skipSubTree = false);

  NodePointer skip(unsigned int n = 1);

  mcs::RecordSet* binstream();
  void saveBinaryStream(string fn = "");
};





class Parser_Tree {
private:
  bool flmodified;

  bool smartmode;

  Parser_Stream stream;

  VOTable* lroot;

  void addNodes(Element* node, unsigned int d);

public:
  Parser_Tree(bool smartmode = true);

  ~Parser_Tree();

  void open(std::string filename);

  void free();

  //Return a pointer to the root node in the tree.
  VOTable* root();
};

//class Parser_Table : public mcs::RecordSet {
//private:
//  Parser_Stream stream;
//  Element* node;
//
//  Data_format type;
//  mcs::Record meta;
//
//  vector<string> arrsizes;
//
//  string fn;
//  unsigned int ord_nodeTable;
//
//  void searchStartData();
//
//  bool fetch_tabledata(unsigned int newpos, bool random);
//  bool fetch_binary(unsigned int newpos, bool random);
//  bool fetch_fits(unsigned int newpos, bool random);
//
//  bool fetch(unsigned int newpos, bool random);
//
//  void addMeta(Field& field);
//
//
//public:
//  Parser_Table(Table& nodeTable);
//  Parser_Table(string fn, int tableOrd = 1);
//
//  ~Parser_Table();
//};
//
//
//
//
//
//
//
//
//
//#define VOT_WRI_TABLEDATA
//#define VOT_WRI_FITS
//#define VOT_WRI_BINARY
//
//
//#define VOT_ENDNODE 1
//
//class Writer_Stream {
//private:
//  //!True if a file is open
//  bool flopen;
//
//  int level;
//
//  //!The writer used to do the job.
//  void* pWriter;
//
//
//public:
//  //!Constructor
//  Writer_Stream();
//
//  //!Destructor, automatically calls close().
//  ~Writer_Stream();
//
//  //!Open a new file for writing.
//  void open(string resource, enum Data_format format, bool include = false);
//
//  //!Finalize writing to a file.
//  void close();
//
//  //!Actual node
//  Element* node;
//
//  const Writer_Stream& operator<<(Element* newnode);
//  const Writer_Stream& operator<<(const int& endnode);
//};




}
//namespace votpp
#endif 

---

VOTPP (VOTable C++ Parser) ver. 0.3.2-alpha1 Documentation generated on Sun Nov 18 12:06:20 UTC 2007