Database.h

Go to the documentation of this file.

// Copyright (c) 2005-2014 Code Synthesis Tools CC
//
// This program was generated by CodeSynthesis XSD, an XML Schema to
// C++ data binding compiler.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// This program 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 this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
//
// In addition, as a special exception, Code Synthesis Tools CC gives
// permission to link this program with the Xerces-C++ library (or with
// modified versions of Xerces-C++ that use the same license as Xerces-C++),
// and distribute linked combinations including the two. You must obey
// the GNU General Public License version 2 in all respects for all of
// the code used other than Xerces-C++. If you modify this copy of the
// program, you may extend this exception to your version of the program,
// but you are not obligated to do so. If you do not wish to do so, delete
// this exception statement from your version.
//
// Furthermore, Code Synthesis Tools CC makes a special exception for
// the Free/Libre and Open Source Software (FLOSS) which is described
// in the accompanying FLOSSE file.
//

#ifndef CXX______CONFIG_DATABASE_H
#define CXX______CONFIG_DATABASE_H

#ifndef XSD_CXX11
#define XSD_CXX11
#endif

#ifndef XSD_USE_CHAR
#define XSD_USE_CHAR
#endif

#ifndef XSD_CXX_TREE_USE_CHAR
#define XSD_CXX_TREE_USE_CHAR
#endif

// Begin prologue.
//
//
// End prologue.

#include <xsd/cxx/config.hxx>

#if (XSD_INT_VERSION != 4000000L)
#error XSD runtime version mismatch
#endif

#include <xsd/cxx/pre.hxx>

#include <xsd/cxx/xml/char-utf8.hxx>

#include <xsd/cxx/tree/exceptions.hxx>
#include <xsd/cxx/tree/elements.hxx>
#include <xsd/cxx/tree/types.hxx>

#include <xsd/cxx/xml/error-handler.hxx>

#include <xsd/cxx/xml/dom/auto-ptr.hxx>

#include <xsd/cxx/tree/parsing.hxx>
#include <xsd/cxx/tree/parsing/byte.hxx>
#include <xsd/cxx/tree/parsing/unsigned-byte.hxx>
#include <xsd/cxx/tree/parsing/short.hxx>
#include <xsd/cxx/tree/parsing/unsigned-short.hxx>
#include <xsd/cxx/tree/parsing/int.hxx>
#include <xsd/cxx/tree/parsing/unsigned-int.hxx>
#include <xsd/cxx/tree/parsing/long.hxx>
#include <xsd/cxx/tree/parsing/unsigned-long.hxx>
#include <xsd/cxx/tree/parsing/boolean.hxx>
#include <xsd/cxx/tree/parsing/float.hxx>
#include <xsd/cxx/tree/parsing/double.hxx>
#include <xsd/cxx/tree/parsing/decimal.hxx>

#include <xsd/cxx/xml/dom/serialization-header.hxx>
#include <xsd/cxx/tree/serialization.hxx>
#include <xsd/cxx/tree/serialization/byte.hxx>
#include <xsd/cxx/tree/serialization/unsigned-byte.hxx>
#include <xsd/cxx/tree/serialization/short.hxx>
#include <xsd/cxx/tree/serialization/unsigned-short.hxx>
#include <xsd/cxx/tree/serialization/int.hxx>
#include <xsd/cxx/tree/serialization/unsigned-int.hxx>
#include <xsd/cxx/tree/serialization/long.hxx>
#include <xsd/cxx/tree/serialization/unsigned-long.hxx>
#include <xsd/cxx/tree/serialization/boolean.hxx>
#include <xsd/cxx/tree/serialization/float.hxx>
#include <xsd/cxx/tree/serialization/double.hxx>
#include <xsd/cxx/tree/serialization/decimal.hxx>

#include <iostream>
#include <fstream>
#include <stdint.h>
#include <NovaDAQUtilities/XMLDeserializationRegistry.h>

namespace xml_schema
{
  // anyType and anySimpleType.
  //
  typedef ::xsd::cxx::tree::type type;
  typedef ::xsd::cxx::tree::simple_type< char, type > simple_type;
  typedef ::xsd::cxx::tree::type container;

  // 8-bit
  //
  typedef signed char byte;
  typedef unsigned char unsigned_byte;

  // 16-bit
  //
  typedef short short_;
  typedef unsigned short unsigned_short;

  // 32-bit
  //
  typedef int int_;
  typedef unsigned int unsigned_int;

  // 64-bit
  //
  typedef long long long_;
  typedef unsigned long long unsigned_long;

  // Supposed to be arbitrary-length integral types.
  //
  typedef long long integer;
  typedef long long non_positive_integer;
  typedef unsigned long long non_negative_integer;
  typedef unsigned long long positive_integer;
  typedef long long negative_integer;

  // Boolean.
  //
  typedef bool boolean;

  // Floating-point types.
  //
  typedef float float_;
  typedef double double_;
  typedef double decimal;

  // String types.
  //
  typedef ::xsd::cxx::tree::string< char, simple_type > string;
  typedef ::xsd::cxx::tree::normalized_string< char, string > normalized_string;
  typedef ::xsd::cxx::tree::token< char, normalized_string > token;
  typedef ::xsd::cxx::tree::name< char, token > name;
  typedef ::xsd::cxx::tree::nmtoken< char, token > nmtoken;
  typedef ::xsd::cxx::tree::nmtokens< char, simple_type, nmtoken > nmtokens;
  typedef ::xsd::cxx::tree::ncname< char, name > ncname;
  typedef ::xsd::cxx::tree::language< char, token > language;

  // ID/IDREF.
  //
  typedef ::xsd::cxx::tree::id< char, ncname > id;
  typedef ::xsd::cxx::tree::idref< char, ncname, type > idref;
  typedef ::xsd::cxx::tree::idrefs< char, simple_type, idref > idrefs;

  // URI.
  //
  typedef ::xsd::cxx::tree::uri< char, simple_type > uri;

  // Qualified name.
  //
  typedef ::xsd::cxx::tree::qname< char, simple_type, uri, ncname > qname;

  // Binary.
  //
  typedef ::xsd::cxx::tree::buffer< char > buffer;
  typedef ::xsd::cxx::tree::base64_binary< char, simple_type > base64_binary;
  typedef ::xsd::cxx::tree::hex_binary< char, simple_type > hex_binary;

  // Date/time.
  //
  typedef ::xsd::cxx::tree::time_zone time_zone;
  typedef ::xsd::cxx::tree::date< char, simple_type > date;
  typedef ::xsd::cxx::tree::date_time< char, simple_type > date_time;
  typedef ::xsd::cxx::tree::duration< char, simple_type > duration;
  typedef ::xsd::cxx::tree::gday< char, simple_type > gday;
  typedef ::xsd::cxx::tree::gmonth< char, simple_type > gmonth;
  typedef ::xsd::cxx::tree::gmonth_day< char, simple_type > gmonth_day;
  typedef ::xsd::cxx::tree::gyear< char, simple_type > gyear;
  typedef ::xsd::cxx::tree::gyear_month< char, simple_type > gyear_month;
  typedef ::xsd::cxx::tree::time< char, simple_type > time;

  // Entity.
  //
  typedef ::xsd::cxx::tree::entity< char, ncname > entity;
  typedef ::xsd::cxx::tree::entities< char, simple_type, entity > entities;

  typedef ::xsd::cxx::tree::content_order content_order;
  // Namespace information and list stream. Used in
  // serialization functions.
  //
  typedef ::xsd::cxx::xml::dom::namespace_info< char > namespace_info;
  typedef ::xsd::cxx::xml::dom::namespace_infomap< char > namespace_infomap;
  typedef ::xsd::cxx::tree::list_stream< char > list_stream;
  typedef ::xsd::cxx::tree::as_double< double_ > as_double;
  typedef ::xsd::cxx::tree::as_decimal< decimal > as_decimal;
  typedef ::xsd::cxx::tree::facet facet;

  // Flags and properties.
  //
  typedef ::xsd::cxx::tree::flags flags;
  typedef ::xsd::cxx::tree::properties< char > properties;

  // Parsing/serialization diagnostics.
  //
  typedef ::xsd::cxx::tree::severity severity;
  typedef ::xsd::cxx::tree::error< char > error;
  typedef ::xsd::cxx::tree::diagnostics< char > diagnostics;

  // Exceptions.
  //
  typedef ::xsd::cxx::tree::exception< char > exception;
  typedef ::xsd::cxx::tree::bounds< char > bounds;
  typedef ::xsd::cxx::tree::duplicate_id< char > duplicate_id;
  typedef ::xsd::cxx::tree::parsing< char > parsing;
  typedef ::xsd::cxx::tree::expected_element< char > expected_element;
  typedef ::xsd::cxx::tree::unexpected_element< char > unexpected_element;
  typedef ::xsd::cxx::tree::expected_attribute< char > expected_attribute;
  typedef ::xsd::cxx::tree::unexpected_enumerator< char > unexpected_enumerator;
  typedef ::xsd::cxx::tree::expected_text_content< char > expected_text_content;
  typedef ::xsd::cxx::tree::no_prefix_mapping< char > no_prefix_mapping;
  typedef ::xsd::cxx::tree::serialization< char > serialization;

  // Error handler callback interface.
  //
  typedef ::xsd::cxx::xml::error_handler< char > error_handler;

  // DOM interaction.
  //
  namespace dom
  {
    // Automatic pointer for DOMDocument.
    //
    using ::xsd::cxx::xml::dom::unique_ptr;

#ifndef XSD_CXX_TREE_TREE_NODE_KEY__XML_SCHEMA
#define XSD_CXX_TREE_TREE_NODE_KEY__XML_SCHEMA
    // DOM user data key for back pointers to tree nodes.
    //
    const XMLCh* const tree_node_key = ::xsd::cxx::tree::user_data_keys::node;
#endif
  }
}

// Forward declarations.
//
namespace nova
{
  namespace dbi
  {
    class dBColumn_t;
    class dBCheck_t;
    class dBRow_t;
    class dBTable;
  }
}


#include <memory>    // ::std::unique_ptr
#include <limits>    // std::numeric_limits
#include <algorithm> // std::binary_search
#include <utility>   // std::move

#include <xsd/cxx/xml/char-utf8.hxx>

#include <xsd/cxx/tree/exceptions.hxx>
#include <xsd/cxx/tree/elements.hxx>
#include <xsd/cxx/tree/containers.hxx>
#include <xsd/cxx/tree/list.hxx>

#include <xsd/cxx/xml/dom/parsing-header.hxx>

namespace nova
{
  namespace dbi
  {
    class dBColumn_t: public ::xml_schema::type
    {
      public:
      // name
      //
      typedef ::xml_schema::string name_type;
      typedef ::xsd::cxx::tree::traits< name_type, char > name_traits;

      const name_type&
      name () const;

      name_type&
      name ();

      const name_type&
      getName () const;

      bool
      hasName () const;

      void
      name (const name_type& x);

      void
      setName (const name_type& x);

      void
      name (::std::unique_ptr< name_type > p);

      // colType
      //
      typedef ::xml_schema::string colType_type;
      typedef ::xsd::cxx::tree::optional< colType_type > colType_optional;
      typedef ::xsd::cxx::tree::traits< colType_type, char > colType_traits;

      const colType_optional&
      colType () const;

      colType_optional&
      colType ();

      const colType_type&
      getColType () const;

      bool
      hasColType () const;

      void
      colType (const colType_type& x);

      void
      setColType (const colType_type& x);

      void
      colType (const colType_optional& x);

      void
      colType (::std::unique_ptr< colType_type > p);

      // value
      //
      typedef ::xml_schema::string value_type;
      typedef ::xsd::cxx::tree::optional< value_type > value_optional;
      typedef ::xsd::cxx::tree::traits< value_type, char > value_traits;

      const value_optional&
      value () const;

      value_optional&
      value ();

      const value_type&
      getValue () const;

      bool
      hasValue () const;

      void
      value (const value_type& x);

      void
      setValue (const value_type& x);

      void
      value (const value_optional& x);

      void
      value (::std::unique_ptr< value_type > p);

      // null
      //
      typedef ::xml_schema::boolean null_type;
      typedef ::xsd::cxx::tree::optional< null_type > null_optional;
      typedef ::xsd::cxx::tree::traits< null_type, char > null_traits;

      const null_optional&
      null () const;

      null_optional&
      null ();

      const null_type&
      getNull () const;

      bool
      hasNull () const;

      void
      null (const null_type& x);

      void
      setNull (const null_type& x);

      void
      null (const null_optional& x);

      // fKeyTable
      //
      typedef ::xml_schema::string fKeyTable_type;
      typedef ::xsd::cxx::tree::optional< fKeyTable_type > fKeyTable_optional;
      typedef ::xsd::cxx::tree::traits< fKeyTable_type, char > fKeyTable_traits;

      const fKeyTable_optional&
      fKeyTable () const;

      fKeyTable_optional&
      fKeyTable ();

      const fKeyTable_type&
      getFKeyTable () const;

      bool
      hasFKeyTable () const;

      void
      fKeyTable (const fKeyTable_type& x);

      void
      setFKeyTable (const fKeyTable_type& x);

      void
      fKeyTable (const fKeyTable_optional& x);

      void
      fKeyTable (::std::unique_ptr< fKeyTable_type > p);

      // fKeyColumn
      //
      typedef ::xml_schema::string fKeyColumn_type;
      typedef ::xsd::cxx::tree::optional< fKeyColumn_type > fKeyColumn_optional;
      typedef ::xsd::cxx::tree::traits< fKeyColumn_type, char > fKeyColumn_traits;

      const fKeyColumn_optional&
      fKeyColumn () const;

      fKeyColumn_optional&
      fKeyColumn ();

      const fKeyColumn_type&
      getFKeyColumn () const;

      bool
      hasFKeyColumn () const;

      void
      fKeyColumn (const fKeyColumn_type& x);

      void
      setFKeyColumn (const fKeyColumn_type& x);

      void
      fKeyColumn (const fKeyColumn_optional& x);

      void
      fKeyColumn (::std::unique_ptr< fKeyColumn_type > p);

      // tolerance
      //
      typedef ::xml_schema::float_ tolerance_type;
      typedef ::xsd::cxx::tree::optional< tolerance_type > tolerance_optional;
      typedef ::xsd::cxx::tree::traits< tolerance_type, char > tolerance_traits;

      const tolerance_optional&
      tolerance () const;

      tolerance_optional&
      tolerance ();

      const tolerance_type&
      getTolerance () const;

      bool
      hasTolerance () const;

      void
      tolerance (const tolerance_type& x);

      void
      setTolerance (const tolerance_type& x);

      void
      tolerance (const tolerance_optional& x);

      // Constructors.
      //
      dBColumn_t ();

      dBColumn_t (const name_type&);

      dBColumn_t (const ::xercesc::DOMElement& e,
                  ::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0);

      dBColumn_t (const dBColumn_t& x,
                  ::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0);

      virtual dBColumn_t*
      _clone (::xml_schema::flags f = 0,
              ::xml_schema::container* c = 0) const;

      dBColumn_t&
      operator= (const dBColumn_t& x);

      virtual 
      ~dBColumn_t ();

      void copyNeededFields (const dBColumn_t& x);

      // Implementation.
      //
      protected:
      void
      parse (::xsd::cxx::xml::dom::parser< char >&,
             ::xml_schema::flags);

      protected:
      ::xsd::cxx::tree::one< name_type > name_;
      colType_optional colType_;
      value_optional value_;
      null_optional null_;
      fKeyTable_optional fKeyTable_;
      fKeyColumn_optional fKeyColumn_;
      tolerance_optional tolerance_;
    };

    class dBCheck_t: public ::xml_schema::type
    {
      public:
      // constraint
      //
      typedef ::xml_schema::string constraint_type;
      typedef ::xsd::cxx::tree::traits< constraint_type, char > constraint_traits;

      const constraint_type&
      constraint () const;

      constraint_type&
      constraint ();

      const constraint_type&
      getConstraint () const;

      bool
      hasConstraint () const;

      void
      constraint (const constraint_type& x);

      void
      setConstraint (const constraint_type& x);

      void
      constraint (::std::unique_ptr< constraint_type > p);

      // Constructors.
      //
      dBCheck_t ();

      dBCheck_t (const constraint_type&);

      dBCheck_t (const ::xercesc::DOMElement& e,
                 ::xml_schema::flags f = 0,
                 ::xml_schema::container* c = 0);

      dBCheck_t (const dBCheck_t& x,
                 ::xml_schema::flags f = 0,
                 ::xml_schema::container* c = 0);

      virtual dBCheck_t*
      _clone (::xml_schema::flags f = 0,
              ::xml_schema::container* c = 0) const;

      dBCheck_t&
      operator= (const dBCheck_t& x);

      virtual 
      ~dBCheck_t ();

      void copyNeededFields (const dBCheck_t& x);

      // Implementation.
      //
      protected:
      void
      parse (::xsd::cxx::xml::dom::parser< char >&,
             ::xml_schema::flags);

      protected:
      ::xsd::cxx::tree::one< constraint_type > constraint_;
    };

    class dBRow_t: public ::xml_schema::type
    {
      public:
      // dBCol
      //
      typedef ::nova::dbi::dBColumn_t dBCol_type;
      typedef ::xsd::cxx::tree::sequence< dBCol_type > dBCol_sequence;
      typedef dBCol_sequence::iterator dBCol_iterator;
      typedef dBCol_sequence::const_iterator dBCol_const_iterator;
      typedef ::xsd::cxx::tree::traits< dBCol_type, char > dBCol_traits;

      const dBCol_sequence&
      dBCol () const;

      dBCol_sequence&
      dBCol ();

      ::xml_schema::integer
      getDBColCount () const;

      const dBCol_type&
      getDBCol (int index) const;

      dBCol_type&
      getDBColReference (int index);

      bool
      hasDBCol () const;

      void
      removeAllDBCol ();

      void
      dBCol (const dBCol_sequence& s);

      void
      addDBCol (const dBCol_type& newDBCol);

      // Constructors.
      //
      dBRow_t ();

      dBRow_t (const ::xercesc::DOMElement& e,
               ::xml_schema::flags f = 0,
               ::xml_schema::container* c = 0);

      dBRow_t (const dBRow_t& x,
               ::xml_schema::flags f = 0,
               ::xml_schema::container* c = 0);

      virtual dBRow_t*
      _clone (::xml_schema::flags f = 0,
              ::xml_schema::container* c = 0) const;

      dBRow_t&
      operator= (const dBRow_t& x);

      virtual 
      ~dBRow_t ();

      void copyNeededFields (const dBRow_t& x);

      // Implementation.
      //
      protected:
      void
      parse (::xsd::cxx::xml::dom::parser< char >&,
             ::xml_schema::flags);

      protected:
      dBCol_sequence dBCol_;
    };

    class dBTable: public ::xml_schema::type
          , public ::novadaq::XMLSerializable
    {
      public:
      // dBColumn
      //
      typedef ::nova::dbi::dBColumn_t dBColumn_type;
      typedef ::xsd::cxx::tree::sequence< dBColumn_type > dBColumn_sequence;
      typedef dBColumn_sequence::iterator dBColumn_iterator;
      typedef dBColumn_sequence::const_iterator dBColumn_const_iterator;
      typedef ::xsd::cxx::tree::traits< dBColumn_type, char > dBColumn_traits;

      const dBColumn_sequence&
      dBColumn () const;

      dBColumn_sequence&
      dBColumn ();

      ::xml_schema::integer
      getDBColumnCount () const;

      const dBColumn_type&
      getDBColumn (int index) const;

      dBColumn_type&
      getDBColumnReference (int index);

      bool
      hasDBColumn () const;

      void
      removeAllDBColumn ();

      void
      dBColumn (const dBColumn_sequence& s);

      void
      addDBColumn (const dBColumn_type& newDBColumn);

      // dBPKey
      //
      typedef ::nova::dbi::dBRow_t dBPKey_type;
      typedef ::xsd::cxx::tree::optional< dBPKey_type > dBPKey_optional;
      typedef ::xsd::cxx::tree::traits< dBPKey_type, char > dBPKey_traits;

      const dBPKey_optional&
      dBPKey () const;

      dBPKey_optional&
      dBPKey ();

      const dBPKey_type&
      getDBPKey () const;

      bool
      hasDBPKey () const;

      void
      dBPKey (const dBPKey_type& x);

      void
      setDBPKey (const dBPKey_type& x);

      void
      dBPKey (const dBPKey_optional& x);

      void
      dBPKey (::std::unique_ptr< dBPKey_type > p);

      // dBUnique
      //
      typedef ::nova::dbi::dBRow_t dBUnique_type;
      typedef ::xsd::cxx::tree::sequence< dBUnique_type > dBUnique_sequence;
      typedef dBUnique_sequence::iterator dBUnique_iterator;
      typedef dBUnique_sequence::const_iterator dBUnique_const_iterator;
      typedef ::xsd::cxx::tree::traits< dBUnique_type, char > dBUnique_traits;

      const dBUnique_sequence&
      dBUnique () const;

      dBUnique_sequence&
      dBUnique ();

      ::xml_schema::integer
      getDBUniqueCount () const;

      const dBUnique_type&
      getDBUnique (int index) const;

      dBUnique_type&
      getDBUniqueReference (int index);

      bool
      hasDBUnique () const;

      void
      removeAllDBUnique ();

      void
      dBUnique (const dBUnique_sequence& s);

      void
      addDBUnique (const dBUnique_type& newDBUnique);

      // dBCheck
      //
      typedef ::nova::dbi::dBCheck_t dBCheck_type;
      typedef ::xsd::cxx::tree::sequence< dBCheck_type > dBCheck_sequence;
      typedef dBCheck_sequence::iterator dBCheck_iterator;
      typedef dBCheck_sequence::const_iterator dBCheck_const_iterator;
      typedef ::xsd::cxx::tree::traits< dBCheck_type, char > dBCheck_traits;

      const dBCheck_sequence&
      dBCheck () const;

      dBCheck_sequence&
      dBCheck ();

      ::xml_schema::integer
      getDBCheckCount () const;

      const dBCheck_type&
      getDBCheck (int index) const;

      dBCheck_type&
      getDBCheckReference (int index);

      bool
      hasDBCheck () const;

      void
      removeAllDBCheck ();

      void
      dBCheck (const dBCheck_sequence& s);

      void
      addDBCheck (const dBCheck_type& newDBCheck);

      // dBRow
      //
      typedef ::nova::dbi::dBRow_t dBRow_type;
      typedef ::xsd::cxx::tree::sequence< dBRow_type > dBRow_sequence;
      typedef dBRow_sequence::iterator dBRow_iterator;
      typedef dBRow_sequence::const_iterator dBRow_const_iterator;
      typedef ::xsd::cxx::tree::traits< dBRow_type, char > dBRow_traits;

      const dBRow_sequence&
      dBRow () const;

      dBRow_sequence&
      dBRow ();

      ::xml_schema::integer
      getDBRowCount () const;

      const dBRow_type&
      getDBRow (int index) const;

      dBRow_type&
      getDBRowReference (int index);

      bool
      hasDBRow () const;

      void
      removeAllDBRow ();

      void
      dBRow (const dBRow_sequence& s);

      void
      addDBRow (const dBRow_type& newDBRow);

      // tableName
      //
      typedef ::xml_schema::string tableName_type;
      typedef ::xsd::cxx::tree::traits< tableName_type, char > tableName_traits;

      const tableName_type&
      tableName () const;

      tableName_type&
      tableName ();

      const tableName_type&
      getTableName () const;

      bool
      hasTableName () const;

      void
      tableName (const tableName_type& x);

      void
      setTableName (const tableName_type& x);

      void
      tableName (::std::unique_ptr< tableName_type > p);

      // dbHost
      //
      typedef ::xml_schema::string dbHost_type;
      typedef ::xsd::cxx::tree::traits< dbHost_type, char > dbHost_traits;

      const dbHost_type&
      dbHost () const;

      dbHost_type&
      dbHost ();

      const dbHost_type&
      getDbHost () const;

      bool
      hasDbHost () const;

      void
      dbHost (const dbHost_type& x);

      void
      setDbHost (const dbHost_type& x);

      void
      dbHost (::std::unique_ptr< dbHost_type > p);

      // dbName
      //
      typedef ::xml_schema::string dbName_type;
      typedef ::xsd::cxx::tree::traits< dbName_type, char > dbName_traits;

      const dbName_type&
      dbName () const;

      dbName_type&
      dbName ();

      const dbName_type&
      getDbName () const;

      bool
      hasDbName () const;

      void
      dbName (const dbName_type& x);

      void
      setDbName (const dbName_type& x);

      void
      dbName (::std::unique_ptr< dbName_type > p);

      // dbType
      //
      typedef ::xml_schema::string dbType_type;
      typedef ::xsd::cxx::tree::optional< dbType_type > dbType_optional;
      typedef ::xsd::cxx::tree::traits< dbType_type, char > dbType_traits;

      const dbType_optional&
      dbType () const;

      dbType_optional&
      dbType ();

      const dbType_type&
      getDbType () const;

      bool
      hasDbType () const;

      void
      dbType (const dbType_type& x);

      void
      setDbType (const dbType_type& x);

      void
      dbType (const dbType_optional& x);

      void
      dbType (::std::unique_ptr< dbType_type > p);

      // dbPort
      //
      typedef ::xml_schema::string dbPort_type;
      typedef ::xsd::cxx::tree::optional< dbPort_type > dbPort_optional;
      typedef ::xsd::cxx::tree::traits< dbPort_type, char > dbPort_traits;

      const dbPort_optional&
      dbPort () const;

      dbPort_optional&
      dbPort ();

      const dbPort_type&
      getDbPort () const;

      bool
      hasDbPort () const;

      void
      dbPort (const dbPort_type& x);

      void
      setDbPort (const dbPort_type& x);

      void
      dbPort (const dbPort_optional& x);

      void
      dbPort (::std::unique_ptr< dbPort_type > p);

      // tableType
      //
      typedef ::xml_schema::string tableType_type;
      typedef ::xsd::cxx::tree::optional< tableType_type > tableType_optional;
      typedef ::xsd::cxx::tree::traits< tableType_type, char > tableType_traits;

      const tableType_optional&
      tableType () const;

      tableType_optional&
      tableType ();

      const tableType_type&
      getTableType () const;

      bool
      hasTableType () const;

      void
      tableType (const tableType_type& x);

      void
      setTableType (const tableType_type& x);

      void
      tableType (const tableType_optional& x);

      void
      tableType (::std::unique_ptr< tableType_type > p);

      // creationDate
      //
      typedef ::xml_schema::string creationDate_type;
      typedef ::xsd::cxx::tree::optional< creationDate_type > creationDate_optional;
      typedef ::xsd::cxx::tree::traits< creationDate_type, char > creationDate_traits;

      const creationDate_optional&
      creationDate () const;

      creationDate_optional&
      creationDate ();

      const creationDate_type&
      getCreationDate () const;

      bool
      hasCreationDate () const;

      void
      creationDate (const creationDate_type& x);

      void
      setCreationDate (const creationDate_type& x);

      void
      creationDate (const creationDate_optional& x);

      void
      creationDate (::std::unique_ptr< creationDate_type > p);

      // maintainer
      //
      typedef ::xml_schema::string maintainer_type;
      typedef ::xsd::cxx::tree::optional< maintainer_type > maintainer_optional;
      typedef ::xsd::cxx::tree::traits< maintainer_type, char > maintainer_traits;

      const maintainer_optional&
      maintainer () const;

      maintainer_optional&
      maintainer ();

      const maintainer_type&
      getMaintainer () const;

      bool
      hasMaintainer () const;

      void
      maintainer (const maintainer_type& x);

      void
      setMaintainer (const maintainer_type& x);

      void
      maintainer (const maintainer_optional& x);

      void
      maintainer (::std::unique_ptr< maintainer_type > p);

      // xmlOverDB
      //
      typedef ::xml_schema::boolean xmlOverDB_type;
      typedef ::xsd::cxx::tree::optional< xmlOverDB_type > xmlOverDB_optional;
      typedef ::xsd::cxx::tree::traits< xmlOverDB_type, char > xmlOverDB_traits;

      const xmlOverDB_optional&
      xmlOverDB () const;

      xmlOverDB_optional&
      xmlOverDB ();

      const xmlOverDB_type&
      getXmlOverDB () const;

      bool
      hasXmlOverDB () const;

      void
      xmlOverDB (const xmlOverDB_type& x);

      void
      setXmlOverDB (const xmlOverDB_type& x);

      void
      xmlOverDB (const xmlOverDB_optional& x);

      // ignoreDB
      //
      typedef ::xml_schema::boolean ignoreDB_type;
      typedef ::xsd::cxx::tree::optional< ignoreDB_type > ignoreDB_optional;
      typedef ::xsd::cxx::tree::traits< ignoreDB_type, char > ignoreDB_traits;

      const ignoreDB_optional&
      ignoreDB () const;

      ignoreDB_optional&
      ignoreDB ();

      const ignoreDB_type&
      getIgnoreDB () const;

      bool
      hasIgnoreDB () const;

      void
      ignoreDB (const ignoreDB_type& x);

      void
      setIgnoreDB (const ignoreDB_type& x);

      void
      ignoreDB (const ignoreDB_optional& x);

      // addInsertTime
      //
      typedef ::xml_schema::boolean addInsertTime_type;
      typedef ::xsd::cxx::tree::optional< addInsertTime_type > addInsertTime_optional;
      typedef ::xsd::cxx::tree::traits< addInsertTime_type, char > addInsertTime_traits;

      const addInsertTime_optional&
      addInsertTime () const;

      addInsertTime_optional&
      addInsertTime ();

      const addInsertTime_type&
      getAddInsertTime () const;

      bool
      hasAddInsertTime () const;

      void
      addInsertTime (const addInsertTime_type& x);

      void
      setAddInsertTime (const addInsertTime_type& x);

      void
      addInsertTime (const addInsertTime_optional& x);

      // addInsertUser
      //
      typedef ::xml_schema::boolean addInsertUser_type;
      typedef ::xsd::cxx::tree::optional< addInsertUser_type > addInsertUser_optional;
      typedef ::xsd::cxx::tree::traits< addInsertUser_type, char > addInsertUser_traits;

      const addInsertUser_optional&
      addInsertUser () const;

      addInsertUser_optional&
      addInsertUser ();

      const addInsertUser_type&
      getAddInsertUser () const;

      bool
      hasAddInsertUser () const;

      void
      addInsertUser (const addInsertUser_type& x);

      void
      setAddInsertUser (const addInsertUser_type& x);

      void
      addInsertUser (const addInsertUser_optional& x);

      // addUpdateTime
      //
      typedef ::xml_schema::boolean addUpdateTime_type;
      typedef ::xsd::cxx::tree::optional< addUpdateTime_type > addUpdateTime_optional;
      typedef ::xsd::cxx::tree::traits< addUpdateTime_type, char > addUpdateTime_traits;

      const addUpdateTime_optional&
      addUpdateTime () const;

      addUpdateTime_optional&
      addUpdateTime ();

      const addUpdateTime_type&
      getAddUpdateTime () const;

      bool
      hasAddUpdateTime () const;

      void
      addUpdateTime (const addUpdateTime_type& x);

      void
      setAddUpdateTime (const addUpdateTime_type& x);

      void
      addUpdateTime (const addUpdateTime_optional& x);

      // addUpdateUser
      //
      typedef ::xml_schema::boolean addUpdateUser_type;
      typedef ::xsd::cxx::tree::optional< addUpdateUser_type > addUpdateUser_optional;
      typedef ::xsd::cxx::tree::traits< addUpdateUser_type, char > addUpdateUser_traits;

      const addUpdateUser_optional&
      addUpdateUser () const;

      addUpdateUser_optional&
      addUpdateUser ();

      const addUpdateUser_type&
      getAddUpdateUser () const;

      bool
      hasAddUpdateUser () const;

      void
      addUpdateUser (const addUpdateUser_type& x);

      void
      setAddUpdateUser (const addUpdateUser_type& x);

      void
      addUpdateUser (const addUpdateUser_optional& x);

      // schema
      //
      typedef ::xml_schema::string schema_type;
      typedef ::xsd::cxx::tree::optional< schema_type > schema_optional;
      typedef ::xsd::cxx::tree::traits< schema_type, char > schema_traits;

      const schema_optional&
      schema () const;

      schema_optional&
      schema ();

      const schema_type&
      getSchema () const;

      bool
      hasSchema () const;

      void
      schema (const schema_type& x);

      void
      setSchema (const schema_type& x);

      void
      schema (const schema_optional& x);

      void
      schema (::std::unique_ptr< schema_type > p);

      // Constructors.
      //
      dBTable ();

      dBTable (const tableName_type&,
               const dbHost_type&,
               const dbName_type&);

      dBTable (const ::xercesc::DOMElement& e,
               ::xml_schema::flags f = 0,
               ::xml_schema::container* c = 0);

      dBTable (const dBTable& x,
               ::xml_schema::flags f = 0,
               ::xml_schema::container* c = 0);

      virtual dBTable*
      _clone (::xml_schema::flags f = 0,
              ::xml_schema::container* c = 0) const;

      dBTable&
      operator= (const dBTable& x);

      virtual 
      ~dBTable ();

      void copyNeededFields (const dBTable& x);

      ::std::string serialize () const;

      void deserialize (const ::std::string&);

      virtual ::std::string getClassName () const;

      virtual ::boost::shared_ptr< ::novadaq::XMLSerializable > clone () const;

      static void registerForDeserialization ();

      // Implementation.
      //
      protected:
      void
      parse (::xsd::cxx::xml::dom::parser< char >&,
             ::xml_schema::flags);

      protected:
      dBColumn_sequence dBColumn_;
      dBPKey_optional dBPKey_;
      dBUnique_sequence dBUnique_;
      dBCheck_sequence dBCheck_;
      dBRow_sequence dBRow_;
      ::xsd::cxx::tree::one< tableName_type > tableName_;
      ::xsd::cxx::tree::one< dbHost_type > dbHost_;
      ::xsd::cxx::tree::one< dbName_type > dbName_;
      dbType_optional dbType_;
      dbPort_optional dbPort_;
      tableType_optional tableType_;
      creationDate_optional creationDate_;
      maintainer_optional maintainer_;
      xmlOverDB_optional xmlOverDB_;
      ignoreDB_optional ignoreDB_;
      addInsertTime_optional addInsertTime_;
      addInsertUser_optional addInsertUser_;
      addUpdateTime_optional addUpdateTime_;
      addUpdateUser_optional addUpdateUser_;
      schema_optional schema_;
    };
  }
}

#include <iosfwd>

#include <xercesc/sax/InputSource.hpp>
#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMErrorHandler.hpp>

namespace nova
{
  namespace dbi
  {
    // Parse a URI or a local file.
    //

    ::std::unique_ptr< ::nova::dbi::dBTable >
    dBTable_ (const ::std::string& uri,
              ::xml_schema::flags f = 0,
              const ::xml_schema::properties& p = ::xml_schema::properties ());

    ::std::unique_ptr< ::nova::dbi::dBTable >
    dBTable_ (const ::std::string& uri,
              ::xml_schema::error_handler& eh,
              ::xml_schema::flags f = 0,
              const ::xml_schema::properties& p = ::xml_schema::properties ());

    ::std::unique_ptr< ::nova::dbi::dBTable >
    dBTable_ (const ::std::string& uri,
              ::xercesc::DOMErrorHandler& eh,
              ::xml_schema::flags f = 0,
              const ::xml_schema::properties& p = ::xml_schema::properties ());

    // Parse std::istream.
    //

    ::std::unique_ptr< ::nova::dbi::dBTable >
    dBTable_ (::std::istream& is,
              ::xml_schema::flags f = 0,
              const ::xml_schema::properties& p = ::xml_schema::properties ());

    ::std::unique_ptr< ::nova::dbi::dBTable >
    dBTable_ (::std::istream& is,
              ::xml_schema::error_handler& eh,
              ::xml_schema::flags f = 0,
              const ::xml_schema::properties& p = ::xml_schema::properties ());

    ::std::unique_ptr< ::nova::dbi::dBTable >
    dBTable_ (::std::istream& is,
              ::xercesc::DOMErrorHandler& eh,
              ::xml_schema::flags f = 0,
              const ::xml_schema::properties& p = ::xml_schema::properties ());

    ::std::unique_ptr< ::nova::dbi::dBTable >
    dBTable_ (::std::istream& is,
              const ::std::string& id,
              ::xml_schema::flags f = 0,
              const ::xml_schema::properties& p = ::xml_schema::properties ());

    ::std::unique_ptr< ::nova::dbi::dBTable >
    dBTable_ (::std::istream& is,
              const ::std::string& id,
              ::xml_schema::error_handler& eh,
              ::xml_schema::flags f = 0,
              const ::xml_schema::properties& p = ::xml_schema::properties ());

    ::std::unique_ptr< ::nova::dbi::dBTable >
    dBTable_ (::std::istream& is,
              const ::std::string& id,
              ::xercesc::DOMErrorHandler& eh,
              ::xml_schema::flags f = 0,
              const ::xml_schema::properties& p = ::xml_schema::properties ());

    // Parse xercesc::InputSource.
    //

    ::std::unique_ptr< ::nova::dbi::dBTable >
    dBTable_ (::xercesc::InputSource& is,
              ::xml_schema::flags f = 0,
              const ::xml_schema::properties& p = ::xml_schema::properties ());

    ::std::unique_ptr< ::nova::dbi::dBTable >
    dBTable_ (::xercesc::InputSource& is,
              ::xml_schema::error_handler& eh,
              ::xml_schema::flags f = 0,
              const ::xml_schema::properties& p = ::xml_schema::properties ());

    ::std::unique_ptr< ::nova::dbi::dBTable >
    dBTable_ (::xercesc::InputSource& is,
              ::xercesc::DOMErrorHandler& eh,
              ::xml_schema::flags f = 0,
              const ::xml_schema::properties& p = ::xml_schema::properties ());

    // Parse xercesc::DOMDocument.
    //

    ::std::unique_ptr< ::nova::dbi::dBTable >
    dBTable_ (const ::xercesc::DOMDocument& d,
              ::xml_schema::flags f = 0,
              const ::xml_schema::properties& p = ::xml_schema::properties ());

    ::std::unique_ptr< ::nova::dbi::dBTable >
    dBTable_ (::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d,
              ::xml_schema::flags f = 0,
              const ::xml_schema::properties& p = ::xml_schema::properties ());
  }
}

#include <iosfwd>

#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMErrorHandler.hpp>
#include <xercesc/framework/XMLFormatter.hpp>

#include <xsd/cxx/xml/dom/auto-ptr.hxx>

namespace nova
{
  namespace dbi
  {
    // Serialize to std::ostream.
    //

    void
    dBTable_ (::std::ostream& os,
              const ::nova::dbi::dBTable& x, 
              const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
              const ::std::string& e = "UTF-8",
              ::xml_schema::flags f = 0);

    void
    dBTable_ (::std::ostream& os,
              const ::nova::dbi::dBTable& x, 
              ::xml_schema::error_handler& eh,
              const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
              const ::std::string& e = "UTF-8",
              ::xml_schema::flags f = 0);

    void
    dBTable_ (::std::ostream& os,
              const ::nova::dbi::dBTable& x, 
              ::xercesc::DOMErrorHandler& eh,
              const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
              const ::std::string& e = "UTF-8",
              ::xml_schema::flags f = 0);

    // Serialize to xercesc::XMLFormatTarget.
    //

    void
    dBTable_ (::xercesc::XMLFormatTarget& ft,
              const ::nova::dbi::dBTable& x, 
              const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
              const ::std::string& e = "UTF-8",
              ::xml_schema::flags f = 0);

    void
    dBTable_ (::xercesc::XMLFormatTarget& ft,
              const ::nova::dbi::dBTable& x, 
              ::xml_schema::error_handler& eh,
              const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
              const ::std::string& e = "UTF-8",
              ::xml_schema::flags f = 0);

    void
    dBTable_ (::xercesc::XMLFormatTarget& ft,
              const ::nova::dbi::dBTable& x, 
              ::xercesc::DOMErrorHandler& eh,
              const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
              const ::std::string& e = "UTF-8",
              ::xml_schema::flags f = 0);

    // Serialize to an existing xercesc::DOMDocument.
    //

    void
    dBTable_ (::xercesc::DOMDocument& d,
              const ::nova::dbi::dBTable& x,
              ::xml_schema::flags f = 0);

    // Serialize to a new xercesc::DOMDocument.
    //

    ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
    dBTable_ (const ::nova::dbi::dBTable& x, 
              const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
              ::xml_schema::flags f = 0);

    void
    operator<< (::xercesc::DOMElement&, const dBColumn_t&);

    void
    operator<< (::xercesc::DOMElement&, const dBCheck_t&);

    void
    operator<< (::xercesc::DOMElement&, const dBRow_t&);

    void
    operator<< (::xercesc::DOMElement&, const dBTable&);
  }
}

#include <xsd/cxx/post.hxx>

// Begin epilogue.
//
//
// End epilogue.

#endif // CXX______CONFIG_DATABASE_H