VOTable.cc

// ----------------------------------------------------------------------^
// 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
// 
// ----------------------------------------------------------------------$

#include <assert.h>
#include <libxml/xmlreader.h>
#include <libxml/xmlwriter.h>


#include "votpp.hh"
using namespace votpp;


Element::~Element() {}

//Static members
const string               Element::def_empty          = "";
const enum Resource_type   Element::def_Resource_type  = RESOURCE_RESULTS;
const enum Values_Type     Element::def_Values_type    = VALUES_LEGAL;
const bool                 Element::def_inclusive      = true;
const enum Stream_type     Element::def_Stream_type    = STREAM_TYPE_LOCATOR;
const enum Stream_actuate  Element::def_Stream_actuate = STREAM_ACTUATE_ONREQUEST;
const enum EncodingType    Element::def_encoding       = ENCODING_NONE;

void Element::hk_reset() {}
void Element::hk_setAttribute(string name, string value) {}
void Element::hk_setChild(Element* child) {}
void Element::setParentInChild(Element* child) { child->lparent = this; }
enum Nodetype Element::nodeType() { return lnodetype; }
string Element::className() { return lclassname; }

void Element::print(bool verbose) {}
void Element::reset() {}
void Element::done() {}

bool Element::setAttribute(string name, string value) { return true; }
bool Element::setChild(Element* child) { return true; }
bool Element::setNext(Element* next) {
  if (lnext)
    abort();

  lnext = next; next->lprev = this;
  return true;
}

Element* Element::next() { return lnext; }
Element* Element::prev() { return lprev; }
Element* Element::parent() { return lparent; }





unsigned int Element::depth()
{ return ldepth; }


unsigned int Element::ord()
{ return lord; }


string Element::space_indent(int d) {
  int i;
  string s = "";
  char buf[4];
  snprintf(buf, 4, "%02d ", d);

  for(i=0; i<d; i++)
    s += "    ";

  s += buf;
  return s;
}






bool Element::sto_bool(string s)
{
  if ((strcmp(s.c_str(), "yes") == 0)  ||
      (strcmp(s.c_str(), "1")   == 0))
    return true;
  else
    return false;
}


enum Nodetype Element::sto_Nodetype(string s)
{
  if      (strcmp(s.c_str(), VOTable::sta_nodeName().c_str()    ) == 0)  return VOTABLE;
  else if (strcmp(s.c_str(), Resource::sta_nodeName().c_str()   ) == 0)  return RESOURCE;
  else if (strcmp(s.c_str(), Description::sta_nodeName().c_str()) == 0)  return DESCRIPTION;
  else if (strcmp(s.c_str(), Definitions::sta_nodeName().c_str()) == 0)  return DEFINITIONS;
  else if (strcmp(s.c_str(), Info::sta_nodeName().c_str()       ) == 0)  return INFO;
  else if (strcmp(s.c_str(), Param::sta_nodeName().c_str()      ) == 0)  return PARAM;
  else if (strcmp(s.c_str(), Table::sta_nodeName().c_str()      ) == 0)  return TABLE;
  else if (strcmp(s.c_str(), Field::sta_nodeName().c_str()      ) == 0)  return FIELD;
  else if (strcmp(s.c_str(), Group::sta_nodeName().c_str()      ) == 0)  return GROUP;
  else if (strcmp(s.c_str(), FieldRef::sta_nodeName().c_str()   ) == 0)  return FIELDref;
  else if (strcmp(s.c_str(), ParamRef::sta_nodeName().c_str()   ) == 0)  return PARAMref;
  else if (strcmp(s.c_str(), Values::sta_nodeName().c_str()     ) == 0)  return VALUES;
  else if (strcmp(s.c_str(), Min::sta_nodeName().c_str()        ) == 0)  return MIN;
  else if (strcmp(s.c_str(), Max::sta_nodeName().c_str()        ) == 0)  return MAX;
  else if (strcmp(s.c_str(), Option::sta_nodeName().c_str()     ) == 0)  return OPTION;
  else if (strcmp(s.c_str(), Link::sta_nodeName().c_str()       ) == 0)  return LINK;
  else if (strcmp(s.c_str(), Data::sta_nodeName().c_str()       ) == 0)  return DATA;
  else if (strcmp(s.c_str(), Tabledata::sta_nodeName().c_str()  ) == 0)  return TABLEDATA;
  else if (strcmp(s.c_str(), Column::sta_nodeName().c_str()     ) == 0)  return TD;
  else if (strcmp(s.c_str(), Row::sta_nodeName().c_str()        ) == 0)  return TR;
  else if (strcmp(s.c_str(), Fits::sta_nodeName().c_str()       ) == 0)  return FITS;
  else if (strcmp(s.c_str(), Binary::sta_nodeName().c_str()     ) == 0)  return BINARY;
  else if (strcmp(s.c_str(), Stream::sta_nodeName().c_str()     ) == 0)  return STREAM;
  else if (strcmp(s.c_str(), Coosys::sta_nodeName().c_str()     ) == 0)  return COOSYS;
  else
    throw MCS_ERROR( MSG_VOT_INVALID_NODETYPE, s);
}


enum Datatype Element::sto_Datatype(string s)
{
  if      (strcmp(s.c_str(), "boolean")       == 0) return BOOLEAN      ;
  else if (strcmp(s.c_str(), "bit")           == 0) return BIT          ;
  else if (strcmp(s.c_str(), "unsignedByte")  == 0) return UNSIGNEDBYTE ;
  else if (strcmp(s.c_str(), "short")         == 0) return SHORT        ;
  else if (strcmp(s.c_str(), "int")           == 0) return INT          ;
  else if (strcmp(s.c_str(), "long")          == 0) return LONG         ;
  else if (strcmp(s.c_str(), "char")          == 0) return CHAR         ;
  else if (strcmp(s.c_str(), "unicodeChar")   == 0) return UNICODECHAR  ;
  else if (strcmp(s.c_str(), "float")         == 0) return FLOAT        ;
  else if (strcmp(s.c_str(), "double")        == 0) return DOUBLE       ;
  else if (strcmp(s.c_str(), "floatComplex")  == 0) return FLOATCOMPLEX ;
  else if (strcmp(s.c_str(), "doubleComplex") == 0) return DOUBLECOMPLEX;
  else
    throw MCS_ERROR( MSG_VOT_INVALID_DATATYPE, s);
}


enum EncodingType Element::sto_EncodingType(string s)
{
  if      (strcmp(s.c_str(), "gzip")     == 0) return ENCODING_GZIP    ;
  else if (strcmp(s.c_str(), "base64")   == 0) return ENCODING_BASE64  ;
  else if (strcmp(s.c_str(), "dynamic")  == 0) return ENCODING_DYNAMIC ;
  else if (strcmp(s.c_str(), "none")     == 0) return ENCODING_NONE    ;
  else
    throw MCS_ERROR( MSG_VOT_INVALID_ENCODINGTYPE, s);
}


enum Resource_type Element::sto_Resource_type(string s)
{
  if      (strcmp(s.c_str(), "results")  == 0) return RESOURCE_RESULTS ;
  else if (strcmp(s.c_str(), "meta")     == 0) return RESOURCE_META    ;
  else
    throw MCS_ERROR( MSG_VOT_INVALID_RESOURCE_TYPE, s);
}


enum Field_type Element::sto_Field_type(string s)
{
  if      (strcmp(s.c_str(), "hidden")    == 0) return FIELD_HIDDEN   ;
  else if (strcmp(s.c_str(), "no_query")  == 0) return FIELD_NO_QUERY ;
  else if (strcmp(s.c_str(), "trigger")   == 0) return FIELD_TRIGGER  ;
  else if (strcmp(s.c_str(), "location")  == 0) return FIELD_LOCATION ;
  else
    throw MCS_ERROR( MSG_VOT_INVALID_FIELD_TYPE, s);
}


enum Values_Type Element::sto_Values_type(string s)
{
  if      (strcmp(s.c_str(), "legal")   == 0) return VALUES_LEGAL  ;
  else if (strcmp(s.c_str(), "actual")  == 0) return VALUES_ACTUAL ;
  else
    throw MCS_ERROR( MSG_VOT_INVALID_VALUES_TYPE, s);
}


enum Link_content_role Element::sto_Link_content_role(string s)
{
  if      (strcmp(s.c_str(), "query")    == 0) return LINK_QUERY    ;
  else if (strcmp(s.c_str(), "hints")    == 0) return LINK_HINTS    ;
  else if (strcmp(s.c_str(), "doc")      == 0) return LINK_DOC      ;
  else if (strcmp(s.c_str(), "location") == 0) return LINK_LOCATION ;
  else
    throw MCS_ERROR( MSG_VOT_INVALID_LINK_CONTENT_ROLE, s);
}


enum Stream_type Element::sto_Stream_type(string s)
{
  if      (strcmp(s.c_str(), "locator") == 0) return STREAM_TYPE_LOCATOR ;
  else if (strcmp(s.c_str(), "other")   == 0) return STREAM_TYPE_OTHER   ;
  else
    throw MCS_ERROR( MSG_VOT_INVALID_STREAM_TYPE, s);
}


enum Stream_actuate Element::sto_Stream_actuate(string s)
{
  if      (strcmp(s.c_str(), "onLoad")    == 0) return STREAM_ACTUATE_ONLOAD    ;
  else if (strcmp(s.c_str(), "onRequest") == 0) return STREAM_ACTUATE_ONREQUEST ;
  else if (strcmp(s.c_str(), "other")     == 0) return STREAM_ACTUATE_OTHER     ;
  else if (strcmp(s.c_str(), "none")      == 0) return STREAM_ACTUATE_NONE      ;
  else
    throw MCS_ERROR( MSG_VOT_INVALID_STREAM_ACTUATE, s);
}


enum Coosys_system Element::sto_Coosys_system(string s)
{
  if      (strcmp(s.c_str(), "eq_FK4")         == 0) return COOSYS_EQ_FK4        ;
  else if (strcmp(s.c_str(), "eq_FK5")         == 0) return COOSYS_EQ_FK5        ;
  else if (strcmp(s.c_str(), "ICRS")           == 0) return COOSYS_ICRS          ;
  else if (strcmp(s.c_str(), "ecl_FK4")        == 0) return COOSYS_ECL_FK4       ;
  else if (strcmp(s.c_str(), "ecl_FK5")        == 0) return COOSYS_ECL_FK5       ;
  else if (strcmp(s.c_str(), "galactic")       == 0) return COOSYS_GALACTIC      ;
  else if (strcmp(s.c_str(), "supergalactic")  == 0) return COOSYS_SUPERGALACTIC ;
  else if (strcmp(s.c_str(), "xy")             == 0) return COOSYS_XY            ;
  else if (strcmp(s.c_str(), "barycentric")    == 0) return COOSYS_BARYCENTRIC   ;
  else if (strcmp(s.c_str(), "geo_app")        == 0) return COOSYS_GEO_APP       ;
  else
    throw MCS_ERROR( MSG_VOT_INVALID_COOSYS_SYSTEM, s);
}



Element* Element::makeCopy()
{
  Element* n = NULL;

  switch (lnodetype) {
  case VOTABLE:      n = new VOTable    (*((VOTable    *) this)); break;
  case RESOURCE:     n = new Resource   (*((Resource   *) this)); break;
  case DESCRIPTION:  n = new Description(*((Description*) this)); break;
  case DEFINITIONS:  n = new Definitions(*((Definitions*) this)); break;
  case INFO:         n = new Info       (*((Info       *) this)); break;
  case PARAM:        n = new Param      (*((Param      *) this)); break;
  case TABLE:        n = new Table      (*((Table      *) this)); break;
  case FIELD:        n = new Field      (*((Field      *) this)); break;
  case GROUP:        n = new Group      (*((Group      *) this)); break;
  case FIELDref:     n = new FieldRef   (*((FieldRef   *) this)); break;
  case PARAMref:     n = new ParamRef   (*((ParamRef   *) this)); break;
  case VALUES:       n = new Values     (*((Values     *) this)); break;
  case MIN:          n = new Min        (*((Min        *) this)); break;
  case MAX:          n = new Max        (*((Max        *) this)); break;
  case OPTION:       n = new Option     (*((Option     *) this)); break;
  case LINK:         n = new Link       (*((Link       *) this)); break;
  case DATA:         n = new Data       (*((Data       *) this)); break;
  case TABLEDATA:    n = new Tabledata  (*((Tabledata  *) this)); break;
  case TD:           n = new Column     (*((Column     *) this)); break;
  case TR:           n = new Row        (*((Row        *) this)); break;
  case FITS:         n = new Fits       (*((Fits       *) this)); break;
  case BINARY:       n = new Binary     (*((Binary     *) this)); break;
  case STREAM:       n = new Stream     (*((Stream     *) this)); break;
  case COOSYS:       n = new Coosys     (*((Coosys     *) this)); break;
  }

  return n;
}








#define XML 0
#define BIN 1

char* VOTableReaderSplit::NodeStream[2] = { "<STREAM", "</STREAM" };

VOTableReaderSplit::VOTableReaderSplit() : URLReader()
{
  pMatch[XML] = NodeStream[XML];
  pMatch[BIN] = NodeStream[BIN];

  pMatchLen[XML] = strlen(NodeStream[XML]);
  pMatchLen[BIN] = strlen(NodeStream[BIN]);

  //SIMMETRY BREAKING: At the very start we deal with XML text
  sel = XML;
  nse = (sel + 1) % 2;

  bin_filecount = 1;
  bin_outfd = 0;
  bin_file_prefix = "";
  synchro.synchronize(true);

  lbinpipe = NULL;
  consumerReady = false;
}


VOTableReaderSplit::~VOTableReaderSplit()
{
  if (lbinpipe)
    lbinpipe->closeWrite();
}

//NOTE: this method must be called before OpenAs*
void VOTableReaderSplit::saveBinaryStream(string fn)
{
  bin_file_prefix = fn;
}


mcs::Pipe* VOTableReaderSplit::binpipe()
{
  if (lbinpipe   &&   (!consumerReady)) {
    synchro.enter();
    lbinpipe->create();
    consumerReady = true;
    synchro.leave();
  }

 return lbinpipe;
}


unsigned int VOTableReaderSplit::writeSplit(char* buf, unsigned int len)
{
  unsigned int ret = 0;
  unsigned int retbin = 0;

  if (sel == BIN) {

    if (! bin_file_prefix.empty()) {  //Save the stream on a file
      if (! bin_outfd) {  //Open output file

    char fn[100];
    sprintf(fn, "%s.%03d", bin_file_prefix.c_str(), bin_filecount);
    bin_filecount++;
    
    bin_outfd = ::open(fn,
               O_WRONLY | O_CREAT | O_TRUNC,
               S_IRUSR | S_IWUSR);
      }

      len = b64.decode(buf, len); //, buf);
      retbin = write(bin_outfd, b64.buffer(), b64.bufUsed());
    }

    else { //Write the stream on a Pipe object
      if (! lbinpipe) { //Output pipe need to be opened
    lbinpipe = new mcs::Pipe();

    //Ensures consumer knows we are writing on a different pipe
    while (1) {
      synchro.enter();
      if (consumerReady) {
        synchro.leave();
        break;
      }
      else {
        URLReader::Write((void*) "\n", 1, 1);
        URLReader::flush();
        synchro.leave();
        mcs::sleep_ms(1);
      }
    }
      }

      len = b64.decode(buf, len); //, buf);
      retbin = write(lbinpipe->getFD_write(), b64.buffer(), b64.bufUsed());
    }

    if (retbin != len)
      return 0; //ERROR
  }
  else {
    if (lbinpipe   ||   bin_outfd) {
      //Eventually write bytes left in b64 cache
      unsigned int l = b64.decode(buf, 0);

      if (bin_outfd) {
    retbin = write(bin_outfd, b64.buffer(), b64.bufUsed());
    ::close(bin_outfd);
    bin_outfd = 0;
      }
      else {
    retbin = write(lbinpipe->getFD_write(), b64.buffer(), b64.bufUsed());
    lbinpipe->closeWrite();
    delete lbinpipe;
    lbinpipe = NULL;
    
      }

      if (retbin != l)
    return 0; //ERROR
    }

    //Write on URLReader
    ret = URLReader::Write(buf, 1, len);
    if (ret != len)
      return 0;
  }

  //Must return exactly "len" bytes, otherwise CURL will raise an error
  return len;
}


unsigned int VOTableReaderSplit::Write(void *buf, unsigned int size,
                       unsigned int nmemb)
{
  char* p = (char*) buf;
  char* cur;
  char* start[2];
  start[sel] = p;
  start[nse] = NULL;
  size *= nmemb;
  nmemb = size; //nmemb will be used as return value

  while ((cur = (char*) memchr(p, '<', size))) {

    if (memcmp(cur, pMatch[sel], pMatchLen[sel]) == 0) {
      if (sel == XML) { //For xml data search for the end of STREAM tag
        cur = (char*) memchr(cur, '>', size);
        cur++;
      }
      start[nse] = cur;
    
      if (writeSplit(start[sel], cur - start[sel]) == 0)
        return 0; //An error occurred
    
      nse = sel;
      sel = (sel + 1) % 2;
    }

    size -= cur - p + 1;
    p = cur + 1;
  }

  if (writeSplit(start[sel], p + size - start[sel]) == 0)
    return 0;

  return nmemb;
}
















Parser_Stream::Parser_Stream() {
  flopen = false;
  lnode = NULL;
  nodeord = 0;
  pReader = malloc(sizeof(xmlTextReaderPtr));
  lbinstream = NULL;
}


Parser_Stream::~Parser_Stream() {
  close();
  free(pReader);
}

string Parser_Stream::filename() {
  return lfilename;
}


enum Nodetype Parser_Stream::nodeType() {
  return lnodetype;
}


unsigned int Parser_Stream::depth() {
  return ldepth;
}



NodePointer Parser_Stream::node() {
  NodePointer node;
  node.element = lnode;
  return node;
}




void Parser_Stream::open(string filename)
{
  if (! filename.empty()) {
    close();


    lfilename = filename;

    xmlTextReaderPtr* reader = (xmlTextReaderPtr*) pReader;

    //*reader = xmlNewTextReaderFilename(filename.c_str());
    //int ret = xmlTextReaderSetParserProp(reader, XML_PARSER_VALIDATE , 1);

    //filename = input.OpenAsFile(filename);
    //*reader = xmlReaderForFile(filename.c_str(), NULL, 0);
    //                 XML_PARSE_DTDATTR    | // default DTD attributes
    //                 XML_PARSE_NOENT      | // substitute entities
    //                 XML_PARSE_DTDVALID);   // validate with the DTD


    int fd = input.OpenAsFD(filename);
    *reader = xmlReaderForFd(fd, filename.c_str(), NULL, 0);

    //               XML_PARSE_DTDATTR |  // default DTD attributes
    //               XML_PARSE_NOENT |    // substitute entities
    //               XML_PARSE_DTDVALID); // validate with the DTD

    if (! reader)
      throw MCS_ERROR( MSG_VOT_CANT_OPEN_FILE, filename );

    flopen = true;
    //fleof = false;
    continue_read = false;
  }
}


void Parser_Stream::close() {
  if (flopen) {
    xmlTextReaderPtr* reader = (xmlTextReaderPtr*) pReader;

    xmlFreeTextReader(*reader);
    flopen = false;
    lnode = NULL;
    nodeord = 0;
  }
}




int Parser_Stream::parse() {
  int xml_type;
  string name, value;
  int ret;
  xmlChar* xmlval;

  xmlTextReaderPtr* reader = (xmlTextReaderPtr*) pReader;

  xml_type = xmlTextReaderNodeType(*reader);
  name = (char*) xmlTextReaderName(*reader);
  xmlval = xmlTextReaderValue(*reader);

  value = "";
  if (xmlval) {
    value = (char*) xmlval;
    xmlFree(xmlval);
  }

  switch(xml_type) {

  case XML_READER_TYPE_ELEMENT:
    flnewinfo = true;
    lnodetype = Element::sto_Nodetype(name);
    ldepth = xmlTextReaderDepth(*reader);

    //cout << "XML_READER_TYPE_ELEMENT " << name << " " << ldepth << endl;

    switch (lnodetype) {
    case VOTABLE:      lnode = &votable;      break;
    case RESOURCE:     lnode = &resource;     break;
    case DESCRIPTION:  lnode = &description;  break;
    case DEFINITIONS:  lnode = &definitions;  break;
    case INFO:         lnode = &info;         break;
    case PARAM:        lnode = &param;        break;
    case TABLE:        lnode = &table;        table.filename = lfilename;  break;
    case FIELD:        lnode = &field;        break;
    case GROUP:        lnode = &group;        break;
    case FIELDref:     lnode = &fieldref;     break;
    case PARAMref:     lnode = &paramref;     break;
    case VALUES:       lnode = &values;       break;
    case MIN:          lnode = &min;          break;
    case MAX:          lnode = &max;          break;
    case OPTION:       lnode = &option;       break;
    case LINK:         lnode = &link;         break;
    case DATA:         lnode = &data;         break;
    case TABLEDATA:    lnode = &tabledata;    break;
    case TD:           lnode = &column;       break;
    case TR:           lnode = &row;          break;
    case FITS:         lnode = &fits;         break;
    case BINARY:       lnode = &binary;       break;
    case STREAM:       lnode = &stream;       break;
    case COOSYS:       lnode = &coosys;       break;
    }

    lnode->reset();
    lnode->ldepth = ldepth;
    lnode->lord = nodeord;

    //Loop through the attributes
    while ((ret = xmlTextReaderMoveToNextAttribute(*reader))) {
      if (ret < 0)
    throw MCS_ERROR( MSG_VOT_PARSE_FAILED, lfilename);

      parse();
    }

    if ((nodeType() == DESCRIPTION)   ||
    (nodeType() == INFO)          ||
    (nodeType() == TD)
    )
      continue_read = true;

    if (nodeType() == STREAM) {
      ;
    }

    /*
    if (nodeType() == BINARY) {
      int len;
      xmlParserInputBufferPtr* input = (xmlParserInputBufferPtr*) pInput;

      while ((len = xmlParserInputBufferRead(*input, 1))) {
    char buf[10000];

    memcpy(buf, (*input)->buffer->content, len);
    buf[len] = '\0';

    cout  << buf << endl;

    if ((strchr(buf, '<'))   &&
        (strchr(buf, '/'))       )
      break;
      }
    }
    */

    break;

  case XML_READER_TYPE_END_ELEMENT:                      //cout << "XML_READER_TYPE_END_ELEMENT " << name << endl;
    continue_read = false;
    break;

  case XML_READER_TYPE_ATTRIBUTE:                        //cout << "XML_READER_TYPE_ATTRIBUTE "  << name << " = " << value << endl;

    if (! lnode->setAttribute(name, value)) {
      cerr << MCS_ERROR( MSG_VOT_UNEXPECTED_ATTRIBUTE, name).msg() << endl;
    }
    //throw MCS_ERROR( MSG_VOT_UNEXPECTED_ATTRIBUTE, name);

    break;

  case XML_READER_TYPE_TEXT:                             //cout << "XML_READER_TYPE_TEXT " << value << endl;

    if ( (lnodetype  == DESCRIPTION)   ||
     (lnodetype  == INFO)          ||
     (lnodetype  == TD)               )
      lnode->setAttribute("value", value);

    break;

  case XML_READER_TYPE_NONE:                             //IGNORED  //cout << "XML_READER_TYPE_NONE " << endl;
  case XML_READER_TYPE_SIGNIFICANT_WHITESPACE:           //cout << "XML_READER_TYPE_SIGNIFICANT_WHITESPACE "  << name << endl;
  case XML_READER_TYPE_WHITESPACE:                       //cout << "XML_READER_TYPE_WHITESPACE "  << name << endl;
  case XML_READER_TYPE_CDATA:                            //cout << "XML_READER_TYPE_CDATA "  << name << endl;
  case XML_READER_TYPE_ENTITY_REFERENCE:                 //cout << "XML_READER_TYPE_ENTITY_REFERENCE "  << name << endl;
  case XML_READER_TYPE_ENTITY:                           //cout << "XML_READER_TYPE_ENTITY "  << name << endl;
  case XML_READER_TYPE_PROCESSING_INSTRUCTION:           //cout << "XML_READER_TYPE_PROCESSING_INSTRUCTION "  << name << endl;
  case XML_READER_TYPE_COMMENT:                          //cout << "XML_READER_TYPE_COMMENT "  << name << endl;
  case XML_READER_TYPE_DOCUMENT:                         //cout << "XML_READER_TYPE_DOCUMENT " << name << endl;
  case XML_READER_TYPE_DOCUMENT_TYPE:                    //cout << "XML_READER_TYPE_DOCUMENT_TYPE " << name << endl;
  case XML_READER_TYPE_DOCUMENT_FRAGMENT:                //cout << "XML_READER_TYPE_DOCUMENT_FRAGMENT "  << name << endl;
  case XML_READER_TYPE_NOTATION:                         //cout << "XML_READER_TYPE_NOTATION "  << name << endl;
    break;

  default:
    cerr << MCS_ERROR( MSG_VOT_UNEXPECTED_NODE_TYPE, "", xml_type).msg() << endl;
    //throw MCS_ERROR( MSG_VOT_UNEXPECTED_NODE_TYPE, "", xml_type);
  }

  return xml_type;
}



int Parser_Stream::next_xmlnode(bool skipSubTree) {
  int ret;
  xmlTextReaderPtr* reader = (xmlTextReaderPtr*) pReader;

  if (skipSubTree) {
    int d = depth();

    do {
      ret = xmlTextReaderRead(*reader);
      nodeord++;
    }
    while ((ret == 1)   &&   (d != xmlTextReaderDepth(*reader)));
  }
  else {
    ret = xmlTextReaderRead(*reader);
    nodeord++;
  }

  if (ret < 0)
    throw MCS_ERROR( MSG_VOT_PARSE_FAILED, lfilename);

  return ret;
}




mcs::RecordSet* Parser_Stream::binstream()
{ return lbinstream; }

NodePointer Parser_Stream::next(bool skipSubTree) {
  flnewinfo = false;

  if (lbinstream) {
    delete lbinstream;
    lbinstream = NULL;
  }


  do {
    if (next_xmlnode(skipSubTree) == 0) {  //End of file
      lnode = NULL;
      break;
    }
    else
      parse();
  }
  while (
     (continue_read)  ||  //Nodes to be read in their entirety
     (! flnewinfo)
     );

  if (lnode)
    lnode->done();

  if ((nodeType() == STREAM)  &&  (node().element)) {
    if (input.binpipe()) {
      mcs::FITSReader* fits = new mcs::FITSReader();
      fits->open(input.binpipe()->getFD_read());
      lbinstream = fits;
    }
  }

  return node();
}


NodePointer Parser_Stream::skip(unsigned int n)
{
  for (; n>1; n--)
    next_xmlnode(false);

  next(false);
  return node();
}


void Parser_Stream::saveBinaryStream(string fn)
{ input.saveBinaryStream(fn); }







Parser_Tree::Parser_Tree(bool smartmode)
{
  this->smartmode = smartmode;
  lroot = NULL;
}


Parser_Tree::~Parser_Tree()
{
  free();
}

void Parser_Tree::free()
{
  if (lroot)
    delete lroot;
}


VOTable* Parser_Tree::root()
{
  return lroot;
}



void Parser_Tree::addNodes(Element* cur, unsigned int d) {
  Element* curchild = NULL;
  bool skip = false;

  static Element* last = lroot;  //The first time is set to the root node

  do {

    if (stream.depth() > d+1) {
      assert(stream.depth() == d+2);
      addNodes(curchild, d+1);
    }

    if (! stream.node().element)
      return;

    if (stream.depth() == d+1) {
      curchild = stream.node().element->makeCopy();
      last->setNext(curchild);
      last = curchild;

      if (! cur->setChild(curchild))
    throw MCS_ERROR( MSG_VOT_UNEXPECTED_NODE_TYPE, "", curchild->nodeType());
    }

    if (stream.depth() <= d)
      return;

    if (smartmode)
      switch (stream.node().element->nodeType()) {
      case TABLEDATA:
      case BINARY:
      case FITS:
    skip = true;
    break;
      default:
    skip = false;
      }

  }
  while (stream.next(skip).element);
}





void Parser_Tree::open(string filename)
{
  stream.saveBinaryStream(basename(filename.c_str()));
  stream.open(filename);

  stream.next();
  if (stream.nodeType() != VOTABLE)
    throw MCS_ERROR( MSG_VOT_ROOT_IS_NOT_VOTABLE, "", stream.node().element->nodeType());

  lroot = (VOTable*) stream.node().element->makeCopy();
  stream.next();

  addNodes(lroot, 0);
}













//Parser_Table::Parser_Table(Table& nodeTable) : RecordSet()
//{
//  fn = nodeTable.filename;
//  ord_nodeTable = nodeTable.ord();
//
//
//  stream.open(fn);
//  node = stream.skip(ord_nodeTable).element;
//}
//
//
//
//
//Parser_Table::Parser_Table(string fn, int tableOrd) : RecordSet()
//{
//  this->fn = fn;
//
//  stream.open(fn);
//  stream.next();
//  node = stream.node().element;
//
//  for (int i=0; i<tableOrd; i++) {
//    do {
//      if (stream.node().element->nodeType() == TABLE)
//  break;
//    }
//    while (stream.next().element);
//
//    stream.next();
//  }
//
//  if (! stream.node().element)  //End of file
//    ; //ERROR: table ord not found
//
//  searchStartData();
//}
//
//
//
//
//Parser_Table::~Parser_Table()
//{
//  stream.close();
//}
//
//
//
//
//void Parser_Table::searchStartData()
//{
//  //Prepare meta information and search the beginning of real data
//  do {
//   switch (node->nodeType()) {
//
//    case FIELD:
//      addMeta((*((Field*) node)));
//      break;
//
//    case TABLEDATA:
//      type = DATA_TABLEDATA;
//      goto exitloop;
//
//    case FITS:
//      type = DATA_FITS;
//      goto exitloop;
//
//    case BINARY:
//      type = DATA_BINARY;
//      goto exitloop;
//
//    default:
//      ;
//    }
//  }
//  while ((node = stream.next().element));
//
// exitloop:
//
//  init(MCS_RS_USEMETAREC, 0, &meta);
//  startFetch();
//}
//
//
//
//
//void Parser_Table::addMeta(Field& field)
//{
//  mcs::Data* d = NULL;
//  string s = field.arraysize();
//
//  /*
//  unsigned int d1, d2, d3, d4, d5;
//  bool foundDynamic = false;
//
//  //Store the dimension specification for later use during data reading.
//  arrsizes.push_back(field.arraysize());
//
//  //Calculate array dimensions
//  d1 = d2 = d3 = d4 = d5 = 1;
//  if (! field.arraysize_isNull()) {
//    vector<string> values = split(field.arraysize(), "x");
//
//    if (values.size() > 5)
//      ; //ERROR: we can handle up to five dimensions
//
//
//    for (i=0; i<values.size(); i++) {
//      if (foundDynamic)
//  ; //ERROR: there can be only one dynamic dimension and it must
//    //be the last.
//
//      string& s = values[i];
//
//      if (strchr(s.c_str(), '*')) {
//  //In a dimension spec there can be a *, meaning that effective
//  //size will be determined during data reading.
//  //
//  //If a number is present then it will be the maximum size,
//  //else the size is completely dynamic.
//
//  s.replace(s.find("*", 0), 1, " ");
//  foundDynamic = true;
//      }
//
//      switch (i) {
//      case 0:
//  d1 = stoi(values[i], false, 1);
//  break;
//  
//      case 1:
//  d2 = stoi(values[i], false, 1);
//  break;
//  
//      case 2:
//  d3 = stoi(values[i], false, 1);
//  break;
//  
//      case 3:
//  d4 = stoi(values[i], false, 1);
//  break;
//  
//      case 4:
//  d5 = stoi(values[i], false, 1);
//  break;
//      }
//    }
//  }
//  */
//
//
//
//  //Create appropriate mcs::Data objects
//  switch (field.datatype()) {
//
//  case CHAR:
//    d = new mcs::Data(mcs::STRING, 1, false, s);
//    break;
//
//  case UNICODECHAR:
//    //ERROR: type not handled
//    break;
//
//  case BOOLEAN:
//    d = new mcs::Data(mcs::TINY, 0, false, s);
//    break;
//
//  case BIT:
//    d = new mcs::Data(mcs::BLOB, 1, false, s);
//    break;
//
//  case UNSIGNEDBYTE:
//    d = new mcs::Data(mcs::TINY, 0, true, s);
//    break;
//
//  case SHORT:
//    d = new mcs::Data(mcs::SMALL, 0, false, s);
//    break;
//
//  case INT:
//    d = new mcs::Data(mcs::INT, 0, false, s);
//    break;
//
//  case LONG:
//    d = new mcs::Data(mcs::BIGINT, 0, false, s);
//    break;
//
//  case FLOAT:
//    d = new mcs::Data(mcs::FLOAT, 0, false, s);
//    break;
//
//  case DOUBLE:
//    d = new mcs::Data(mcs::DOUBLE, 0, false, s);
//    break;
//
//  case FLOATCOMPLEX:
//    d = new mcs::Data(mcs::FLOAT, 0, false, s);
//    break;
//
//  case DOUBLECOMPLEX:
//    //We need an extra dimension to handle real and imaginary part.
//    s = "2x" + s;
//    d = new mcs::Data(mcs::DOUBLE, 0, false, s);
//    break;
//
//  default:
//    ;
//    //ERROR
//  }
//
//  //Set name and add to the meta record.
//  d->setName(field.name());
//  meta.addField(d);
//}
//
//
//
//
//bool Parser_Table::fetch(unsigned int newpos, bool random) {
//  rec().clear();
//
//  switch (type) {
//  case DATA_TABLEDATA:
//    return fetch_tabledata(newpos, random);
//  case DATA_FITS:
//    return fetch_fits(newpos, random);
//  case DATA_BINARY:
//    return fetch_binary(newpos, random);
//  }
//
//  ; //ERROR: unexpected
//  return false;
//}
//
//
//bool Parser_Table::fetch_tabledata(unsigned int newpos, bool random)
//{
//  mcs::Data* d;
//  //unsigned int p, i1, i2, i3, i4, i5;
//  unsigned int p;
//  int i;
//  string s;
//
//  if (! node) {
//    stream.close();
//    return false;
//  }
//
//  //Search for start of record
//  if (node->nodeType() != TR) {
//    node = stream.next().element;
//
//    if (! node) {
//      stream.close();
//      return false;
//    }
//
//    if (node->nodeType() != TR) {
//      stream.close();
//      return false;  //End of file
//    }
//  }
//
//
//  //Search for first field
//  if (node->nodeType() != TD) {
//    node = stream.next().element;
//    if (node->nodeType() != TD)
//      ; //ERROR: unexpected node type
//  }
//
//
//  //There must be at least meta.count() fields.
//  for (i=0; i<meta.count(); i++) {
//    if (node->nodeType() != TD)
//      ; //ERROR
//
//    //Get a pointer to current Column node
//    Column* f = (Column*) node;
//
//    //Create a new mcs::Data object based on the correspondig template in the meta record
//    d = new mcs::Data(meta[i]);
//
//    if (f->value_isNull())
//      d->setNull();
//
//    else {
//      s = f->value();
//
//      if (! VarLenType(d->type())) {
//  vector<string> values = mcs::split(s, " ");
//  
//  if (values.size() > d->arraySize())
//    ; //ERROR there are more data than cells in the array
//  
//  for (p=0; p<values.size(); p++)
//    (*d)(p) = values[p];
//      }
//
//      else {
//  switch (d->type()) {
//  case mcs::STRING:
//    (*d)() = s;
//    break;
//  
//  case mcs::TINY_BLOB:
//    //ERROR: unexpected because no VOTable type is associated
//    //with TINY_BLOB
//    break;
//  
//  case mcs::BLOB:
//    break;
//
//  default:
//    ;//ERROR: unexpected
//  }
//      }
//    }
//
//    rec().addField(d);
//    node = stream.next().element;
//  }
//
//  return true;
//}
//
//
//bool Parser_Table::fetch_binary(unsigned int newpos, bool random)
//{
//  return false;
//}
//
//
//bool Parser_Table::fetch_fits(unsigned int newpos, bool random)
//{
//  return false;
//}
//
//
//
//
//
//
//
//
//
//
//Writer_Stream::Writer_Stream()
//{
//  level = 0;
//  flopen = 0;
//  node = NULL;
//  pWriter = malloc(sizeof(xmlTextWriterPtr));
//}
//
//Writer_Stream::~Writer_Stream()
//{
//  close();
//}
//
//
//void Writer_Stream::open(string filename, enum Data_format format, bool include)
//{
//  close();
//
//  xmlTextWriterPtr* writer = (xmlTextWriterPtr*) pWriter;
//  *writer = xmlNewTextWriterFilename(filename.c_str(), 0);
//
//  flopen = true;
//}
//
//
//void Writer_Stream::close()
//{
//  if (flopen) {
//
//    if (node)
//      delete node;
//
//    flopen = false;
//  }
//}
//
//
//const Writer_Stream& Writer_Stream::operator<<(Element* newnode)
//{
//  if (! node) {
//    if (newnode->nodeType() != VOTABLE)
//      ; //ERROR
//
//    node = (Element*) new VOTable(*((VOTable*) newnode));
//  }
//  else {
//    level++;
//    if (! node->setChild(newnode->makeCopy()))
//      ; //Error
//
//    node = newnode;
//  }
//
//  cout << Element::space_indent(level) << node->className() << endl;
//
//  return *this;
//}
//
//
//const Writer_Stream& Writer_Stream::operator<<(const int& endnode)
//{
//  int i;
//
//  for (i=0; i<endnode; i++) {
//    cout << Element::space_indent(level) << "---- " << node->className() << endl;
//
//    Element* p = node;
//    node = node->parent();
//    delete p;
//    level -= endnode;
//  }
//
//  return *this;
//}

---

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