xml/Xsil.hh

#ifndef _LIGO_XSIL_H
#define _LIGO_XSIL_H
/*----------------------------------------------------------------------*/
/*                                                                      */
/* Module Name: Xsil                                                    */
/*                                                                      */
/* Module Description: Utility classes for XML/XSIL input/output.       */
/*                                                                      */
/* Revision History:                                                    */
/* Rel   Date     Programmer    Comments                                */
/* 0.1   10Jun00  D. Sigg       First release                           */
/*                                                                      */
/* Documentation References:                                            */
/*      Man Pages: TLGXsil.html                                         */
/*      References: none                                                */
/*                                                                      */
/* Author Information:                                                  */
/* Name          Telephone       Fax             e-mail                 */
/* Daniel Sigg   (509) 372-8132  (509) 372-8137  sigg_d@ligo.mit.edu    */
/*                                                                      */
/*                                                                      */
/*                      -------------------                             */
/*                                                                      */
/*                             LIGO                                     */
/*                                                                      */
/*        THE LASER INTERFEROMETER GRAVITATIONAL WAVE OBSERVATORY.      */
/*                                                                      */
/*                     (C) The LIGO Project, 1999.                      */
/*                                                                      */
/*                                                                      */
/* Caltech                              MIT                             */
/* LIGO Project MS 51-33                LIGO Project NW-17 161          */
/* Pasadena CA 91125                    Cambridge MA 01239              */
/*                                                                      */
/* LIGO Hanford Observatory             LIGO Livingston Observatory     */
/* P.O. Box 1970 S9-02                  19100 LIGO Lane Rd.             */
/* Richland WA 99352                    Livingston, LA 70754            */
/*                                                                      */
/*----------------------------------------------------------------------*/

#include <iosfwd>
#include <iomanip>
#include <complex>
#include <string>
#include <map>
#include <vector>
#include "Time.hh"

#if defined(__SUNPRO_CC) && defined(G__DICTIONARY)
   namespace xml {}
   using namespace xml;
#endif

namespace xml {


   const char* const xmlVersion = "<?xml version=\"1.0\"?>";

   const char* const xmlDocType = 
   "<!DOCTYPE LIGO_LW [\n"
   "<!ELEMENT LIGO_LW ((LIGO_LW|Comment|Param|Time|Table|Array|Stream)*)>\n"
   "<!ATTLIST LIGO_LW Name CDATA #IMPLIED Type CDATA #IMPLIED>\n"
   "<!ELEMENT Comment (#PCDATA)>\n"
   "<!ELEMENT Param (#PCDATA)>\n"
   "<!ATTLIST Param Name CDATA #IMPLIED Type CDATA #IMPLIED Dim CDATA #IMPLIED\n"
   "                Unit CDATA #IMPLIED>\n"
   "<!ELEMENT Table (Comment?,Column*,Stream?)>\n"
   "<!ATTLIST Table Name CDATA #IMPLIED Type CDATA #IMPLIED>\n"
   "<!ELEMENT Column EMPTY>\n"
   "<!ATTLIST Column Name CDATA #IMPLIED Type CDATA #IMPLIED Unit CDATA #IMPLIED>\n"
   "<!ELEMENT Array (Dim*,Stream?)>\n"
   "<!ATTLIST Array Name CDATA #IMPLIED Type CDATA #IMPLIED>\n"
   "<!ELEMENT Dim (#PCDATA)>\n"
   "<!ATTLIST Dim Name CDATA #IMPLIED>\n"
   "<!ELEMENT Stream (#PCDATA)>\n"
   "<!ATTLIST Stream Name CDATA #IMPLIED Type (Remote|Local) \"Local\"\n"
   "          Delimiter CDATA \",\" Encoding CDATA #IMPLIED Content CDATA #IMPLIED>\n"
   "<!ELEMENT Time (#PCDATA)>\n"
   "<!ATTLIST Time Name CDATA #IMPLIED Type (GPS|Unix|ISO-8601) \"ISO-8601\">\n"
   "]>";
   // "<!DOCTYPE LIGO_LW SYSTEM "
   // "\"http://www.cacr.caltech.edu/projects/ligo_lw.dtd\">";

   const char* const xmlLigoLW = "LIGO_LW";

   const char* const xmlContainer = "LIGO_LW";
   const char* const xmlTable = "Table";
   const char* const xmlTime = "Time";
   const char* const xmlParam = "Param";
   const char* const xmlColumn = "Column";
   const char* const xmlArray = "Array";
   const char* const xmlDim = "Dim";
   const char* const xmlStream = "Stream";

   const char* const xmlName = "Name";
   const char* const xmlType = "Type";
   const char* const xmlFlag = "Flag";
   const char* const xmlComment = "Comment";
   const char* const xmlUnit = "Unit";
   const char* const xmlDelimiter = "Delimiter";
   const char* const xmlLink = "Link";
   const char* const xmlRef = "Ref";
   const char* const xmlEncode = "Encoding";
   const char* const xmlEncodeStd = "BigEndian,base64";
   const char* const xmlEncodeBE = "BigEndian,base64";
   const char* const xmlEncodeLE = "LittleEndian,base64";

   const char* const xmlObjTypeTestParameters = "TestParameters";
   const char* const xmlObjTypeTimeSeries = "TimeSeries";
   const char* const xmlObjTypeFrequencySeries = "FrequencySeries";
   const char* const xmlObjTypeSpectrum = "Spectrum";
   const char* const xmlObjTypeTransferFunction = "TransferFunction";
   const char* const xmlObjTypeCoefficients = "Coefficients";
   const char* const xmlObjTypeHistogram = "Histogram";
   const char* const xmlObjTypeSettings = "Settings";
   const char* const xmlObjTypeResult = "Result";

   const char* const xmlTagClosing = ">";

   const char* const xmlAttrName = " Name=\"";

   const char* const xmlAttrType = " Type=\"";

   const char* const xmlAttrFlag = " Flag=\"";

   const char* const xmlAttrUnit = " Unit=\"";

   const char* const xmlAttrDim = " Dim=\"";

   const char* const xmlAttrEncoding = " Encoding=\"";

   const char* const xmlAttrComment = " Comment=\"";

   const char* const xmlAttrClosing = "\"";


   enum gdsDataType {
   gds_void = 0,
   gds_int8 = 1, 
   gds_int16 = 2, 
   gds_int32 = 3, 
   gds_int64 = 4, 
   gds_float32 = 5, 
   gds_float64 = 6,
   gds_complex32 = 7, 
   gds_complex64 = 8, 
   gds_string = 9,
   gds_channel = 10,
   gds_bool = 11,
   gds_time = 12,
   gds_table = 13
   };

   class xsilIndent {
   protected:
      int               fLevel;
   public: 
      explicit xsilIndent (int level = 0) : fLevel (level) {
      }
      std::ostream& write (std::ostream& os) const;
   };


   class xsilTagBegin {
   protected:
      const char*       fTag;
   public: 
      explicit xsilTagBegin (const char* tag = 0) : fTag (tag) {
      }
      std::ostream& write (std::ostream& os) const;
   };


   class xsilTagEnd {
   protected:
      const char*       fTag;
   public: 
      explicit xsilTagEnd (const char* tag = 0) : fTag (tag) {
      }
      std::ostream& write (std::ostream& os) const;
   };


   class xsilDimAttr {
   protected:
      int               fDim;
   public:
      explicit xsilDimAttr (int dim = 0) : fDim (dim) {
      }
      std::ostream& write (std::ostream& os) const;
   };


   class xsilEncodingAttr {
   public:
      xsilEncodingAttr () {
      }
      std::ostream& write (std::ostream& os) const;
   };


template <class T>
   class xsilDataTypename {
   public:
      explicit xsilDataTypename () {
      }
   };


template <class T>
   class xsilBase64 {
   protected:
      const T*          fData;
      int               fN;
   public:
      xsilBase64 (const T* data = 0, int N = 0)
      : fData (data), fN (N) {
      }
      std::ostream& write (std::ostream& os) const;
   };


   std::ostream& base64encode (std::ostream& os, const char* p, 
                     int num, int elsize);
   bool base64decode (const char* code, int codelen,
                     char* p, int len, int ctype = 0);

   class xsil_base {
   protected:
      const char*       fName;
      const char*       fUnit;
      const char*       fComment;
      int               fLevel;
   public:
      explicit xsil_base (const char* name = 0, int level = 0)
      : fName (name), fUnit (0), fComment (0), fLevel(level) {
      }
      explicit xsil_base (const char* name, const char* unit, 
                        int level = 0)
      : fName (name), fUnit (unit), fComment (0), fLevel(level) {
      }
      void SetUnit (const char* unit) {
         fUnit = unit; }
      void SetComment (const char* comment) {
         fComment = comment; }
      std::ostream& write (std::ostream& os) const;
   };


   inline std::ostream& operator<< (std::ostream& os,
                     const xsilIndent& i) {
      return i.write (os); }
   inline std::ostream& operator<< (std::ostream& os,
                     const xsilTagBegin& t) {
      return t.write (os); }
   inline std::ostream& operator<< (std::ostream& os,
                     const xsilTagEnd& t) {
      return t.write (os); }
   inline std::ostream& operator<< (std::ostream& os,
                     const xsilDimAttr& d) {
      return d.write (os); }
   inline std::ostream& operator<< (std::ostream& os,
                     const xsilEncodingAttr& e) {
      return e.write (os); }
   inline std::ostream& operator<< (std::ostream& os,
                     const xsil_base& b) {
      return b.write (os); }
   inline std::ostream& operator<< (std::ostream& os,
                     const xsilDataTypename<bool>& t) {
      return (os << "boolean"); }
   inline std::ostream& operator<< (std::ostream& os,
                     const xsilDataTypename<char>& t) {
      return (os << "byte"); }
   inline std::ostream& operator<< (std::ostream& os,
                     const xsilDataTypename<short>& t) {
      return (os << "short"); }
   inline std::ostream& operator<< (std::ostream& os,
                     const xsilDataTypename<int>& t) {
      return (os << "int"); }
#ifndef __CINT__
   inline  std::ostream& operator<< (std::ostream& os,
                     const xsilDataTypename<long long>& t) {
      return (os << "long"); }
#endif
   inline std::ostream& operator<< (std::ostream& os,
                     const xsilDataTypename<float>& t) {
      return (os << "float"); }
   inline std::ostream& operator<< (std::ostream& os,
                     const xsilDataTypename<double>& t) {
      return (os << "double"); }
   inline std::ostream& operator<< (std::ostream& os,
                     const xsilDataTypename<std::complex<float> >& t) {
      return (os << "floatComplex"); }
   inline std::ostream& operator<< (std::ostream& os,
                     const xsilDataTypename<std::complex<double> >& t) {
      return (os << "doubleComplex"); }
   inline std::ostream& operator<< (std::ostream& os,
                     const xsilDataTypename<const char*>& t) {
      return (os << "string"); }
   inline std::ostream& operator<< (std::ostream& os,
                     const xsilDataTypename<std::string>& t) {
      return (os << "string"); }
   inline std::ostream& operator<< (std::ostream& os,
                     const xsilDataTypename<Time>& t) {
      return (os << "time"); }
   struct xsil_table {
   };
   inline std::ostream& operator<< (std::ostream& os,
                     const xsilDataTypename<xml::xsil_table>& t) {
      return (os << "table"); }

   class xsilHeader {
   public: 
      xsilHeader () {
      }
      std::ostream& write (std::ostream& os) const;
   };


   class xsilTrailer {
   public:
      xsilTrailer () {
      }
      std::ostream& write (std::ostream& os) const;
   };


   class xsilComment : public xsil_base {
   public:
      xsilComment (const char* comment, int level = 2)
      : xsil_base (comment, level) {
      }
      xsilComment (const std::string& comment, int level = 2)
      : xsil_base (comment.c_str(), level) {
      }
      std::ostream& write (std::ostream& os) const;
   };

   class xsilTime : public xsil_base {
   public:
      typedef unsigned long gdstime_t;
   
   protected:
      gdstime_t         fSec;
      gdstime_t         fNSec;
   public:
      xsilTime (const char* name, const Time& time, 
               int level = 2)
      : xsil_base (name, level), fSec (time.getS()), fNSec (time.getN()) {
      }
      xsilTime (const char* name, gdstime_t sec, gdstime_t nsec, 
               int level = 2)
      : xsil_base (name, level), fSec (sec), fNSec (nsec) {
      }
      std::ostream& write (std::ostream& os, int format = 1) const;
   };

template <class T>
   class xsilParameter : public xsil_base {
   protected:
      const T*          fData;
      int               fN;
   public:
      xsilParameter() : fData (0), fN (0) {
      }
      xsilParameter (const char* name, const T& x, int N = 1, int level = 2)
      : xsil_base (name, level), fData (&x), fN (N) {
      }
      xsilParameter (const char* name, const char* unit, const T& x, 
                    int N = 1, int level = 2)
      : xsil_base (name, unit, level), fData (&x), fN (N) {
      }
      std::ostream& write (std::ostream& os) const;
   };


template <class T>
   class xsilArray : public xsil_base {
   protected:
      int               fDim[4];
      const T*          fData;
   
   public:
      xsilArray () : fData (0) {
         fDim[0] = 0; fDim[1] = 0; fDim[2] = 0; fDim[3] = 0; }
      xsilArray (const char* name, int dim1, 
                const T* data, int level = 2)
      : xsil_base (name, level), fData (data) {
         fDim[0] = dim1; fDim[1] = 0; fDim[2] = 0; fDim[3] = 0; }
      xsilArray (const char* name, 
                int dim1, int dim2, const T* data, int level = 2)
      : xsil_base (name, level), fData (data) {
         fDim[0] = dim1; fDim[1] = dim2; fDim[2] = 0; fDim[3] = 0; }
      xsilArray (const char* name, int dim1, int dim2, int dim3, 
                const T* data, int level = 2)
      : xsil_base (name, level), fData (data) {
         fDim[0] = dim1; fDim[1] = dim2; fDim[2] = dim3; fDim[3] = 0; }
      xsilArray (const char* name, 
                int dim1, int dim2, int dim3, int dim4,
                const T* data, int level = 2)
      : xsil_base (name, level), fData (data) {
         fDim[0] = dim1; fDim[1] = dim2; fDim[2] = dim3; fDim[3] = dim4; }
      std::ostream& write (std::ostream& os, bool term = true) const;
   };


   class xsilDataBegin : public xsil_base {
   protected:
      const char*       fType;
      const char*       fFlag;
   public:
      xsilDataBegin (const char* name, const char* type, int level = 1) 
      : xsil_base (name, level), fType (type), fFlag (0) {
      }
      xsilDataBegin (const char* name, const char* type, 
                    const char* flag, int level = 1) 
      : xsil_base (name, level), fType (type), fFlag (flag) {
      }
      std::ostream& write (std::ostream& os) const;
   };


template <class T>
   class xsilDataEnd  {
   protected:
      int               fLevel;
      int               fDim[4];
      const T*          fData;
   public:
      xsilDataEnd (int level = 1) 
      : fLevel (level), fData (0) {
         fDim[0] = 0; fDim[1] = 0; fDim[2] = 0; fDim[3] = 0; }
      xsilDataEnd (int dim1, const T* data, int level = 1)
      : fLevel (level), fData (data) {
         fDim[0] = dim1; fDim[1] = 0; fDim[2] = 0; fDim[3] = 0; }
      xsilDataEnd (int dim1, int dim2, const T* data, int level = 1)
      : fLevel (level), fData (data) {
         fDim[0] = dim1; fDim[1] = dim2; fDim[2] = 0; fDim[3] = 0; }
      xsilDataEnd (int dim1, int dim2, int dim3,
                  const T* data, int level = 1)
      : fLevel (level), fData (data) {
         fDim[0] = dim1; fDim[1] = dim2; fDim[2] = dim3; fDim[3] = 0; }
      xsilDataEnd (int dim1, int dim2, int dim3, int dim4,
                  const T* data, int level = 1)
      : fLevel (level), fData (data) {
         fDim[0] = dim1; fDim[1] = dim2; fDim[2] = dim3; fDim[3] = dim4; }
      std::ostream& write (std::ostream& os, bool term = true) const;
   };


   class xsilTableBegin : public xsil_base {
   protected:
      const char*       fType;
   public:
      xsilTableBegin (const char* name, const char* type = 0, int level = 1) 
      : xsil_base (name, level), fType (type) {
      }
      std::ostream& write (std::ostream& os) const;
   };


   class xsilTableEnd {
   protected:
      int               fLevel;
   public:
      xsilTableEnd (int level = 1) : fLevel (level) {
      }
      std::ostream& write (std::ostream& os) const;
   };


template <class T>
   class xsilTableColumn : public xsil_base {
   public:
      xsilTableColumn (const char* name = 0, int level = 2)
      : xsil_base (name, level) {
      }
      std::ostream& write (std::ostream& os) const;
   };


   class xsilTableDataBegin : public xsil_base {
   public:
      xsilTableDataBegin (const char* name = 0, int level = 2) 
      : xsil_base (name, level) {
      }
      std::ostream& write (std::ostream& os) const;
   };


   class xsilTableDataEnd {
   protected:
      int               fLevel;
   public:
      xsilTableDataEnd (int level = 2) : fLevel (level) {
      }
      std::ostream& write (std::ostream& os) const;
   };


  template <class T>
  class xsilTableEntry {
  protected:
    const T*            fValue;
  public:
    xsilTableEntry() 
      : fValue (0) 
    {}
   
    xsilTableEntry (const T& value)
      : fValue (&value)
    {}

    std::ostream& write (std::ostream& os) const;
  };

template <>
   std::ostream& xsilTableEntry<std::complex<double> >::write (std::ostream& os) const;


template <>
   std::ostream& xsilTableEntry<Time>::write (std::ostream& os) const;

template <>
   class xsilTableEntry<const char*> {
   protected:
      const char*       fValue;
      int               fLength;
   public:
      xsilTableEntry<const char*> (const char* value = 0)
      : fValue (value), fLength (-1) {
      }
      xsilTableEntry<const char*> (const char* value, int len)
      : fValue (value), fLength (len) {
      }
      std::ostream& write (std::ostream& os) const;
   };

   std::string xsilStringEscape (const char* p);
   std::string xsilEscape (const char* p, int len);
   std::string xsilUnescape (const char* p);


   class xsilTableEntryDelimiter {
   public:
      xsilTableEntryDelimiter() {
      }
      std::ostream& write (std::ostream& os) const;
   };


   inline std::ostream& operator<< (std::ostream& os,
                     const xsilHeader& h) {
      return h.write(os); }
   inline std::ostream& operator<< (std::ostream& os,
                     const xsilTrailer& t) {
      return t.write(os); }

template <class T>
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilParameter<T>& p) {
      return p.write (os); }

   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilComment& t) {
      return t.write (os); }

   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTime& t) {
      return t.write (os); }

template <class T>
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilArray<T>& arr) {
      return arr.write (os); }

   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilDataBegin& d) {
      return d.write (os); }

template <class T>
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilDataEnd<T>& d) {
      return d.write (os); }

   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableBegin& d) {
      return d.write (os); }

   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableEnd& d) {
      return d.write (os); }

template <class T>
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableColumn<T>& d) {
      return d.write (os); }

   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableDataBegin& d) {
      return d.write (os); }

   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableDataEnd& d) {
      return d.write (os); }

template <class T>
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableEntry<T>& d) {
      return d.write (os); }

   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableEntryDelimiter& d) {
      return d.write (os); }


#ifdef __CINT__
//    inline std::ostream& operator<< (std::ostream& os, 
//                       const xsilParameter<bool>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilParameter<char>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilParameter<short>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilParameter<int>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilParameter<float>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilParameter<double>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilParameter<std::complex<float> >& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilParameter<std::complex<double> >& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilParameter<const char*>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilArray<float>& arr);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilArray<double>& arr);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilArray<std::complex<float> >& arr);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilArray<std::complex<double> >& arr);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilDataEnd<float>& d);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilDataEnd<double>& d);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilDataEnd<std::complex<float> >& d);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilDataEnd<std::complex<double> >& d);
//   inline std::ostream& operator<< (std::ostream& os, 
//                       const xsilTableColumn<bool>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableColumn<char>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableColumn<short>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableColumn<int>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableColumn<float>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableColumn<double>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableColumn<std::complex<float> >& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableColumn<std::complex<double> >& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableColumn<Time>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableColumn<const char*>& p);
//   inline std::ostream& operator<< (std::ostream& os, 
//                       const xsilTableEntry<bool>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableEntry<char>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableEntry<short>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableEntry<int>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableEntry<float>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableEntry<double>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableEntry<std::complex<float> >& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableEntry<std::complex<double> >& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableEntry<Time>& p);
   inline std::ostream& operator<< (std::ostream& os, 
                     const xsilTableEntry<const char*>& p);
#endif

   class xsilHandler {
   protected:
      bool              fIgnoreNested;
      std::string       fComment;
      std::string       fUnit;
   public:
      typedef std::map<std::string, std::string> attrlist;
   
      explicit xsilHandler (bool ignore = false) :
      fIgnoreNested (ignore) {
      }
      virtual ~xsilHandler() {
      }
      virtual bool CommentHandler (const std::string& comment);
   
      virtual bool ParameterHandler (int type, void* x, int size,
                        const attrlist& attr);
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const bool& p, int N = 1) {
         return false; }
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const char& p, int N = 1) {
         return false; }
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const short& p, int N = 1) {
         return false; }
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const int& p, int N = 1) {
         return false; }
   #ifndef __CINT__
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const long long& p, int N = 1) {
         return false; }
   #endif
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const float& p, int N = 1) {
         return false; }
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const double& p, int N = 1) {
         return false; }
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const std::complex<float>& p, int N = 1) {
         return false; }
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const std::complex<double>& p, int N = 1) {
         return false; }
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const std::string& p) {
         return false; }
   
      virtual bool HandleTime (const std::string& name,
                        const attrlist& attr,
                        unsigned long sec, unsigned long nsec) {
         return false; }
   
      virtual bool DataHandler (const std::string& name,
                        int type, void* x, int size, 
                        int dim1, int dim2 = 0, int dim3 = 0,
                        int dim4 = 0);
      virtual bool HandleData (const std::string& name,
                        float* x, int dim1, int dim2 = 0, 
                        int dim3 = 0, int dim4 = 0) {
         return false; }
      virtual bool HandleData (const std::string& name,
                        std::complex<float>* x, 
                        int dim1, int dim2 = 0, 
                        int dim3 = 0, int dim4 = 0) {
         return false; }
      virtual bool HandleData (const std::string& name,
                        double* x, int dim1, int dim2 = 0, 
                        int dim3 = 0, int dim4 = 0) {
         return false; }
      virtual bool HandleData (const std::string& name,
                        std::complex<double>* x, 
                        int dim1, int dim2 = 0, 
                        int dim3 = 0, int dim4 = 0) {
         return false; }
   
      virtual bool HandleTableColumn (int col, const std::string& name,
                        int type, const attrlist& attr) {
         return false; }
   
      virtual bool TableEntryHandler (int row, int col, int type, 
                        void* x);
      virtual bool HandleTableEntry (int row, int col, bool p) {
         return false; }
      virtual bool HandleTableEntry (int row, int col, char p) {
         return false; }
      virtual bool HandleTableEntry (int row, int col, short p) {
         return false; }
      virtual bool HandleTableEntry (int row, int col, int p) {
         return false; }
   #ifndef __CINT__
      virtual bool HandleTableEntry (int row, int col, long long p) {
         return false; }
   #endif
      virtual bool HandleTableEntry (int row, int col, float p) {
         return false; }
      virtual bool HandleTableEntry (int row, int col, double p) {
         return false; }
      virtual bool HandleTableEntry (int row, int col,
                        const std::complex<float>& p) {
         return false; }
      virtual bool HandleTableEntry (int row, int col,
                        const std::complex<double>& p) {
         return false; }
      virtual bool HandleTableEntry (int row, int col, const Time& p) {
         return false; }
      virtual bool HandleTableEntry (int row, int col,
                        const std::string& p) {
         return false; }
   
      virtual xsilHandler* GetHandler (const attrlist& attr) {
         return fIgnoreNested ? new xsilHandler (true) : 0; }
      virtual xsilHandler* GetTableHandler (const attrlist& attr) {
         return fIgnoreNested ? new xsilHandler (true) : 0; }
   };


   class xsilHandlerQuery {
   public:
      typedef std::map<std::string, std::string> attrlist;
      xsilHandlerQuery() {
      }
      virtual ~xsilHandlerQuery() {
      }
      virtual xsilHandler* GetHandler (const attrlist& attr) = 0;
      virtual xsilHandler* GetTableHandler (const attrlist& attr) {
         return 0; }
   };


   class xsilHandlerUnknown : public xsilHandler {
      xsilHandlerUnknown (const xsilHandlerUnknown&);
      xsilHandlerUnknown& operator= (const xsilHandlerUnknown&);
   
   public:
      explicit xsilHandlerUnknown (std::ostream& os, 
                        const attrlist* attr = 0, bool ignore = false);
      virtual ~xsilHandlerUnknown();
   
      virtual bool CommentHandler (const std::string& comment);
   
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const bool& p, int N = 1);
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const char& p, int N = 1);
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const short& p, int N = 1);
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const int& p, int N = 1);
   #ifndef __CINT__
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const long long& p, int N = 1);
   #endif
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const float& p, int N = 1);
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const double& p, int N = 1);
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const std::complex<float>& p, int N = 1);
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr,
                        const std::complex<double>& p, int N = 1);
      virtual bool HandleParameter (const std::string& name,
                        const attrlist& attr, const std::string& p);
      virtual bool HandleTime (const std::string& name,
                        const attrlist& attr,
                        unsigned long sec, unsigned long nsec);
      virtual bool HandleData (const std::string& name,
                        float* x, int dim1, int dim2 = 0, 
                        int dim3 = 0, int dim4 = 0);
      virtual bool HandleData (const std::string& name,
                        std::complex<float>* x, 
                        int dim1, int dim2 = 0, 
                        int dim3 = 0, int dim4 = 0);
      virtual bool HandleData (const std::string& name,
                        double* x, int dim1, int dim2 = 0, 
                        int dim3 = 0, int dim4 = 0);
      virtual bool HandleData (const std::string& name,
                        std::complex<double>* x, 
                        int dim1, int dim2 = 0, 
                        int dim3 = 0, int dim4 = 0);
   
   protected:
      std::ostream*     fOs;
      bool              fTrailer;
      int               fDim[4];
      bool              fComplex;
      bool              fDouble;
      void*             fData;
   
   };


   class xsilHandlerQueryUnknown : public xml::xsilHandlerQuery {
   public:
      xsilHandlerQueryUnknown (std::ostream* os) : fOs (os) {
      }
      virtual xsilHandler* GetHandler (const attrlist& attr);
   
   protected:
      std::ostream*             fOs;
   };

   class xsilHandlerPtr {
      mutable xsilHandler* ptr;
   public:

      explicit xsilHandlerPtr (xsilHandler* x = 0) : ptr (x) {
      }
      xsilHandlerPtr (const xsilHandlerPtr& p) : ptr (0) {
         *this = p; }
      ~xsilHandlerPtr() {
         if (ptr) delete ptr; }

      xsilHandlerPtr& operator= (const xsilHandlerPtr& p) {
         if (this != &p) {
            ptr = p.ptr; p.ptr = 0;
         }
         return *this; }

      xsilHandler& operator* () const {
         return *ptr; }

      xsilHandler* operator-> () const {
         return ptr; }

      bool operator== (const xsilHandler* p) {
         return (ptr == p); }

      bool operator!= (const xsilHandler* p) {
         return (ptr != p); }
   };


   class xsilHandlerTemp {
   
   public:
      enum status {
      // normal
      normal = 0,
      // parameter
      param = 1,
      // time
      time = 2,
      // column
      column = 3,
      // stream
      stream = 4,
      // array
      array = 5,
      // array dim
      arraydim = 6,
      // array stream 
      arraystream = 7,
      // comment
      comment = 8
      };
      typedef std::map<std::string, std::string> attrlist;
      typedef std::vector <int> columnlist;
   
      bool              fIsTable;
      status            fStatus;
      xsilHandlerPtr    fHandler;
      std::string       fComment;
      std::string       fText;
      std::string       fDataName;
      int               fDataType;
      char*             fData;
      int               fSize;
      std::vector<int>  fDim;
      int               fEncoding;
      attrlist          fPrmAttr;
      std::string       fPrmName;
      int               fPrmType;
      int               fPrmSize;
      columnlist        fColumns;
      int               fColumn;
      int               fRow;
      bool              fIgnoreNextComma;
   
      xsilHandlerTemp(xsilHandler* handler, bool istable = false)
      : fIsTable (istable), fStatus  (normal), fHandler (handler), 
      fData (0), fColumn (0), fRow (0), fIgnoreNextComma (false) {
      }
      ~xsilHandlerTemp() {
         SetData (0); } 
      void SetData (char* dat) {
         if (fData) delete [] fData; 
         fData = dat; }
      bool FlushTableEntries (bool comma = false);
      bool SetTableEntry();
   
   };

   class xsilParser {
   public:
      typedef std::map<std::string, std::string> attrlist;
      typedef std::vector<xsilHandlerQuery*> handlerquerylist;
      typedef std::vector<xsilHandlerTemp> worklist;
   
      static xsilHandlerQuery& DefaultHandler();
      static xsilHandlerQuery& IgnoreAllHandler();
   
   protected:
      handlerquerylist  fHandler;
      int               fIgnore;
      bool              fNewLine;
      bool              fEndXML;
      worklist          fWork;
      void*             fXML;
   
   public:
      xsilParser ();
      ~xsilParser();
      void Init();
      void Done();
   
      void AddHandler (xsilHandlerQuery& handler);
      bool Parse (const char* p, int len);
      bool Parse (const std::string& s) {
         return Parse (s.c_str(), s.size()); }
      bool Parse (std::istream& is);
      bool ParseFile (const char* filename);
   
   public:
      void Startelement (const char* name, const attrlist& attr);
      void Texthandler (const char* text, int len);
      void Endelement (const char* name);
   };
#ifndef __CINT__

// Template defintions: Due to a strange SUN/C++ bug (generating 
// undefined symbols for string constants) these definitions
// have to be in the header and have to be declared inline.

// xsilBase64: XML base64 object 
template <class T>
inline std::ostream& xsilBase64<T>::write (std::ostream& os) const 
{
  return base64encode (os, (const char*) fData, fN, sizeof (T));
}

// xsilParameter: XML parameter object
template <class T>
   inline std::ostream& xsilParameter<T>::write (std::ostream& os) const 
   {
      os << xsilIndent (fLevel) << xsilTagBegin (xmlParam);
      this->xsil_base::write (os);
      os << xmlAttrType << xsilDataTypename<T>() << xmlAttrClosing <<
         xsilDimAttr (fN) << xmlTagClosing;
      for (int i = 0; i < fN; i++) {
         os << (i > 0 ? " " : "") << fData[i];
      }
      return (os << xsilTagEnd (xmlParam));
   }

// xsilParameter: XML parameter object (string specialization)
template <>
   inline std::ostream& xsilParameter<const char*>::write (std::ostream& os) const 
   {
      os << xsilIndent (fLevel) << xsilTagBegin (xmlParam);
      this->xsil_base::write (os);
      os << xmlAttrType << xsilDataTypename<const char*>() << xmlAttrClosing 
         << xsilDimAttr (fN) << xmlTagClosing;
      for (int i = 0; i < fN; i++) {
         os << (i > 0 ? "\n" : "") << xsilStringEscape (fData[i]);
      }
      return (os << xsilTagEnd (xmlParam));
   }

// xsilArray: XML array object
template <class T>
   inline std::ostream& xsilArray<T>::write (std::ostream& os, 
                     bool term) const 
   {
      int fN = 1;
      bool nValid = false;
      for (int i = 0; i < 4; ++i) {
         if (fDim[i] > 0) {
            fN *= fDim[i];
            nValid = true;
         }
      }
      if (!nValid) fN = 0;
      if ((fData != 0) && (fN > 0)) {
         os << xsilIndent (fLevel) << xsilTagBegin (xmlArray); 
         xsil_base::write (os);
         os << xmlAttrType << xsilDataTypename<T>() << xmlAttrClosing <<
            xmlTagClosing << std::endl;
         for (int i = 0; i < 4; ++i) {
            if (fDim[i] > 0) {
               os << xsilIndent (fLevel+1) << xsilTagBegin (xmlDim) << 
                  xmlTagClosing << fDim[i] << xsilTagEnd (xmlDim) << 
                  std::endl;
            }
         }
         os << xsilIndent (fLevel+1) << xsilTagBegin (xmlStream) << 
            xsilEncodingAttr() << xmlTagClosing << std::endl;
         xsilBase64<T> (fData, fN).write (os);
         os << xsilIndent (fLevel+1) << xsilTagEnd (xmlStream) << 
            std::endl;
         os << xsilIndent (fLevel) << xsilTagEnd (xmlArray);
      }
      return os; 
   }

// xsilDataEnd: XML data end object
template <class T>
   inline std::ostream& xsilDataEnd<T>::write (std::ostream& os, 
                     bool term) const 
   {
      os << xsilArray<T> (0, fDim[0], fDim[1], fDim[2], fDim[3],
                         fData, fLevel + 1) << std::endl; 
      if (term) 
         os << xsilIndent (fLevel) << xsilTagEnd (xmlContainer);
      return os; 
   }

// xsilTableColumn: XML table column object
template <class T>
   inline std::ostream& xsilTableColumn<T>::write (std::ostream& os) const
   {
      os << xsilIndent (fLevel) << xsilTagBegin (xmlColumn);
      this->xsil_base::write (os);
      os << xmlAttrType << xsilDataTypename<T>() << xmlAttrClosing
         << "/" << xmlTagClosing;
      return os;
   }

// xsilTableEntry: XML table entry object
template <class T>
   inline std::ostream& xsilTableEntry<T>::write (std::ostream& os) const
   {
      if (fValue) os << *fValue;
      return os;
   }

  template<>
  inline std::ostream& 
  xsilTableEntry<std::complex<double> >::write (std::ostream& os) const {
      if (fValue) os << fValue->real() << " " << fValue->imag();
      return os;
  }

  template<> 
  inline std::ostream& 
  xsilTableEntry<Time>::write (std::ostream& os) const
   {
      char buf[64];
      TimeStr (*fValue, buf, "%s.%n");
      os << buf;
      return os;
   }

  // xsilTableEntry: XML table entry object (string specialization)
  inline std::ostream& 
  xsilTableEntry<const char*>::write (std::ostream& os) const
   {
      if (fValue) os << "\"" << xsilEscape (fValue, fLength) << "\"";
      return os;
   }

  /*******************************************************************
   *  Finish up....
   *  \endcond
   */

#endif // __CINT__
}

#endif // _LIGO_XSIL_H

---