diff --git a/applications/gaia/gaia/generic/GaiaSkySearch.C b/applications/gaia/gaia/generic/GaiaSkySearch.C index 442b907fb00..80ff449566b 100644 --- a/applications/gaia/gaia/generic/GaiaSkySearch.C +++ b/applications/gaia/gaia/generic/GaiaSkySearch.C @@ -119,7 +119,7 @@ public: {"imgplot", &GaiaSkySearch::imgplotCmd, 1, 4}, {"info", &GaiaSkySearch::infoCmd, 1, 2}, {"namesvr", &GaiaSkySearch::namesvrCmd, 2, 2}, - {"open", &GaiaSkySearch::openCmd, 1, 2}, + {"open", &GaiaSkySearch::openCmd, 0, 2}, {"origin", &GaiaSkySearch::originCmd, 0, 2}, {"save", &GaiaSkySearch::saveCmd, 1, 5}, {"setequinox", &GaiaSkySearch::setequinoxCmd, 1, 1} @@ -225,6 +225,18 @@ GaiaSkySearch::~GaiaSkySearch() */ int GaiaSkySearch::openCmd(int argc, char* argv[]) { + // Return if a catalogue is open if no args are given. + if ( argc == 0 ) { + if ( cat_ ) { + set_result( "1" ); + } + else { + set_result( "0" ); + } + return TCL_OK; + } + + if ( cat_ ) { delete cat_; cat_ = NULL; diff --git a/applications/gaia/gaia/library/Gaia.tcl b/applications/gaia/gaia/library/Gaia.tcl index 00e4d25e3b9..449c9e4a75e 100644 --- a/applications/gaia/gaia/library/Gaia.tcl +++ b/applications/gaia/gaia/library/Gaia.tcl @@ -27,7 +27,7 @@ # Copyright: # Copyright (C) 1998-2001 Central Laboratory of the Research Councils # Copyright (C) 2006-2007 Particle Physics & Astronomy Research Council. -# Copyright (C) 2007-2009 Science and Technology Facilities Council. +# Copyright (C) 2007-2014 Science and Technology Facilities Council. # All Rights Reserved. # Licence: @@ -2167,7 +2167,6 @@ itcl::class gaia::Gaia { file copy -force $config_file ${backupname} } file copy -force $gaia_library/skycat2.0.cfg $config_file - puts "file copy -force $gaia_library/skycat2.0.cfg $config_file" # Make a directory entry that accesses the old configs. if { $backupname != "" } { @@ -2599,10 +2598,10 @@ window gives you access to this." # See if the given headers and row data specify a SIAP server. # Need a accessURL field for that. - set accessURL [gaiavo::GaiaVOCatSIAP::getAccessURL $headers $row] + set accessURL [gaiavo::GaiaVOCat::getAccessURL $headers $row] if { $accessURL != {} } { - set name [gaiavo::GaiaVOCatSIAP::getName $headers $row] - set id [gaiavo::GaiaVOCatSIAP::getIdentifier $headers $row] + set name [gaiavo::GaiaVOCat::getName $headers $row] + set id [gaiavo::GaiaVOCat::getIdentifier $headers $row] gaiavo::GaiaVOCatSIAP $w_.siapquery\#auto \ -accessURL $accessURL \ -identifier $id \ @@ -2625,7 +2624,7 @@ window gives you access to this." # Find and open the current list of servers. set cone_file [vo_config_file_ GaiaConeServers.vot] - utilReUseWidget gaiavo::GaiaVOCatRegistry $w_.voregistry \ + utilReUseWidget gaiavo::GaiaVOCatRegistry $w_.voregistrycone \ -catalog $cone_file \ -service CONE \ -title "Catalogue Cone search" \ @@ -2645,9 +2644,9 @@ window gives you access to this." # See if the given headers and row data specify a Cone # server. Need a accessURL field for that. - set accessURL [gaiavo::GaiaVOCatCone::getAccessURL $headers $row] + set accessURL [gaiavo::GaiaVOCat::getAccessURL $headers $row] if { $accessURL != {} } { - set name [gaiavo::GaiaVOCatCone::getName $headers $row] + set name [gaiavo::GaiaVOCat::getName $headers $row] gaiavo::GaiaVOCatCone $w_.conequery\#auto \ -accessURL $accessURL \ -shortname $name \ @@ -2660,12 +2659,56 @@ window gives you access to this." } } + # Open a dialog for querying TAP services. + public method vo_find_tap {} { + if { [gaia::GaiaVOTableAccess::check_for_gaiavo] } { + + # Find and open the current list of servers. + set tap_file [vo_config_file_ GaiaTAPServers.vot] + + utilReUseWidget gaiavo::GaiaVOCatRegistry $w_.voregistrytap \ + -catalog $tap_file \ + -service TAP \ + -title "TAP server queries" \ + -activate_cmd [code $this vo_query_tap_] \ + -whole_operation 0 \ + -help_file tap + } else { + error_dialog "No GAIA-VO extension is available" $w_ + } + } + + # Open a dialog for querying a TAP server. + protected method vo_query_tap_ {headers row} { + if { [gaia::GaiaVOTableAccess::check_for_gaiavo] } { + + # See if the given headers and row data specify a TAP + # service. Need a URL resource for that. + set accessURL [gaiavo::GaiaVOCat::getAccessURL $headers $row] + if { $accessURL != {} } { + set name [gaiavo::GaiaVOCat::getName $headers $row] + gaiavo::GaiaVOTAP $w_.tap\#auto \ + -accessURL $accessURL \ + -shortname $name \ + -gaia $this \ + -title "$name TAP service" \ + -help_file tapquery + } else { + warning_dialog "TAP service does not specify a resource URL" $w_ + } + } + } + # Get a cached configuration file. If not present use builtin list. protected method vo_config_file_ {name} { set config_file [utilGetConfigFilename .skycat $name] if { ! [::file exists $config_file] } { - # Use builtin defaults. - ::file copy -force $::gaiavo_library/$name $config_file + # Use builtin defaults. If any. + if { [::file exists $::gaiavo_library/$name ] } { + ::file copy -force $::gaiavo_library/$name $config_file + } else { + puts stderr "Warning: no $name configuation file located" + } } return $config_file } diff --git a/applications/gaia/gaia/library/GaiaSearch.tcl b/applications/gaia/gaia/library/GaiaSearch.tcl index 29385658286..87674647090 100644 --- a/applications/gaia/gaia/library/GaiaSearch.tcl +++ b/applications/gaia/gaia/library/GaiaSearch.tcl @@ -873,11 +873,16 @@ itcl::class gaia::GaiaSearch { set state disabled } - # Cone Search. + # Cone search. $w add_menuitem $m command "Query a VO catalog server..." \ {Find VO cone search servers and query for catalogs} \ -command [code $w vo_find_cone] -state $state + # TAP query. + $w add_menuitem $m command "Query a TAP service..." \ + {Find TAP services and query} \ + -command [code $w vo_find_tap] -state $state + # Add SIAP query dialogs $w add_menuitem $m command "Query a VO image server..." \ {Find VO image servers and make requests for images} \ diff --git a/applications/gaia/gaiavo/Makefile.in b/applications/gaia/gaiavo/Makefile.in index 725bea9a655..a788e62309e 100644 --- a/applications/gaia/gaiavo/Makefile.in +++ b/applications/gaia/gaiavo/Makefile.in @@ -490,7 +490,7 @@ distdir: #============================================================================ VOTable1.1.C: VOTable1.1.xsd - xsd cxx-tree --root-element VOTABLE \ + xsdcxx cxx-tree --root-element VOTABLE \ --generate-serialization \ --namespace-map http://www.ivoa.net/xml/VOTable/v1.1=votable_11 \ --parser-regex '/VOTABLE/VOTABLE_read/' \ @@ -504,7 +504,7 @@ VOTable1.1.C: VOTable1.1.xsd # Note no serialization support for this. Do not want to write these. VOTable1.1_dns.C: VOTable1.1_dns.xsd - xsd cxx-tree --root-element VOTABLE \ + xsdcxx cxx-tree --root-element VOTABLE \ --namespace-map '=votable_11_dns' \ --parser-regex '/VOTABLE/VOTABLE_read/' \ --generate-wildcard \ @@ -515,7 +515,7 @@ VOTable1.1_dns.C: VOTable1.1_dns.xsd mv VOTable1.1_dns.hxx generic/VOTable1.1_dns.hxx VOTable1.2.C: VOTable1.2.xsd - xsd cxx-tree --root-element VOTABLE \ + xsdcxx cxx-tree --root-element VOTABLE \ --generate-serialization \ --namespace-map http://www.ivoa.net/xml/VOTable/v1.2=votable_12 \ --parser-regex '/VOTABLE/VOTABLE_read/' \ @@ -527,5 +527,18 @@ VOTable1.2.C: VOTable1.2.xsd rm -f generic/VOTable1.2.hxx mv VOTable1.2.hxx generic/VOTable1.2.hxx +VOTable1.3.C: VOTable1.3.xsd + xsdcxx cxx-tree --root-element VOTABLE \ + --generate-serialization \ + --namespace-map http://www.ivoa.net/xml/VOTable/v1.3=votable_13 \ + --parser-regex '/VOTABLE/VOTABLE_read/' \ + --serializer-regex '/VOTABLE/VOTABLE_write/' \ + --generate-wildcard \ + VOTable1.3.xsd + rm -f generic/VOTable1.3.C + mv VOTable1.3.cxx generic/VOTable1.3.C + rm -f generic/VOTable1.3.hxx + mv VOTable1.3.hxx generic/VOTable1.3.hxx + # Local dependencies. VOTableWriteFunctions.o: ./generic/VOTableWriteFunctions.icc diff --git a/applications/gaia/gaiavo/VOTable1.3.xsd b/applications/gaia/gaiavo/VOTable1.3.xsd new file mode 100644 index 00000000000..c08d736576d --- /dev/null +++ b/applications/gaia/gaiavo/VOTable1.3.xsd @@ -0,0 +1,572 @@ + + + + + VOTable is meant to serialize tabular documents in the + context of Virtual Observatory applications. This schema + corresponds to the VOTable document available from + http://www.ivoa.net/Documents/latest/VOT.html + + + + + + + + + + + + + + + + + + + + Accept UCD1+ + Accept also old UCD1 (but not / + %) including SIAP convention (with :) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + content-role was previsouly restricted as: + + + + + + + + + ]]>; is now a token. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Deprecated in Version 1.2 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Deprecated in Version 1.1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Added in Version 1.2: INFO for diagnostics + + + + + + + + + + + + + + + + + + + + + + + + + The 'encoding' attribute is added here to avoid + problems of code generators which do not properly + interpret the TR/TD structures. + 'encoding' was chosen because it appears in + appendix A.5 + + + + + + + + + The ID attribute is added here to the TR tag to avoid + problems of code generators which do not properly + interpret the TR/TD structures + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Added in Version 1.2: INFO for diagnostics + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Added in Version 1.2: INFO for diagnostics in several places + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/applications/gaia/gaiavo/generic/VOTable.C b/applications/gaia/gaiavo/generic/VOTable.C index 356972e47d8..310066aea08 100644 --- a/applications/gaia/gaiavo/generic/VOTable.C +++ b/applications/gaia/gaiavo/generic/VOTable.C @@ -87,6 +87,7 @@ namespace gaia { */ const char *VOTABLE_NS11 ="http://www.ivoa.net/xml/VOTable/v1.1"; const char *VOTABLE_NS12 ="http://www.ivoa.net/xml/VOTable/v1.2"; + const char *VOTABLE_NS13 ="http://www.ivoa.net/xml/VOTable/v1.3"; /** Static member initializations. */ bool VOTable::initialized = false; @@ -99,7 +100,8 @@ namespace gaia { VOTable::VOTable() : votable1_(NULL), votable2_(NULL), - votable3_(NULL) + votable3_(NULL), + votable4_(NULL) { // Initialise Xerces runtime if ( !VOTable::initialized ) { @@ -179,6 +181,10 @@ namespace gaia { delete votable3_; votable3_ = NULL; } + if ( votable4_ ) { + delete votable4_; + votable4_ = NULL; + } // Open the VOTable using the correct parsing classes. Currently this // just scans for the namespace qualifying string in the first 2048 @@ -191,7 +197,8 @@ namespace gaia { // Now look for namespace signifier. if ( strstr( line, VOTABLE_NS11 ) == NULL && - strstr( line, VOTABLE_NS12 ) == NULL ) { + strstr( line, VOTABLE_NS12 ) == NULL && + strstr( line, VOTABLE_NS13 ) == NULL ) { // No namespace. votable1_ = openVOTable1( in ); @@ -199,15 +206,24 @@ namespace gaia { else { // Namespace. if ( strstr( line, VOTABLE_NS11 ) == NULL ) { - votable3_ = openVOTable3( in ); + // Not 1.1 + if ( strstr( line, VOTABLE_NS12 ) == NULL ) { + // 1.3 + votable4_ = openVOTable4( in ); + } + else { + // 1.2 + votable3_ = openVOTable3( in ); + } } else { + // 1.1 votable2_ = openVOTable2( in ); } } // If we have a table, that's OK. - if ( votable1_ || votable2_ || votable3_ ) { + if ( votable1_ || votable2_ || votable3_ || votable4_ ) { return 1; } return 0; @@ -234,6 +250,10 @@ namespace gaia { delete votable3_; votable3_ = NULL; } + if ( votable4_ ) { + delete votable4_; + votable4_ = NULL; + } // Create new instance. votable2_ = new VOTABLE(); @@ -263,6 +283,16 @@ namespace gaia { votable3_->version( "1.2" ); VOTABLE_write( out, *votable3_, map ); } + + using namespace votable_13; + if ( votable4_ != NULL ) { + ofstream out( file, ios::out ); + xml_schema::namespace_infomap map; + map[""].name = "http://www.ivoa.net/xml/VOTable/v1.3"; + map[""].schema = "VOTable1.3.xsd"; + votable4_->version( "1.3" ); + VOTABLE_write( out, *votable4_, map ); + } } /** @@ -279,6 +309,9 @@ namespace gaia { if ( votable3_ ) { delete votable3_; } + if ( votable4_ ) { + delete votable4_; + } } /** @@ -417,6 +450,31 @@ namespace gaia { return NULL; } + /** + * Read stream for a VOTable version 1.3 using fully qualified + * namespace. + */ + votable_13::VOTABLE *VOTable::openVOTable4( istream *in ) + { + using namespace votable_13; + try { + auto_ptr table = + VOTABLE_read( *in, + xml_schema::flags::dont_validate | + xml_schema::flags::dont_initialize | + xml_schema::flags::keep_dom ); + return table.release(); + } + catch ( const xml_schema::exception &e ) { + // Basic report to terminal. + cerr << "open_votable: "; + cerr << e << endl; + } + + // Open failed. + return NULL; + } + /** * Simple listing of VOTable contents. */ @@ -431,6 +489,9 @@ namespace gaia { else if ( votable3_ ) { votable_enum( *votable3_, str ); } + else if ( votable4_ ) { + votable_enum( *votable4_, str ); + } } /** @@ -447,6 +508,9 @@ namespace gaia { else if ( votable3_ ) { return votable_count( *votable3_ ); } + else if ( votable4_ ) { + return votable_count( *votable4_ ); + } return 0; } @@ -472,6 +536,9 @@ namespace gaia { else if ( votable3_ ) { result = votable_write( *votable3_, index, out ); } + else if ( votable4_ ) { + result = votable_write( *votable4_, index, out ); + } out.close(); return result; @@ -507,6 +574,9 @@ namespace gaia { else if ( votable3_ ) { return votable_info_value( *votable3_, name, value, content ); } + else if ( votable4_ ) { + return votable_info_value( *votable4_, name, value, content ); + } return 0; } } diff --git a/applications/gaia/gaiavo/generic/VOTable.h b/applications/gaia/gaiavo/generic/VOTable.h index cbd13530110..341b40a6c59 100644 --- a/applications/gaia/gaiavo/generic/VOTable.h +++ b/applications/gaia/gaiavo/generic/VOTable.h @@ -51,6 +51,7 @@ #include "VOTable1.1.hxx" #include "VOTable1.1_dns.hxx" #include "VOTable1.2.hxx" +#include "VOTable1.3.hxx" using namespace std; @@ -74,6 +75,10 @@ namespace gaia votable_12::VOTABLE *votable3_; votable_12::VOTABLE *openVOTable3( istream *in ); + // Open a VOTable 1.3. + votable_13::VOTABLE *votable4_; + votable_13::VOTABLE *openVOTable4( istream *in ); + // Note for above. VOTABLE classes are not derived, so cannot // simply use an array. @@ -124,16 +129,28 @@ namespace gaia // default namespace). These read a VOTable and write a tab // table. Defined in VOTableWriteFunctions.C. #define NS ::votable_11_dns +#define NSVERS 11 #include "VOTableWriteFunctions.h" #undef NS +#undef NSVERS #define NS ::votable_11 +#define NSVERS 11 #include "VOTableWriteFunctions.h" #undef NS +#undef NSVERS #define NS ::votable_12 +#define NSVERS 12 +#include "VOTableWriteFunctions.h" +#undef NS +#undef NSVERS + +#define NS ::votable_13 +#define NSVERS 13 #include "VOTableWriteFunctions.h" #undef NS +#undef NSVERS // Similar functions for reading a tab table and writing a VOTable. // Only support writing in the VOTable 1.1 namespace so no need for diff --git a/applications/gaia/gaiavo/generic/VOTable1.3.C b/applications/gaia/gaiavo/generic/VOTable1.3.C new file mode 100644 index 00000000000..e36bedf0cb4 --- /dev/null +++ b/applications/gaia/gaiavo/generic/VOTable1.3.C @@ -0,0 +1,10757 @@ +// Copyright (C) 2005-2010 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. +// + +// Begin prologue. +// +// +// End prologue. + +#include + +#include "VOTable1.3.hxx" + +namespace votable_13 +{ + // anyTEXT + // + + const anyTEXT::any_sequence& anyTEXT:: + any () const + { + return this->any_; + } + + anyTEXT::any_sequence& anyTEXT:: + any () + { + return this->any_; + } + + void anyTEXT:: + any (const any_sequence& s) + { + this->any_ = s; + } + + const ::xercesc::DOMDocument& anyTEXT:: + dom_document () const + { + return *dom_document_; + } + + ::xercesc::DOMDocument& anyTEXT:: + dom_document () + { + return *dom_document_; + } + + + // astroYear + // + + + // ucdType + // + + + // arrayDEF + // + + + // encodingType + // + + encodingType:: + encodingType (value v) + : ::xml_schema::nmtoken (_xsd_encodingType_literals_[v]) + { + } + + encodingType:: + encodingType (const char* v) + : ::xml_schema::nmtoken (v) + { + } + + encodingType:: + encodingType (const ::std::string& v) + : ::xml_schema::nmtoken (v) + { + } + + encodingType:: + encodingType (const ::xml_schema::nmtoken& v) + : ::xml_schema::nmtoken (v) + { + } + + encodingType:: + encodingType (const encodingType& v, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (v, f, c) + { + } + + encodingType& encodingType:: + operator= (value v) + { + static_cast< ::xml_schema::nmtoken& > (*this) = + ::xml_schema::nmtoken (_xsd_encodingType_literals_[v]); + + return *this; + } + + + // dataType + // + + dataType:: + dataType (value v) + : ::xml_schema::nmtoken (_xsd_dataType_literals_[v]) + { + } + + dataType:: + dataType (const char* v) + : ::xml_schema::nmtoken (v) + { + } + + dataType:: + dataType (const ::std::string& v) + : ::xml_schema::nmtoken (v) + { + } + + dataType:: + dataType (const ::xml_schema::nmtoken& v) + : ::xml_schema::nmtoken (v) + { + } + + dataType:: + dataType (const dataType& v, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (v, f, c) + { + } + + dataType& dataType:: + operator= (value v) + { + static_cast< ::xml_schema::nmtoken& > (*this) = + ::xml_schema::nmtoken (_xsd_dataType_literals_[v]); + + return *this; + } + + + // precType + // + + + // yesno + // + + yesno:: + yesno (value v) + : ::xml_schema::nmtoken (_xsd_yesno_literals_[v]) + { + } + + yesno:: + yesno (const char* v) + : ::xml_schema::nmtoken (v) + { + } + + yesno:: + yesno (const ::std::string& v) + : ::xml_schema::nmtoken (v) + { + } + + yesno:: + yesno (const ::xml_schema::nmtoken& v) + : ::xml_schema::nmtoken (v) + { + } + + yesno:: + yesno (const yesno& v, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (v, f, c) + { + } + + yesno& yesno:: + operator= (value v) + { + static_cast< ::xml_schema::nmtoken& > (*this) = + ::xml_schema::nmtoken (_xsd_yesno_literals_[v]); + + return *this; + } + + + // MIN + // + + const MIN::value_type& MIN:: + value () const + { + return this->value_.get (); + } + + MIN::value_type& MIN:: + value () + { + return this->value_.get (); + } + + void MIN:: + value (const value_type& x) + { + this->value_.set (x); + } + + void MIN:: + value (::std::auto_ptr< value_type > x) + { + this->value_.set (x); + } + + const MIN::inclusive_type& MIN:: + inclusive () const + { + return this->inclusive_.get (); + } + + MIN::inclusive_type& MIN:: + inclusive () + { + return this->inclusive_.get (); + } + + void MIN:: + inclusive (const inclusive_type& x) + { + this->inclusive_.set (x); + } + + void MIN:: + inclusive (::std::auto_ptr< inclusive_type > x) + { + this->inclusive_.set (x); + } + + const MIN::inclusive_type& MIN:: + inclusive_default_value () + { + return inclusive_default_value_; + } + + + // MAX + // + + const MAX::value_type& MAX:: + value () const + { + return this->value_.get (); + } + + MAX::value_type& MAX:: + value () + { + return this->value_.get (); + } + + void MAX:: + value (const value_type& x) + { + this->value_.set (x); + } + + void MAX:: + value (::std::auto_ptr< value_type > x) + { + this->value_.set (x); + } + + const MAX::inclusive_type& MAX:: + inclusive () const + { + return this->inclusive_.get (); + } + + MAX::inclusive_type& MAX:: + inclusive () + { + return this->inclusive_.get (); + } + + void MAX:: + inclusive (const inclusive_type& x) + { + this->inclusive_.set (x); + } + + void MAX:: + inclusive (::std::auto_ptr< inclusive_type > x) + { + this->inclusive_.set (x); + } + + const MAX::inclusive_type& MAX:: + inclusive_default_value () + { + return inclusive_default_value_; + } + + + // OPTION + // + + const OPTION::OPTION1_sequence& OPTION:: + OPTION1 () const + { + return this->OPTION1_; + } + + OPTION::OPTION1_sequence& OPTION:: + OPTION1 () + { + return this->OPTION1_; + } + + void OPTION:: + OPTION1 (const OPTION1_sequence& s) + { + this->OPTION1_ = s; + } + + const OPTION::name_optional& OPTION:: + name () const + { + return this->name_; + } + + OPTION::name_optional& OPTION:: + name () + { + return this->name_; + } + + void OPTION:: + name (const name_type& x) + { + this->name_.set (x); + } + + void OPTION:: + name (const name_optional& x) + { + this->name_ = x; + } + + void OPTION:: + name (::std::auto_ptr< name_type > x) + { + this->name_.set (x); + } + + const OPTION::value_type& OPTION:: + value () const + { + return this->value_.get (); + } + + OPTION::value_type& OPTION:: + value () + { + return this->value_.get (); + } + + void OPTION:: + value (const value_type& x) + { + this->value_.set (x); + } + + void OPTION:: + value (::std::auto_ptr< value_type > x) + { + this->value_.set (x); + } + + + // VALUES + // + + const VALUES::MIN_optional& VALUES:: + MIN () const + { + return this->MIN_; + } + + VALUES::MIN_optional& VALUES:: + MIN () + { + return this->MIN_; + } + + void VALUES:: + MIN (const MIN_type& x) + { + this->MIN_.set (x); + } + + void VALUES:: + MIN (const MIN_optional& x) + { + this->MIN_ = x; + } + + void VALUES:: + MIN (::std::auto_ptr< MIN_type > x) + { + this->MIN_.set (x); + } + + const VALUES::MAX_optional& VALUES:: + MAX () const + { + return this->MAX_; + } + + VALUES::MAX_optional& VALUES:: + MAX () + { + return this->MAX_; + } + + void VALUES:: + MAX (const MAX_type& x) + { + this->MAX_.set (x); + } + + void VALUES:: + MAX (const MAX_optional& x) + { + this->MAX_ = x; + } + + void VALUES:: + MAX (::std::auto_ptr< MAX_type > x) + { + this->MAX_.set (x); + } + + const VALUES::OPTION_sequence& VALUES:: + OPTION () const + { + return this->OPTION_; + } + + VALUES::OPTION_sequence& VALUES:: + OPTION () + { + return this->OPTION_; + } + + void VALUES:: + OPTION (const OPTION_sequence& s) + { + this->OPTION_ = s; + } + + const VALUES::ID_optional& VALUES:: + ID () const + { + return this->ID_; + } + + VALUES::ID_optional& VALUES:: + ID () + { + return this->ID_; + } + + void VALUES:: + ID (const ID_type& x) + { + this->ID_.set (x); + } + + void VALUES:: + ID (const ID_optional& x) + { + this->ID_ = x; + } + + void VALUES:: + ID (::std::auto_ptr< ID_type > x) + { + this->ID_.set (x); + } + + const VALUES::type_type& VALUES:: + type () const + { + return this->type_.get (); + } + + VALUES::type_type& VALUES:: + type () + { + return this->type_.get (); + } + + void VALUES:: + type (const type_type& x) + { + this->type_.set (x); + } + + void VALUES:: + type (::std::auto_ptr< type_type > x) + { + this->type_.set (x); + } + + const VALUES::type_type& VALUES:: + type_default_value () + { + return type_default_value_; + } + + const VALUES::null_optional& VALUES:: + null () const + { + return this->null_; + } + + VALUES::null_optional& VALUES:: + null () + { + return this->null_; + } + + void VALUES:: + null (const null_type& x) + { + this->null_.set (x); + } + + void VALUES:: + null (const null_optional& x) + { + this->null_ = x; + } + + void VALUES:: + null (::std::auto_ptr< null_type > x) + { + this->null_.set (x); + } + + const VALUES::ref_optional& VALUES:: + ref () const + { + return this->ref_; + } + + VALUES::ref_optional& VALUES:: + ref () + { + return this->ref_; + } + + void VALUES:: + ref (const ref_type& x) + { + this->ref_.set (x); + } + + void VALUES:: + ref (const ref_optional& x) + { + this->ref_ = x; + } + + void VALUES:: + ref (::std::auto_ptr< ref_type > x) + { + this->ref_.set (x); + } + + + // LINK + // + + const LINK::ID_optional& LINK:: + ID () const + { + return this->ID_; + } + + LINK::ID_optional& LINK:: + ID () + { + return this->ID_; + } + + void LINK:: + ID (const ID_type& x) + { + this->ID_.set (x); + } + + void LINK:: + ID (const ID_optional& x) + { + this->ID_ = x; + } + + void LINK:: + ID (::std::auto_ptr< ID_type > x) + { + this->ID_.set (x); + } + + const LINK::content_role_optional& LINK:: + content_role () const + { + return this->content_role_; + } + + LINK::content_role_optional& LINK:: + content_role () + { + return this->content_role_; + } + + void LINK:: + content_role (const content_role_type& x) + { + this->content_role_.set (x); + } + + void LINK:: + content_role (const content_role_optional& x) + { + this->content_role_ = x; + } + + void LINK:: + content_role (::std::auto_ptr< content_role_type > x) + { + this->content_role_.set (x); + } + + const LINK::content_type_optional& LINK:: + content_type () const + { + return this->content_type_; + } + + LINK::content_type_optional& LINK:: + content_type () + { + return this->content_type_; + } + + void LINK:: + content_type (const content_type_type& x) + { + this->content_type_.set (x); + } + + void LINK:: + content_type (const content_type_optional& x) + { + this->content_type_ = x; + } + + void LINK:: + content_type (::std::auto_ptr< content_type_type > x) + { + this->content_type_.set (x); + } + + const LINK::title_optional& LINK:: + title () const + { + return this->title_; + } + + LINK::title_optional& LINK:: + title () + { + return this->title_; + } + + void LINK:: + title (const title_type& x) + { + this->title_.set (x); + } + + void LINK:: + title (const title_optional& x) + { + this->title_ = x; + } + + void LINK:: + title (::std::auto_ptr< title_type > x) + { + this->title_.set (x); + } + + const LINK::value_optional& LINK:: + value () const + { + return this->value_; + } + + LINK::value_optional& LINK:: + value () + { + return this->value_; + } + + void LINK:: + value (const value_type& x) + { + this->value_.set (x); + } + + void LINK:: + value (const value_optional& x) + { + this->value_ = x; + } + + void LINK:: + value (::std::auto_ptr< value_type > x) + { + this->value_.set (x); + } + + const LINK::href_optional& LINK:: + href () const + { + return this->href_; + } + + LINK::href_optional& LINK:: + href () + { + return this->href_; + } + + void LINK:: + href (const href_type& x) + { + this->href_.set (x); + } + + void LINK:: + href (const href_optional& x) + { + this->href_ = x; + } + + void LINK:: + href (::std::auto_ptr< href_type > x) + { + this->href_.set (x); + } + + const LINK::gref_optional& LINK:: + gref () const + { + return this->gref_; + } + + LINK::gref_optional& LINK:: + gref () + { + return this->gref_; + } + + void LINK:: + gref (const gref_type& x) + { + this->gref_.set (x); + } + + void LINK:: + gref (const gref_optional& x) + { + this->gref_ = x; + } + + void LINK:: + gref (::std::auto_ptr< gref_type > x) + { + this->gref_.set (x); + } + + const LINK::action_optional& LINK:: + action () const + { + return this->action_; + } + + LINK::action_optional& LINK:: + action () + { + return this->action_; + } + + void LINK:: + action (const action_type& x) + { + this->action_.set (x); + } + + void LINK:: + action (const action_optional& x) + { + this->action_ = x; + } + + void LINK:: + action (::std::auto_ptr< action_type > x) + { + this->action_.set (x); + } + + + // INFO + // + + const INFO::ID_optional& INFO:: + ID () const + { + return this->ID_; + } + + INFO::ID_optional& INFO:: + ID () + { + return this->ID_; + } + + void INFO:: + ID (const ID_type& x) + { + this->ID_.set (x); + } + + void INFO:: + ID (const ID_optional& x) + { + this->ID_ = x; + } + + void INFO:: + ID (::std::auto_ptr< ID_type > x) + { + this->ID_.set (x); + } + + const INFO::name_type& INFO:: + name () const + { + return this->name_.get (); + } + + INFO::name_type& INFO:: + name () + { + return this->name_.get (); + } + + void INFO:: + name (const name_type& x) + { + this->name_.set (x); + } + + void INFO:: + name (::std::auto_ptr< name_type > x) + { + this->name_.set (x); + } + + const INFO::value_type& INFO:: + value () const + { + return this->value_.get (); + } + + INFO::value_type& INFO:: + value () + { + return this->value_.get (); + } + + void INFO:: + value (const value_type& x) + { + this->value_.set (x); + } + + void INFO:: + value (::std::auto_ptr< value_type > x) + { + this->value_.set (x); + } + + const INFO::unit_optional& INFO:: + unit () const + { + return this->unit_; + } + + INFO::unit_optional& INFO:: + unit () + { + return this->unit_; + } + + void INFO:: + unit (const unit_type& x) + { + this->unit_.set (x); + } + + void INFO:: + unit (const unit_optional& x) + { + this->unit_ = x; + } + + void INFO:: + unit (::std::auto_ptr< unit_type > x) + { + this->unit_.set (x); + } + + const INFO::xtype_optional& INFO:: + xtype () const + { + return this->xtype_; + } + + INFO::xtype_optional& INFO:: + xtype () + { + return this->xtype_; + } + + void INFO:: + xtype (const xtype_type& x) + { + this->xtype_.set (x); + } + + void INFO:: + xtype (const xtype_optional& x) + { + this->xtype_ = x; + } + + void INFO:: + xtype (::std::auto_ptr< xtype_type > x) + { + this->xtype_.set (x); + } + + const INFO::ref_optional& INFO:: + ref () const + { + return this->ref_; + } + + INFO::ref_optional& INFO:: + ref () + { + return this->ref_; + } + + void INFO:: + ref (const ref_type& x) + { + this->ref_.set (x); + } + + void INFO:: + ref (const ref_optional& x) + { + this->ref_ = x; + } + + void INFO:: + ref (::std::auto_ptr< ref_type > x) + { + this->ref_.set (x); + } + + const INFO::ucd_optional& INFO:: + ucd () const + { + return this->ucd_; + } + + INFO::ucd_optional& INFO:: + ucd () + { + return this->ucd_; + } + + void INFO:: + ucd (const ucd_type& x) + { + this->ucd_.set (x); + } + + void INFO:: + ucd (const ucd_optional& x) + { + this->ucd_ = x; + } + + void INFO:: + ucd (::std::auto_ptr< ucd_type > x) + { + this->ucd_.set (x); + } + + const INFO::utype_optional& INFO:: + utype () const + { + return this->utype_; + } + + INFO::utype_optional& INFO:: + utype () + { + return this->utype_; + } + + void INFO:: + utype (const utype_type& x) + { + this->utype_.set (x); + } + + void INFO:: + utype (const utype_optional& x) + { + this->utype_ = x; + } + + void INFO:: + utype (::std::auto_ptr< utype_type > x) + { + this->utype_.set (x); + } + + + // COOSYS + // + + const COOSYS::ID_type& COOSYS:: + ID () const + { + return this->ID_.get (); + } + + COOSYS::ID_type& COOSYS:: + ID () + { + return this->ID_.get (); + } + + void COOSYS:: + ID (const ID_type& x) + { + this->ID_.set (x); + } + + void COOSYS:: + ID (::std::auto_ptr< ID_type > x) + { + this->ID_.set (x); + } + + const COOSYS::equinox_optional& COOSYS:: + equinox () const + { + return this->equinox_; + } + + COOSYS::equinox_optional& COOSYS:: + equinox () + { + return this->equinox_; + } + + void COOSYS:: + equinox (const equinox_type& x) + { + this->equinox_.set (x); + } + + void COOSYS:: + equinox (const equinox_optional& x) + { + this->equinox_ = x; + } + + void COOSYS:: + equinox (::std::auto_ptr< equinox_type > x) + { + this->equinox_.set (x); + } + + const COOSYS::epoch_optional& COOSYS:: + epoch () const + { + return this->epoch_; + } + + COOSYS::epoch_optional& COOSYS:: + epoch () + { + return this->epoch_; + } + + void COOSYS:: + epoch (const epoch_type& x) + { + this->epoch_.set (x); + } + + void COOSYS:: + epoch (const epoch_optional& x) + { + this->epoch_ = x; + } + + void COOSYS:: + epoch (::std::auto_ptr< epoch_type > x) + { + this->epoch_.set (x); + } + + const COOSYS::system_type& COOSYS:: + system () const + { + return this->system_.get (); + } + + COOSYS::system_type& COOSYS:: + system () + { + return this->system_.get (); + } + + void COOSYS:: + system (const system_type& x) + { + this->system_.set (x); + } + + void COOSYS:: + system (::std::auto_ptr< system_type > x) + { + this->system_.set (x); + } + + const COOSYS::system_type& COOSYS:: + system_default_value () + { + return system_default_value_; + } + + + // DEFINITIONS + // + + const DEFINITIONS::COOSYS_sequence& DEFINITIONS:: + COOSYS () const + { + return this->COOSYS_; + } + + DEFINITIONS::COOSYS_sequence& DEFINITIONS:: + COOSYS () + { + return this->COOSYS_; + } + + void DEFINITIONS:: + COOSYS (const COOSYS_sequence& s) + { + this->COOSYS_ = s; + } + + const DEFINITIONS::PARAM_sequence& DEFINITIONS:: + PARAM () const + { + return this->PARAM_; + } + + DEFINITIONS::PARAM_sequence& DEFINITIONS:: + PARAM () + { + return this->PARAM_; + } + + void DEFINITIONS:: + PARAM (const PARAM_sequence& s) + { + this->PARAM_ = s; + } + + + // FIELD + // + + const FIELD::DESCRIPTION_optional& FIELD:: + DESCRIPTION () const + { + return this->DESCRIPTION_; + } + + FIELD::DESCRIPTION_optional& FIELD:: + DESCRIPTION () + { + return this->DESCRIPTION_; + } + + void FIELD:: + DESCRIPTION (const DESCRIPTION_type& x) + { + this->DESCRIPTION_.set (x); + } + + void FIELD:: + DESCRIPTION (const DESCRIPTION_optional& x) + { + this->DESCRIPTION_ = x; + } + + void FIELD:: + DESCRIPTION (::std::auto_ptr< DESCRIPTION_type > x) + { + this->DESCRIPTION_.set (x); + } + + const FIELD::VALUES_optional& FIELD:: + VALUES () const + { + return this->VALUES_; + } + + FIELD::VALUES_optional& FIELD:: + VALUES () + { + return this->VALUES_; + } + + void FIELD:: + VALUES (const VALUES_type& x) + { + this->VALUES_.set (x); + } + + void FIELD:: + VALUES (const VALUES_optional& x) + { + this->VALUES_ = x; + } + + void FIELD:: + VALUES (::std::auto_ptr< VALUES_type > x) + { + this->VALUES_.set (x); + } + + const FIELD::LINK_sequence& FIELD:: + LINK () const + { + return this->LINK_; + } + + FIELD::LINK_sequence& FIELD:: + LINK () + { + return this->LINK_; + } + + void FIELD:: + LINK (const LINK_sequence& s) + { + this->LINK_ = s; + } + + const FIELD::ID_optional& FIELD:: + ID () const + { + return this->ID_; + } + + FIELD::ID_optional& FIELD:: + ID () + { + return this->ID_; + } + + void FIELD:: + ID (const ID_type& x) + { + this->ID_.set (x); + } + + void FIELD:: + ID (const ID_optional& x) + { + this->ID_ = x; + } + + void FIELD:: + ID (::std::auto_ptr< ID_type > x) + { + this->ID_.set (x); + } + + const FIELD::unit_optional& FIELD:: + unit () const + { + return this->unit_; + } + + FIELD::unit_optional& FIELD:: + unit () + { + return this->unit_; + } + + void FIELD:: + unit (const unit_type& x) + { + this->unit_.set (x); + } + + void FIELD:: + unit (const unit_optional& x) + { + this->unit_ = x; + } + + void FIELD:: + unit (::std::auto_ptr< unit_type > x) + { + this->unit_.set (x); + } + + const FIELD::datatype_optional& FIELD:: + datatype () const + { + return this->datatype_; + } + + FIELD::datatype_optional& FIELD:: + datatype () + { + return this->datatype_; + } + + void FIELD:: + datatype (const datatype_type& x) + { + this->datatype_.set (x); + } + + void FIELD:: + datatype (const datatype_optional& x) + { + this->datatype_ = x; + } + + void FIELD:: + datatype (::std::auto_ptr< datatype_type > x) + { + this->datatype_.set (x); + } + + const FIELD::precision_optional& FIELD:: + precision () const + { + return this->precision_; + } + + FIELD::precision_optional& FIELD:: + precision () + { + return this->precision_; + } + + void FIELD:: + precision (const precision_type& x) + { + this->precision_.set (x); + } + + void FIELD:: + precision (const precision_optional& x) + { + this->precision_ = x; + } + + void FIELD:: + precision (::std::auto_ptr< precision_type > x) + { + this->precision_.set (x); + } + + const FIELD::width_optional& FIELD:: + width () const + { + return this->width_; + } + + FIELD::width_optional& FIELD:: + width () + { + return this->width_; + } + + void FIELD:: + width (const width_type& x) + { + this->width_.set (x); + } + + void FIELD:: + width (const width_optional& x) + { + this->width_ = x; + } + + const FIELD::xtype_optional& FIELD:: + xtype () const + { + return this->xtype_; + } + + FIELD::xtype_optional& FIELD:: + xtype () + { + return this->xtype_; + } + + void FIELD:: + xtype (const xtype_type& x) + { + this->xtype_.set (x); + } + + void FIELD:: + xtype (const xtype_optional& x) + { + this->xtype_ = x; + } + + void FIELD:: + xtype (::std::auto_ptr< xtype_type > x) + { + this->xtype_.set (x); + } + + const FIELD::ref_optional& FIELD:: + ref () const + { + return this->ref_; + } + + FIELD::ref_optional& FIELD:: + ref () + { + return this->ref_; + } + + void FIELD:: + ref (const ref_type& x) + { + this->ref_.set (x); + } + + void FIELD:: + ref (const ref_optional& x) + { + this->ref_ = x; + } + + void FIELD:: + ref (::std::auto_ptr< ref_type > x) + { + this->ref_.set (x); + } + + const FIELD::name_optional& FIELD:: + name () const + { + return this->name_; + } + + FIELD::name_optional& FIELD:: + name () + { + return this->name_; + } + + void FIELD:: + name (const name_type& x) + { + this->name_.set (x); + } + + void FIELD:: + name (const name_optional& x) + { + this->name_ = x; + } + + void FIELD:: + name (::std::auto_ptr< name_type > x) + { + this->name_.set (x); + } + + const FIELD::ucd_optional& FIELD:: + ucd () const + { + return this->ucd_; + } + + FIELD::ucd_optional& FIELD:: + ucd () + { + return this->ucd_; + } + + void FIELD:: + ucd (const ucd_type& x) + { + this->ucd_.set (x); + } + + void FIELD:: + ucd (const ucd_optional& x) + { + this->ucd_ = x; + } + + void FIELD:: + ucd (::std::auto_ptr< ucd_type > x) + { + this->ucd_.set (x); + } + + const FIELD::utype_optional& FIELD:: + utype () const + { + return this->utype_; + } + + FIELD::utype_optional& FIELD:: + utype () + { + return this->utype_; + } + + void FIELD:: + utype (const utype_type& x) + { + this->utype_.set (x); + } + + void FIELD:: + utype (const utype_optional& x) + { + this->utype_ = x; + } + + void FIELD:: + utype (::std::auto_ptr< utype_type > x) + { + this->utype_.set (x); + } + + const FIELD::arraysize_optional& FIELD:: + arraysize () const + { + return this->arraysize_; + } + + FIELD::arraysize_optional& FIELD:: + arraysize () + { + return this->arraysize_; + } + + void FIELD:: + arraysize (const arraysize_type& x) + { + this->arraysize_.set (x); + } + + void FIELD:: + arraysize (const arraysize_optional& x) + { + this->arraysize_ = x; + } + + void FIELD:: + arraysize (::std::auto_ptr< arraysize_type > x) + { + this->arraysize_.set (x); + } + + const FIELD::type_optional& FIELD:: + type () const + { + return this->type_; + } + + FIELD::type_optional& FIELD:: + type () + { + return this->type_; + } + + void FIELD:: + type (const type_type& x) + { + this->type_.set (x); + } + + void FIELD:: + type (const type_optional& x) + { + this->type_ = x; + } + + void FIELD:: + type (::std::auto_ptr< type_type > x) + { + this->type_.set (x); + } + + + // PARAM + // + + const PARAM::value_optional& PARAM:: + value () const + { + return this->value_; + } + + PARAM::value_optional& PARAM:: + value () + { + return this->value_; + } + + void PARAM:: + value (const value_type& x) + { + this->value_.set (x); + } + + void PARAM:: + value (const value_optional& x) + { + this->value_ = x; + } + + void PARAM:: + value (::std::auto_ptr< value_type > x) + { + this->value_.set (x); + } + + + // GROUP + // + + const GROUP::DESCRIPTION_optional& GROUP:: + DESCRIPTION () const + { + return this->DESCRIPTION_; + } + + GROUP::DESCRIPTION_optional& GROUP:: + DESCRIPTION () + { + return this->DESCRIPTION_; + } + + void GROUP:: + DESCRIPTION (const DESCRIPTION_type& x) + { + this->DESCRIPTION_.set (x); + } + + void GROUP:: + DESCRIPTION (const DESCRIPTION_optional& x) + { + this->DESCRIPTION_ = x; + } + + void GROUP:: + DESCRIPTION (::std::auto_ptr< DESCRIPTION_type > x) + { + this->DESCRIPTION_.set (x); + } + + const GROUP::FIELDref_sequence& GROUP:: + FIELDref () const + { + return this->FIELDref_; + } + + GROUP::FIELDref_sequence& GROUP:: + FIELDref () + { + return this->FIELDref_; + } + + void GROUP:: + FIELDref (const FIELDref_sequence& s) + { + this->FIELDref_ = s; + } + + const GROUP::PARAMref_sequence& GROUP:: + PARAMref () const + { + return this->PARAMref_; + } + + GROUP::PARAMref_sequence& GROUP:: + PARAMref () + { + return this->PARAMref_; + } + + void GROUP:: + PARAMref (const PARAMref_sequence& s) + { + this->PARAMref_ = s; + } + + const GROUP::PARAM_sequence& GROUP:: + PARAM () const + { + return this->PARAM_; + } + + GROUP::PARAM_sequence& GROUP:: + PARAM () + { + return this->PARAM_; + } + + void GROUP:: + PARAM (const PARAM_sequence& s) + { + this->PARAM_ = s; + } + + const GROUP::GROUP1_sequence& GROUP:: + GROUP1 () const + { + return this->GROUP1_; + } + + GROUP::GROUP1_sequence& GROUP:: + GROUP1 () + { + return this->GROUP1_; + } + + void GROUP:: + GROUP1 (const GROUP1_sequence& s) + { + this->GROUP1_ = s; + } + + const GROUP::ID_optional& GROUP:: + ID () const + { + return this->ID_; + } + + GROUP::ID_optional& GROUP:: + ID () + { + return this->ID_; + } + + void GROUP:: + ID (const ID_type& x) + { + this->ID_.set (x); + } + + void GROUP:: + ID (const ID_optional& x) + { + this->ID_ = x; + } + + void GROUP:: + ID (::std::auto_ptr< ID_type > x) + { + this->ID_.set (x); + } + + const GROUP::name_optional& GROUP:: + name () const + { + return this->name_; + } + + GROUP::name_optional& GROUP:: + name () + { + return this->name_; + } + + void GROUP:: + name (const name_type& x) + { + this->name_.set (x); + } + + void GROUP:: + name (const name_optional& x) + { + this->name_ = x; + } + + void GROUP:: + name (::std::auto_ptr< name_type > x) + { + this->name_.set (x); + } + + const GROUP::ref_optional& GROUP:: + ref () const + { + return this->ref_; + } + + GROUP::ref_optional& GROUP:: + ref () + { + return this->ref_; + } + + void GROUP:: + ref (const ref_type& x) + { + this->ref_.set (x); + } + + void GROUP:: + ref (const ref_optional& x) + { + this->ref_ = x; + } + + void GROUP:: + ref (::std::auto_ptr< ref_type > x) + { + this->ref_.set (x); + } + + const GROUP::ucd_optional& GROUP:: + ucd () const + { + return this->ucd_; + } + + GROUP::ucd_optional& GROUP:: + ucd () + { + return this->ucd_; + } + + void GROUP:: + ucd (const ucd_type& x) + { + this->ucd_.set (x); + } + + void GROUP:: + ucd (const ucd_optional& x) + { + this->ucd_ = x; + } + + void GROUP:: + ucd (::std::auto_ptr< ucd_type > x) + { + this->ucd_.set (x); + } + + const GROUP::utype_optional& GROUP:: + utype () const + { + return this->utype_; + } + + GROUP::utype_optional& GROUP:: + utype () + { + return this->utype_; + } + + void GROUP:: + utype (const utype_type& x) + { + this->utype_.set (x); + } + + void GROUP:: + utype (const utype_optional& x) + { + this->utype_ = x; + } + + void GROUP:: + utype (::std::auto_ptr< utype_type > x) + { + this->utype_.set (x); + } + + + // FIELDref + // + + const FIELDref::ref_type& FIELDref:: + ref () const + { + return this->ref_.get (); + } + + FIELDref::ref_type& FIELDref:: + ref () + { + return this->ref_.get (); + } + + void FIELDref:: + ref (const ref_type& x) + { + this->ref_.set (x); + } + + void FIELDref:: + ref (::std::auto_ptr< ref_type > x) + { + this->ref_.set (x); + } + + const FIELDref::ucd_optional& FIELDref:: + ucd () const + { + return this->ucd_; + } + + FIELDref::ucd_optional& FIELDref:: + ucd () + { + return this->ucd_; + } + + void FIELDref:: + ucd (const ucd_type& x) + { + this->ucd_.set (x); + } + + void FIELDref:: + ucd (const ucd_optional& x) + { + this->ucd_ = x; + } + + void FIELDref:: + ucd (::std::auto_ptr< ucd_type > x) + { + this->ucd_.set (x); + } + + const FIELDref::utype_optional& FIELDref:: + utype () const + { + return this->utype_; + } + + FIELDref::utype_optional& FIELDref:: + utype () + { + return this->utype_; + } + + void FIELDref:: + utype (const utype_type& x) + { + this->utype_.set (x); + } + + void FIELDref:: + utype (const utype_optional& x) + { + this->utype_ = x; + } + + void FIELDref:: + utype (::std::auto_ptr< utype_type > x) + { + this->utype_.set (x); + } + + + // PARAMref + // + + const PARAMref::ref_type& PARAMref:: + ref () const + { + return this->ref_.get (); + } + + PARAMref::ref_type& PARAMref:: + ref () + { + return this->ref_.get (); + } + + void PARAMref:: + ref (const ref_type& x) + { + this->ref_.set (x); + } + + void PARAMref:: + ref (::std::auto_ptr< ref_type > x) + { + this->ref_.set (x); + } + + const PARAMref::ucd_optional& PARAMref:: + ucd () const + { + return this->ucd_; + } + + PARAMref::ucd_optional& PARAMref:: + ucd () + { + return this->ucd_; + } + + void PARAMref:: + ucd (const ucd_type& x) + { + this->ucd_.set (x); + } + + void PARAMref:: + ucd (const ucd_optional& x) + { + this->ucd_ = x; + } + + void PARAMref:: + ucd (::std::auto_ptr< ucd_type > x) + { + this->ucd_.set (x); + } + + const PARAMref::utype_optional& PARAMref:: + utype () const + { + return this->utype_; + } + + PARAMref::utype_optional& PARAMref:: + utype () + { + return this->utype_; + } + + void PARAMref:: + utype (const utype_type& x) + { + this->utype_.set (x); + } + + void PARAMref:: + utype (const utype_optional& x) + { + this->utype_ = x; + } + + void PARAMref:: + utype (::std::auto_ptr< utype_type > x) + { + this->utype_.set (x); + } + + + // DATA + // + + const DATA::TABLEDATA_optional& DATA:: + TABLEDATA () const + { + return this->TABLEDATA_; + } + + DATA::TABLEDATA_optional& DATA:: + TABLEDATA () + { + return this->TABLEDATA_; + } + + void DATA:: + TABLEDATA (const TABLEDATA_type& x) + { + this->TABLEDATA_.set (x); + } + + void DATA:: + TABLEDATA (const TABLEDATA_optional& x) + { + this->TABLEDATA_ = x; + } + + void DATA:: + TABLEDATA (::std::auto_ptr< TABLEDATA_type > x) + { + this->TABLEDATA_.set (x); + } + + const DATA::BINARY_optional& DATA:: + BINARY () const + { + return this->BINARY_; + } + + DATA::BINARY_optional& DATA:: + BINARY () + { + return this->BINARY_; + } + + void DATA:: + BINARY (const BINARY_type& x) + { + this->BINARY_.set (x); + } + + void DATA:: + BINARY (const BINARY_optional& x) + { + this->BINARY_ = x; + } + + void DATA:: + BINARY (::std::auto_ptr< BINARY_type > x) + { + this->BINARY_.set (x); + } + + const DATA::BINARY2_optional& DATA:: + BINARY2 () const + { + return this->BINARY2_; + } + + DATA::BINARY2_optional& DATA:: + BINARY2 () + { + return this->BINARY2_; + } + + void DATA:: + BINARY2 (const BINARY2_type& x) + { + this->BINARY2_.set (x); + } + + void DATA:: + BINARY2 (const BINARY2_optional& x) + { + this->BINARY2_ = x; + } + + void DATA:: + BINARY2 (::std::auto_ptr< BINARY2_type > x) + { + this->BINARY2_.set (x); + } + + const DATA::FITS_optional& DATA:: + FITS () const + { + return this->FITS_; + } + + DATA::FITS_optional& DATA:: + FITS () + { + return this->FITS_; + } + + void DATA:: + FITS (const FITS_type& x) + { + this->FITS_.set (x); + } + + void DATA:: + FITS (const FITS_optional& x) + { + this->FITS_ = x; + } + + void DATA:: + FITS (::std::auto_ptr< FITS_type > x) + { + this->FITS_.set (x); + } + + const DATA::INFO_sequence& DATA:: + INFO () const + { + return this->INFO_; + } + + DATA::INFO_sequence& DATA:: + INFO () + { + return this->INFO_; + } + + void DATA:: + INFO (const INFO_sequence& s) + { + this->INFO_ = s; + } + + + // TABLEDATA + // + + const TABLEDATA::TR_sequence& TABLEDATA:: + TR () const + { + return this->TR_; + } + + TABLEDATA::TR_sequence& TABLEDATA:: + TR () + { + return this->TR_; + } + + void TABLEDATA:: + TR (const TR_sequence& s) + { + this->TR_ = s; + } + + + // TD + // + + const TD::encoding_optional& TD:: + encoding () const + { + return this->encoding_; + } + + TD::encoding_optional& TD:: + encoding () + { + return this->encoding_; + } + + void TD:: + encoding (const encoding_type& x) + { + this->encoding_.set (x); + } + + void TD:: + encoding (const encoding_optional& x) + { + this->encoding_ = x; + } + + void TD:: + encoding (::std::auto_ptr< encoding_type > x) + { + this->encoding_.set (x); + } + + + // TR + // + + const TR::TD_sequence& TR:: + TD () const + { + return this->TD_; + } + + TR::TD_sequence& TR:: + TD () + { + return this->TD_; + } + + void TR:: + TD (const TD_sequence& s) + { + this->TD_ = s; + } + + const TR::ID_optional& TR:: + ID () const + { + return this->ID_; + } + + TR::ID_optional& TR:: + ID () + { + return this->ID_; + } + + void TR:: + ID (const ID_type& x) + { + this->ID_.set (x); + } + + void TR:: + ID (const ID_optional& x) + { + this->ID_ = x; + } + + void TR:: + ID (::std::auto_ptr< ID_type > x) + { + this->ID_.set (x); + } + + + // FITS + // + + const FITS::STREAM_type& FITS:: + STREAM () const + { + return this->STREAM_.get (); + } + + FITS::STREAM_type& FITS:: + STREAM () + { + return this->STREAM_.get (); + } + + void FITS:: + STREAM (const STREAM_type& x) + { + this->STREAM_.set (x); + } + + void FITS:: + STREAM (::std::auto_ptr< STREAM_type > x) + { + this->STREAM_.set (x); + } + + const FITS::extnum_optional& FITS:: + extnum () const + { + return this->extnum_; + } + + FITS::extnum_optional& FITS:: + extnum () + { + return this->extnum_; + } + + void FITS:: + extnum (const extnum_type& x) + { + this->extnum_.set (x); + } + + void FITS:: + extnum (const extnum_optional& x) + { + this->extnum_ = x; + } + + + // BINARY + // + + const BINARY::STREAM_type& BINARY:: + STREAM () const + { + return this->STREAM_.get (); + } + + BINARY::STREAM_type& BINARY:: + STREAM () + { + return this->STREAM_.get (); + } + + void BINARY:: + STREAM (const STREAM_type& x) + { + this->STREAM_.set (x); + } + + void BINARY:: + STREAM (::std::auto_ptr< STREAM_type > x) + { + this->STREAM_.set (x); + } + + + // BINARY2 + // + + const BINARY2::STREAM_type& BINARY2:: + STREAM () const + { + return this->STREAM_.get (); + } + + BINARY2::STREAM_type& BINARY2:: + STREAM () + { + return this->STREAM_.get (); + } + + void BINARY2:: + STREAM (const STREAM_type& x) + { + this->STREAM_.set (x); + } + + void BINARY2:: + STREAM (::std::auto_ptr< STREAM_type > x) + { + this->STREAM_.set (x); + } + + + // STREAM + // + + const STREAM::type_type& STREAM:: + type () const + { + return this->type_.get (); + } + + STREAM::type_type& STREAM:: + type () + { + return this->type_.get (); + } + + void STREAM:: + type (const type_type& x) + { + this->type_.set (x); + } + + void STREAM:: + type (::std::auto_ptr< type_type > x) + { + this->type_.set (x); + } + + const STREAM::type_type& STREAM:: + type_default_value () + { + return type_default_value_; + } + + const STREAM::href_optional& STREAM:: + href () const + { + return this->href_; + } + + STREAM::href_optional& STREAM:: + href () + { + return this->href_; + } + + void STREAM:: + href (const href_type& x) + { + this->href_.set (x); + } + + void STREAM:: + href (const href_optional& x) + { + this->href_ = x; + } + + void STREAM:: + href (::std::auto_ptr< href_type > x) + { + this->href_.set (x); + } + + const STREAM::actuate_type& STREAM:: + actuate () const + { + return this->actuate_.get (); + } + + STREAM::actuate_type& STREAM:: + actuate () + { + return this->actuate_.get (); + } + + void STREAM:: + actuate (const actuate_type& x) + { + this->actuate_.set (x); + } + + void STREAM:: + actuate (::std::auto_ptr< actuate_type > x) + { + this->actuate_.set (x); + } + + const STREAM::actuate_type& STREAM:: + actuate_default_value () + { + return actuate_default_value_; + } + + const STREAM::encoding_type& STREAM:: + encoding () const + { + return this->encoding_.get (); + } + + STREAM::encoding_type& STREAM:: + encoding () + { + return this->encoding_.get (); + } + + void STREAM:: + encoding (const encoding_type& x) + { + this->encoding_.set (x); + } + + void STREAM:: + encoding (::std::auto_ptr< encoding_type > x) + { + this->encoding_.set (x); + } + + const STREAM::encoding_type& STREAM:: + encoding_default_value () + { + return encoding_default_value_; + } + + const STREAM::expires_optional& STREAM:: + expires () const + { + return this->expires_; + } + + STREAM::expires_optional& STREAM:: + expires () + { + return this->expires_; + } + + void STREAM:: + expires (const expires_type& x) + { + this->expires_.set (x); + } + + void STREAM:: + expires (const expires_optional& x) + { + this->expires_ = x; + } + + void STREAM:: + expires (::std::auto_ptr< expires_type > x) + { + this->expires_.set (x); + } + + const STREAM::rights_optional& STREAM:: + rights () const + { + return this->rights_; + } + + STREAM::rights_optional& STREAM:: + rights () + { + return this->rights_; + } + + void STREAM:: + rights (const rights_type& x) + { + this->rights_.set (x); + } + + void STREAM:: + rights (const rights_optional& x) + { + this->rights_ = x; + } + + void STREAM:: + rights (::std::auto_ptr< rights_type > x) + { + this->rights_.set (x); + } + + + // TABLE + // + + const TABLE::DESCRIPTION_optional& TABLE:: + DESCRIPTION () const + { + return this->DESCRIPTION_; + } + + TABLE::DESCRIPTION_optional& TABLE:: + DESCRIPTION () + { + return this->DESCRIPTION_; + } + + void TABLE:: + DESCRIPTION (const DESCRIPTION_type& x) + { + this->DESCRIPTION_.set (x); + } + + void TABLE:: + DESCRIPTION (const DESCRIPTION_optional& x) + { + this->DESCRIPTION_ = x; + } + + void TABLE:: + DESCRIPTION (::std::auto_ptr< DESCRIPTION_type > x) + { + this->DESCRIPTION_.set (x); + } + + const TABLE::INFO_sequence& TABLE:: + INFO () const + { + return this->INFO_; + } + + TABLE::INFO_sequence& TABLE:: + INFO () + { + return this->INFO_; + } + + void TABLE:: + INFO (const INFO_sequence& s) + { + this->INFO_ = s; + } + + const TABLE::FIELD_sequence& TABLE:: + FIELD () const + { + return this->FIELD_; + } + + TABLE::FIELD_sequence& TABLE:: + FIELD () + { + return this->FIELD_; + } + + void TABLE:: + FIELD (const FIELD_sequence& s) + { + this->FIELD_ = s; + } + + const TABLE::PARAM_sequence& TABLE:: + PARAM () const + { + return this->PARAM_; + } + + TABLE::PARAM_sequence& TABLE:: + PARAM () + { + return this->PARAM_; + } + + void TABLE:: + PARAM (const PARAM_sequence& s) + { + this->PARAM_ = s; + } + + const TABLE::GROUP_sequence& TABLE:: + GROUP () const + { + return this->GROUP_; + } + + TABLE::GROUP_sequence& TABLE:: + GROUP () + { + return this->GROUP_; + } + + void TABLE:: + GROUP (const GROUP_sequence& s) + { + this->GROUP_ = s; + } + + const TABLE::LINK_sequence& TABLE:: + LINK () const + { + return this->LINK_; + } + + TABLE::LINK_sequence& TABLE:: + LINK () + { + return this->LINK_; + } + + void TABLE:: + LINK (const LINK_sequence& s) + { + this->LINK_ = s; + } + + const TABLE::DATA_optional& TABLE:: + DATA () const + { + return this->DATA_; + } + + TABLE::DATA_optional& TABLE:: + DATA () + { + return this->DATA_; + } + + void TABLE:: + DATA (const DATA_type& x) + { + this->DATA_.set (x); + } + + void TABLE:: + DATA (const DATA_optional& x) + { + this->DATA_ = x; + } + + void TABLE:: + DATA (::std::auto_ptr< DATA_type > x) + { + this->DATA_.set (x); + } + + const TABLE::ID_optional& TABLE:: + ID () const + { + return this->ID_; + } + + TABLE::ID_optional& TABLE:: + ID () + { + return this->ID_; + } + + void TABLE:: + ID (const ID_type& x) + { + this->ID_.set (x); + } + + void TABLE:: + ID (const ID_optional& x) + { + this->ID_ = x; + } + + void TABLE:: + ID (::std::auto_ptr< ID_type > x) + { + this->ID_.set (x); + } + + const TABLE::name_optional& TABLE:: + name () const + { + return this->name_; + } + + TABLE::name_optional& TABLE:: + name () + { + return this->name_; + } + + void TABLE:: + name (const name_type& x) + { + this->name_.set (x); + } + + void TABLE:: + name (const name_optional& x) + { + this->name_ = x; + } + + void TABLE:: + name (::std::auto_ptr< name_type > x) + { + this->name_.set (x); + } + + const TABLE::ref_optional& TABLE:: + ref () const + { + return this->ref_; + } + + TABLE::ref_optional& TABLE:: + ref () + { + return this->ref_; + } + + void TABLE:: + ref (const ref_type& x) + { + this->ref_.set (x); + } + + void TABLE:: + ref (const ref_optional& x) + { + this->ref_ = x; + } + + void TABLE:: + ref (::std::auto_ptr< ref_type > x) + { + this->ref_.set (x); + } + + const TABLE::ucd_optional& TABLE:: + ucd () const + { + return this->ucd_; + } + + TABLE::ucd_optional& TABLE:: + ucd () + { + return this->ucd_; + } + + void TABLE:: + ucd (const ucd_type& x) + { + this->ucd_.set (x); + } + + void TABLE:: + ucd (const ucd_optional& x) + { + this->ucd_ = x; + } + + void TABLE:: + ucd (::std::auto_ptr< ucd_type > x) + { + this->ucd_.set (x); + } + + const TABLE::utype_optional& TABLE:: + utype () const + { + return this->utype_; + } + + TABLE::utype_optional& TABLE:: + utype () + { + return this->utype_; + } + + void TABLE:: + utype (const utype_type& x) + { + this->utype_.set (x); + } + + void TABLE:: + utype (const utype_optional& x) + { + this->utype_ = x; + } + + void TABLE:: + utype (::std::auto_ptr< utype_type > x) + { + this->utype_.set (x); + } + + const TABLE::nrows_optional& TABLE:: + nrows () const + { + return this->nrows_; + } + + TABLE::nrows_optional& TABLE:: + nrows () + { + return this->nrows_; + } + + void TABLE:: + nrows (const nrows_type& x) + { + this->nrows_.set (x); + } + + void TABLE:: + nrows (const nrows_optional& x) + { + this->nrows_ = x; + } + + + // RESOURCE + // + + const RESOURCE::DESCRIPTION_optional& RESOURCE:: + DESCRIPTION () const + { + return this->DESCRIPTION_; + } + + RESOURCE::DESCRIPTION_optional& RESOURCE:: + DESCRIPTION () + { + return this->DESCRIPTION_; + } + + void RESOURCE:: + DESCRIPTION (const DESCRIPTION_type& x) + { + this->DESCRIPTION_.set (x); + } + + void RESOURCE:: + DESCRIPTION (const DESCRIPTION_optional& x) + { + this->DESCRIPTION_ = x; + } + + void RESOURCE:: + DESCRIPTION (::std::auto_ptr< DESCRIPTION_type > x) + { + this->DESCRIPTION_.set (x); + } + + const RESOURCE::INFO_sequence& RESOURCE:: + INFO () const + { + return this->INFO_; + } + + RESOURCE::INFO_sequence& RESOURCE:: + INFO () + { + return this->INFO_; + } + + void RESOURCE:: + INFO (const INFO_sequence& s) + { + this->INFO_ = s; + } + + const RESOURCE::COOSYS_sequence& RESOURCE:: + COOSYS () const + { + return this->COOSYS_; + } + + RESOURCE::COOSYS_sequence& RESOURCE:: + COOSYS () + { + return this->COOSYS_; + } + + void RESOURCE:: + COOSYS (const COOSYS_sequence& s) + { + this->COOSYS_ = s; + } + + const RESOURCE::GROUP_sequence& RESOURCE:: + GROUP () const + { + return this->GROUP_; + } + + RESOURCE::GROUP_sequence& RESOURCE:: + GROUP () + { + return this->GROUP_; + } + + void RESOURCE:: + GROUP (const GROUP_sequence& s) + { + this->GROUP_ = s; + } + + const RESOURCE::PARAM_sequence& RESOURCE:: + PARAM () const + { + return this->PARAM_; + } + + RESOURCE::PARAM_sequence& RESOURCE:: + PARAM () + { + return this->PARAM_; + } + + void RESOURCE:: + PARAM (const PARAM_sequence& s) + { + this->PARAM_ = s; + } + + const RESOURCE::LINK_sequence& RESOURCE:: + LINK () const + { + return this->LINK_; + } + + RESOURCE::LINK_sequence& RESOURCE:: + LINK () + { + return this->LINK_; + } + + void RESOURCE:: + LINK (const LINK_sequence& s) + { + this->LINK_ = s; + } + + const RESOURCE::TABLE_sequence& RESOURCE:: + TABLE () const + { + return this->TABLE_; + } + + RESOURCE::TABLE_sequence& RESOURCE:: + TABLE () + { + return this->TABLE_; + } + + void RESOURCE:: + TABLE (const TABLE_sequence& s) + { + this->TABLE_ = s; + } + + const RESOURCE::RESOURCE1_sequence& RESOURCE:: + RESOURCE1 () const + { + return this->RESOURCE1_; + } + + RESOURCE::RESOURCE1_sequence& RESOURCE:: + RESOURCE1 () + { + return this->RESOURCE1_; + } + + void RESOURCE:: + RESOURCE1 (const RESOURCE1_sequence& s) + { + this->RESOURCE1_ = s; + } + + const RESOURCE::any_sequence& RESOURCE:: + any () const + { + return this->any_; + } + + RESOURCE::any_sequence& RESOURCE:: + any () + { + return this->any_; + } + + void RESOURCE:: + any (const any_sequence& s) + { + this->any_ = s; + } + + const RESOURCE::name_optional& RESOURCE:: + name () const + { + return this->name_; + } + + RESOURCE::name_optional& RESOURCE:: + name () + { + return this->name_; + } + + void RESOURCE:: + name (const name_type& x) + { + this->name_.set (x); + } + + void RESOURCE:: + name (const name_optional& x) + { + this->name_ = x; + } + + void RESOURCE:: + name (::std::auto_ptr< name_type > x) + { + this->name_.set (x); + } + + const RESOURCE::ID_optional& RESOURCE:: + ID () const + { + return this->ID_; + } + + RESOURCE::ID_optional& RESOURCE:: + ID () + { + return this->ID_; + } + + void RESOURCE:: + ID (const ID_type& x) + { + this->ID_.set (x); + } + + void RESOURCE:: + ID (const ID_optional& x) + { + this->ID_ = x; + } + + void RESOURCE:: + ID (::std::auto_ptr< ID_type > x) + { + this->ID_.set (x); + } + + const RESOURCE::utype_optional& RESOURCE:: + utype () const + { + return this->utype_; + } + + RESOURCE::utype_optional& RESOURCE:: + utype () + { + return this->utype_; + } + + void RESOURCE:: + utype (const utype_type& x) + { + this->utype_.set (x); + } + + void RESOURCE:: + utype (const utype_optional& x) + { + this->utype_ = x; + } + + void RESOURCE:: + utype (::std::auto_ptr< utype_type > x) + { + this->utype_.set (x); + } + + const RESOURCE::type_type& RESOURCE:: + type () const + { + return this->type_.get (); + } + + RESOURCE::type_type& RESOURCE:: + type () + { + return this->type_.get (); + } + + void RESOURCE:: + type (const type_type& x) + { + this->type_.set (x); + } + + void RESOURCE:: + type (::std::auto_ptr< type_type > x) + { + this->type_.set (x); + } + + const RESOURCE::type_type& RESOURCE:: + type_default_value () + { + return type_default_value_; + } + + const RESOURCE::any_attribute_set& RESOURCE:: + any_attribute () const + { + return this->any_attribute_; + } + + RESOURCE::any_attribute_set& RESOURCE:: + any_attribute () + { + return this->any_attribute_; + } + + void RESOURCE:: + any_attribute (const any_attribute_set& s) + { + this->any_attribute_ = s; + } + + const ::xercesc::DOMDocument& RESOURCE:: + dom_document () const + { + return *dom_document_; + } + + ::xercesc::DOMDocument& RESOURCE:: + dom_document () + { + return *dom_document_; + } + + + // type + // + + type:: + type (value v) + : ::xml_schema::nmtoken (_xsd_type_literals_[v]) + { + } + + type:: + type (const char* v) + : ::xml_schema::nmtoken (v) + { + } + + type:: + type (const ::std::string& v) + : ::xml_schema::nmtoken (v) + { + } + + type:: + type (const ::xml_schema::nmtoken& v) + : ::xml_schema::nmtoken (v) + { + } + + type:: + type (const type& v, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (v, f, c) + { + } + + type& type:: + operator= (value v) + { + static_cast< ::xml_schema::nmtoken& > (*this) = + ::xml_schema::nmtoken (_xsd_type_literals_[v]); + + return *this; + } + + + // system + // + + system:: + system (value v) + : ::xml_schema::nmtoken (_xsd_system_literals_[v]) + { + } + + system:: + system (const char* v) + : ::xml_schema::nmtoken (v) + { + } + + system:: + system (const ::std::string& v) + : ::xml_schema::nmtoken (v) + { + } + + system:: + system (const ::xml_schema::nmtoken& v) + : ::xml_schema::nmtoken (v) + { + } + + system:: + system (const system& v, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (v, f, c) + { + } + + system& system:: + operator= (value v) + { + static_cast< ::xml_schema::nmtoken& > (*this) = + ::xml_schema::nmtoken (_xsd_system_literals_[v]); + + return *this; + } + + + // type1 + // + + type1:: + type1 (value v) + : ::xml_schema::nmtoken (_xsd_type1_literals_[v]) + { + } + + type1:: + type1 (const char* v) + : ::xml_schema::nmtoken (v) + { + } + + type1:: + type1 (const ::std::string& v) + : ::xml_schema::nmtoken (v) + { + } + + type1:: + type1 (const ::xml_schema::nmtoken& v) + : ::xml_schema::nmtoken (v) + { + } + + type1:: + type1 (const type1& v, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (v, f, c) + { + } + + type1& type1:: + operator= (value v) + { + static_cast< ::xml_schema::nmtoken& > (*this) = + ::xml_schema::nmtoken (_xsd_type1_literals_[v]); + + return *this; + } + + + // type2 + // + + type2:: + type2 (value v) + : ::xml_schema::nmtoken (_xsd_type2_literals_[v]) + { + } + + type2:: + type2 (const char* v) + : ::xml_schema::nmtoken (v) + { + } + + type2:: + type2 (const ::std::string& v) + : ::xml_schema::nmtoken (v) + { + } + + type2:: + type2 (const ::xml_schema::nmtoken& v) + : ::xml_schema::nmtoken (v) + { + } + + type2:: + type2 (const type2& v, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (v, f, c) + { + } + + type2& type2:: + operator= (value v) + { + static_cast< ::xml_schema::nmtoken& > (*this) = + ::xml_schema::nmtoken (_xsd_type2_literals_[v]); + + return *this; + } + + + // actuate + // + + actuate:: + actuate (value v) + : ::xml_schema::nmtoken (_xsd_actuate_literals_[v]) + { + } + + actuate:: + actuate (const char* v) + : ::xml_schema::nmtoken (v) + { + } + + actuate:: + actuate (const ::std::string& v) + : ::xml_schema::nmtoken (v) + { + } + + actuate:: + actuate (const ::xml_schema::nmtoken& v) + : ::xml_schema::nmtoken (v) + { + } + + actuate:: + actuate (const actuate& v, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (v, f, c) + { + } + + actuate& actuate:: + operator= (value v) + { + static_cast< ::xml_schema::nmtoken& > (*this) = + ::xml_schema::nmtoken (_xsd_actuate_literals_[v]); + + return *this; + } + + + // type3 + // + + type3:: + type3 (value v) + : ::xml_schema::nmtoken (_xsd_type3_literals_[v]) + { + } + + type3:: + type3 (const char* v) + : ::xml_schema::nmtoken (v) + { + } + + type3:: + type3 (const ::std::string& v) + : ::xml_schema::nmtoken (v) + { + } + + type3:: + type3 (const ::xml_schema::nmtoken& v) + : ::xml_schema::nmtoken (v) + { + } + + type3:: + type3 (const type3& v, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (v, f, c) + { + } + + type3& type3:: + operator= (value v) + { + static_cast< ::xml_schema::nmtoken& > (*this) = + ::xml_schema::nmtoken (_xsd_type3_literals_[v]); + + return *this; + } + + + // VOTABLE + // + + const VOTABLE::DESCRIPTION_optional& VOTABLE:: + DESCRIPTION () const + { + return this->DESCRIPTION_; + } + + VOTABLE::DESCRIPTION_optional& VOTABLE:: + DESCRIPTION () + { + return this->DESCRIPTION_; + } + + void VOTABLE:: + DESCRIPTION (const DESCRIPTION_type& x) + { + this->DESCRIPTION_.set (x); + } + + void VOTABLE:: + DESCRIPTION (const DESCRIPTION_optional& x) + { + this->DESCRIPTION_ = x; + } + + void VOTABLE:: + DESCRIPTION (::std::auto_ptr< DESCRIPTION_type > x) + { + this->DESCRIPTION_.set (x); + } + + const VOTABLE::DEFINITIONS_optional& VOTABLE:: + DEFINITIONS () const + { + return this->DEFINITIONS_; + } + + VOTABLE::DEFINITIONS_optional& VOTABLE:: + DEFINITIONS () + { + return this->DEFINITIONS_; + } + + void VOTABLE:: + DEFINITIONS (const DEFINITIONS_type& x) + { + this->DEFINITIONS_.set (x); + } + + void VOTABLE:: + DEFINITIONS (const DEFINITIONS_optional& x) + { + this->DEFINITIONS_ = x; + } + + void VOTABLE:: + DEFINITIONS (::std::auto_ptr< DEFINITIONS_type > x) + { + this->DEFINITIONS_.set (x); + } + + const VOTABLE::COOSYS_sequence& VOTABLE:: + COOSYS () const + { + return this->COOSYS_; + } + + VOTABLE::COOSYS_sequence& VOTABLE:: + COOSYS () + { + return this->COOSYS_; + } + + void VOTABLE:: + COOSYS (const COOSYS_sequence& s) + { + this->COOSYS_ = s; + } + + const VOTABLE::GROUP_sequence& VOTABLE:: + GROUP () const + { + return this->GROUP_; + } + + VOTABLE::GROUP_sequence& VOTABLE:: + GROUP () + { + return this->GROUP_; + } + + void VOTABLE:: + GROUP (const GROUP_sequence& s) + { + this->GROUP_ = s; + } + + const VOTABLE::PARAM_sequence& VOTABLE:: + PARAM () const + { + return this->PARAM_; + } + + VOTABLE::PARAM_sequence& VOTABLE:: + PARAM () + { + return this->PARAM_; + } + + void VOTABLE:: + PARAM (const PARAM_sequence& s) + { + this->PARAM_ = s; + } + + const VOTABLE::INFO_sequence& VOTABLE:: + INFO () const + { + return this->INFO_; + } + + VOTABLE::INFO_sequence& VOTABLE:: + INFO () + { + return this->INFO_; + } + + void VOTABLE:: + INFO (const INFO_sequence& s) + { + this->INFO_ = s; + } + + const VOTABLE::RESOURCE_sequence& VOTABLE:: + RESOURCE () const + { + return this->RESOURCE_; + } + + VOTABLE::RESOURCE_sequence& VOTABLE:: + RESOURCE () + { + return this->RESOURCE_; + } + + void VOTABLE:: + RESOURCE (const RESOURCE_sequence& s) + { + this->RESOURCE_ = s; + } + + const VOTABLE::ID_optional& VOTABLE:: + ID () const + { + return this->ID_; + } + + VOTABLE::ID_optional& VOTABLE:: + ID () + { + return this->ID_; + } + + void VOTABLE:: + ID (const ID_type& x) + { + this->ID_.set (x); + } + + void VOTABLE:: + ID (const ID_optional& x) + { + this->ID_ = x; + } + + void VOTABLE:: + ID (::std::auto_ptr< ID_type > x) + { + this->ID_.set (x); + } + + const VOTABLE::version_optional& VOTABLE:: + version () const + { + return this->version_; + } + + VOTABLE::version_optional& VOTABLE:: + version () + { + return this->version_; + } + + void VOTABLE:: + version (const version_type& x) + { + this->version_.set (x); + } + + void VOTABLE:: + version (const version_optional& x) + { + this->version_ = x; + } + + void VOTABLE:: + version (::std::auto_ptr< version_type > x) + { + this->version_.set (x); + } + + + // version + // + + version:: + version (value v) + : ::xml_schema::nmtoken (_xsd_version_literals_[v]) + { + } + + version:: + version (const char* v) + : ::xml_schema::nmtoken (v) + { + } + + version:: + version (const ::std::string& v) + : ::xml_schema::nmtoken (v) + { + } + + version:: + version (const ::xml_schema::nmtoken& v) + : ::xml_schema::nmtoken (v) + { + } + + version:: + version (const version& v, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (v, f, c) + { + } + + version& version:: + operator= (value v) + { + static_cast< ::xml_schema::nmtoken& > (*this) = + ::xml_schema::nmtoken (_xsd_version_literals_[v]); + + return *this; + } +} + +#include + +#include + +namespace votable_13 +{ + // anyTEXT + // + + anyTEXT:: + anyTEXT () + : ::xml_schema::type (), + dom_document_ (::xsd::cxx::xml::dom::create_document< char > ()), + any_ (this->dom_document ()) + { + } + + anyTEXT:: + anyTEXT (const anyTEXT& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + dom_document_ (::xsd::cxx::xml::dom::create_document< char > ()), + any_ (x.any_, this->dom_document ()) + { + } + + anyTEXT:: + anyTEXT (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + dom_document_ (::xsd::cxx::xml::dom::create_document< char > ()), + any_ (this->dom_document ()) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, false); + this->parse (p, f); + } + } + + void anyTEXT:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags) + { + for (; p.more_elements (); p.next_element ()) + { + const ::xercesc::DOMElement& i (p.cur_element ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + // any + // + if (true) + { + ::xercesc::DOMElement* r ( + static_cast< ::xercesc::DOMElement* > ( + this->dom_document ().importNode ( + const_cast< ::xercesc::DOMElement* > (&i), true))); + this->any_ .push_back (r); + continue; + } + + break; + } + } + + anyTEXT* anyTEXT:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class anyTEXT (*this, f, c); + } + + anyTEXT:: + ~anyTEXT () + { + } + + // astroYear + // + + astroYear:: + astroYear () + : ::xml_schema::token () + { + } + + astroYear:: + astroYear (const char* _xsd_token_base) + : ::xml_schema::token (_xsd_token_base) + { + } + + astroYear:: + astroYear (const ::std::string& _xsd_token_base) + : ::xml_schema::token (_xsd_token_base) + { + } + + astroYear:: + astroYear (const ::xml_schema::token& _xsd_token_base) + : ::xml_schema::token (_xsd_token_base) + { + } + + astroYear:: + astroYear (const astroYear& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::token (x, f, c) + { + } + + astroYear:: + astroYear (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::token (e, f, c) + { + } + + astroYear:: + astroYear (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::token (a, f, c) + { + } + + astroYear:: + astroYear (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::token (s, e, f, c) + { + } + + astroYear* astroYear:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class astroYear (*this, f, c); + } + + astroYear:: + ~astroYear () + { + } + + // ucdType + // + + ucdType:: + ucdType () + : ::xml_schema::token () + { + } + + ucdType:: + ucdType (const char* _xsd_token_base) + : ::xml_schema::token (_xsd_token_base) + { + } + + ucdType:: + ucdType (const ::std::string& _xsd_token_base) + : ::xml_schema::token (_xsd_token_base) + { + } + + ucdType:: + ucdType (const ::xml_schema::token& _xsd_token_base) + : ::xml_schema::token (_xsd_token_base) + { + } + + ucdType:: + ucdType (const ucdType& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::token (x, f, c) + { + } + + ucdType:: + ucdType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::token (e, f, c) + { + } + + ucdType:: + ucdType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::token (a, f, c) + { + } + + ucdType:: + ucdType (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::token (s, e, f, c) + { + } + + ucdType* ucdType:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class ucdType (*this, f, c); + } + + ucdType:: + ~ucdType () + { + } + + // arrayDEF + // + + arrayDEF:: + arrayDEF () + : ::xml_schema::token () + { + } + + arrayDEF:: + arrayDEF (const char* _xsd_token_base) + : ::xml_schema::token (_xsd_token_base) + { + } + + arrayDEF:: + arrayDEF (const ::std::string& _xsd_token_base) + : ::xml_schema::token (_xsd_token_base) + { + } + + arrayDEF:: + arrayDEF (const ::xml_schema::token& _xsd_token_base) + : ::xml_schema::token (_xsd_token_base) + { + } + + arrayDEF:: + arrayDEF (const arrayDEF& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::token (x, f, c) + { + } + + arrayDEF:: + arrayDEF (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::token (e, f, c) + { + } + + arrayDEF:: + arrayDEF (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::token (a, f, c) + { + } + + arrayDEF:: + arrayDEF (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::token (s, e, f, c) + { + } + + arrayDEF* arrayDEF:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class arrayDEF (*this, f, c); + } + + arrayDEF:: + ~arrayDEF () + { + } + + // encodingType + // + + encodingType:: + encodingType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (e, f, c) + { + _xsd_encodingType_convert (); + } + + encodingType:: + encodingType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (a, f, c) + { + _xsd_encodingType_convert (); + } + + encodingType:: + encodingType (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (s, e, f, c) + { + _xsd_encodingType_convert (); + } + + encodingType* encodingType:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class encodingType (*this, f, c); + } + + encodingType::value encodingType:: + _xsd_encodingType_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_encodingType_literals_); + const value* i (::std::lower_bound ( + _xsd_encodingType_indexes_, + _xsd_encodingType_indexes_ + 4, + *this, + c)); + + if (i == _xsd_encodingType_indexes_ + 4 || _xsd_encodingType_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const encodingType:: + _xsd_encodingType_literals_[4] = + { + "gzip", + "base64", + "dynamic", + "none" + }; + + const encodingType::value encodingType:: + _xsd_encodingType_indexes_[4] = + { + ::votable_13::encodingType::base64, + ::votable_13::encodingType::dynamic, + ::votable_13::encodingType::gzip, + ::votable_13::encodingType::none + }; + + // dataType + // + + dataType:: + dataType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (e, f, c) + { + _xsd_dataType_convert (); + } + + dataType:: + dataType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (a, f, c) + { + _xsd_dataType_convert (); + } + + dataType:: + dataType (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (s, e, f, c) + { + _xsd_dataType_convert (); + } + + dataType* dataType:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class dataType (*this, f, c); + } + + dataType::value dataType:: + _xsd_dataType_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_dataType_literals_); + const value* i (::std::lower_bound ( + _xsd_dataType_indexes_, + _xsd_dataType_indexes_ + 12, + *this, + c)); + + if (i == _xsd_dataType_indexes_ + 12 || _xsd_dataType_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const dataType:: + _xsd_dataType_literals_[12] = + { + "boolean", + "bit", + "unsignedByte", + "short", + "int", + "long", + "char", + "unicodeChar", + "float", + "double", + "floatComplex", + "doubleComplex" + }; + + const dataType::value dataType:: + _xsd_dataType_indexes_[12] = + { + ::votable_13::dataType::bit, + ::votable_13::dataType::boolean, + ::votable_13::dataType::char_, + ::votable_13::dataType::double_, + ::votable_13::dataType::doubleComplex, + ::votable_13::dataType::float_, + ::votable_13::dataType::floatComplex, + ::votable_13::dataType::int_, + ::votable_13::dataType::long_, + ::votable_13::dataType::short_, + ::votable_13::dataType::unicodeChar, + ::votable_13::dataType::unsignedByte + }; + + // precType + // + + precType:: + precType () + : ::xml_schema::token () + { + } + + precType:: + precType (const char* _xsd_token_base) + : ::xml_schema::token (_xsd_token_base) + { + } + + precType:: + precType (const ::std::string& _xsd_token_base) + : ::xml_schema::token (_xsd_token_base) + { + } + + precType:: + precType (const ::xml_schema::token& _xsd_token_base) + : ::xml_schema::token (_xsd_token_base) + { + } + + precType:: + precType (const precType& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::token (x, f, c) + { + } + + precType:: + precType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::token (e, f, c) + { + } + + precType:: + precType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::token (a, f, c) + { + } + + precType:: + precType (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::token (s, e, f, c) + { + } + + precType* precType:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class precType (*this, f, c); + } + + precType:: + ~precType () + { + } + + // yesno + // + + yesno:: + yesno (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (e, f, c) + { + _xsd_yesno_convert (); + } + + yesno:: + yesno (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (a, f, c) + { + _xsd_yesno_convert (); + } + + yesno:: + yesno (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (s, e, f, c) + { + _xsd_yesno_convert (); + } + + yesno* yesno:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class yesno (*this, f, c); + } + + yesno::value yesno:: + _xsd_yesno_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_yesno_literals_); + const value* i (::std::lower_bound ( + _xsd_yesno_indexes_, + _xsd_yesno_indexes_ + 2, + *this, + c)); + + if (i == _xsd_yesno_indexes_ + 2 || _xsd_yesno_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const yesno:: + _xsd_yesno_literals_[2] = + { + "yes", + "no" + }; + + const yesno::value yesno:: + _xsd_yesno_indexes_[2] = + { + ::votable_13::yesno::no, + ::votable_13::yesno::yes + }; + + // MIN + // + + const MIN::inclusive_type MIN::inclusive_default_value_ ( + "yes"); + + MIN:: + MIN (const value_type& value) + : ::xml_schema::type (), + value_ (value, ::xml_schema::flags (), this), + inclusive_ (inclusive_default_value (), ::xml_schema::flags (), this) + { + } + + MIN:: + MIN (const MIN& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + value_ (x.value_, f, this), + inclusive_ (x.inclusive_, f, this) + { + } + + MIN:: + MIN (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + value_ (f, this), + inclusive_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, false, true); + this->parse (p, f); + } + } + + void MIN:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "value" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< value_type > r ( + value_traits::create (i, f, this)); + + this->value_.set (r); + continue; + } + + if (n.name () == "inclusive" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< inclusive_type > r ( + inclusive_traits::create (i, f, this)); + + this->inclusive_.set (r); + continue; + } + } + + if (!value_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "value", + ""); + } + + if (!inclusive_.present ()) + { + this->inclusive_.set (inclusive_default_value ()); + } + } + + MIN* MIN:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class MIN (*this, f, c); + } + + MIN:: + ~MIN () + { + } + + // MAX + // + + const MAX::inclusive_type MAX::inclusive_default_value_ ( + "yes"); + + MAX:: + MAX (const value_type& value) + : ::xml_schema::type (), + value_ (value, ::xml_schema::flags (), this), + inclusive_ (inclusive_default_value (), ::xml_schema::flags (), this) + { + } + + MAX:: + MAX (const MAX& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + value_ (x.value_, f, this), + inclusive_ (x.inclusive_, f, this) + { + } + + MAX:: + MAX (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + value_ (f, this), + inclusive_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, false, true); + this->parse (p, f); + } + } + + void MAX:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "value" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< value_type > r ( + value_traits::create (i, f, this)); + + this->value_.set (r); + continue; + } + + if (n.name () == "inclusive" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< inclusive_type > r ( + inclusive_traits::create (i, f, this)); + + this->inclusive_.set (r); + continue; + } + } + + if (!value_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "value", + ""); + } + + if (!inclusive_.present ()) + { + this->inclusive_.set (inclusive_default_value ()); + } + } + + MAX* MAX:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class MAX (*this, f, c); + } + + MAX:: + ~MAX () + { + } + + // OPTION + // + + OPTION:: + OPTION (const value_type& value) + : ::xml_schema::type (), + OPTION1_ (::xml_schema::flags (), this), + name_ (::xml_schema::flags (), this), + value_ (value, ::xml_schema::flags (), this) + { + } + + OPTION:: + OPTION (const OPTION& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + OPTION1_ (x.OPTION1_, f, this), + name_ (x.name_, f, this), + value_ (x.value_, f, this) + { + } + + OPTION:: + OPTION (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + OPTION1_ (f, this), + name_ (f, this), + value_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, true); + this->parse (p, f); + } + } + + void OPTION:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + for (; p.more_elements (); p.next_element ()) + { + const ::xercesc::DOMElement& i (p.cur_element ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + // OPTION + // + if (n.name () == "OPTION" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< OPTION1_type > r ( + OPTION1_traits::create (i, f, this)); + + this->OPTION1_.push_back (r); + continue; + } + + break; + } + + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "name" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< name_type > r ( + name_traits::create (i, f, this)); + + this->name_.set (r); + continue; + } + + if (n.name () == "value" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< value_type > r ( + value_traits::create (i, f, this)); + + this->value_.set (r); + continue; + } + } + + if (!value_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "value", + ""); + } + } + + OPTION* OPTION:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class OPTION (*this, f, c); + } + + OPTION:: + ~OPTION () + { + } + + // VALUES + // + + const VALUES::type_type VALUES::type_default_value_ ( + "legal"); + + VALUES:: + VALUES () + : ::xml_schema::type (), + MIN_ (::xml_schema::flags (), this), + MAX_ (::xml_schema::flags (), this), + OPTION_ (::xml_schema::flags (), this), + ID_ (::xml_schema::flags (), this), + type_ (type_default_value (), ::xml_schema::flags (), this), + null_ (::xml_schema::flags (), this), + ref_ (::xml_schema::flags (), this) + { + } + + VALUES:: + VALUES (const VALUES& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + MIN_ (x.MIN_, f, this), + MAX_ (x.MAX_, f, this), + OPTION_ (x.OPTION_, f, this), + ID_ (x.ID_, f, this), + type_ (x.type_, f, this), + null_ (x.null_, f, this), + ref_ (x.ref_, f, this) + { + } + + VALUES:: + VALUES (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + MIN_ (f, this), + MAX_ (f, this), + OPTION_ (f, this), + ID_ (f, this), + type_ (f, this), + null_ (f, this), + ref_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, true); + this->parse (p, f); + } + } + + void VALUES:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + for (; p.more_elements (); p.next_element ()) + { + const ::xercesc::DOMElement& i (p.cur_element ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + // MIN + // + if (n.name () == "MIN" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< MIN_type > r ( + MIN_traits::create (i, f, this)); + + if (!this->MIN_) + { + this->MIN_.set (r); + continue; + } + } + + // MAX + // + if (n.name () == "MAX" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< MAX_type > r ( + MAX_traits::create (i, f, this)); + + if (!this->MAX_) + { + this->MAX_.set (r); + continue; + } + } + + // OPTION + // + if (n.name () == "OPTION" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< OPTION_type > r ( + OPTION_traits::create (i, f, this)); + + this->OPTION_.push_back (r); + continue; + } + + break; + } + + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "ID" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ID_type > r ( + ID_traits::create (i, f, this)); + + this->ID_.set (r); + continue; + } + + if (n.name () == "type" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< type_type > r ( + type_traits::create (i, f, this)); + + this->type_.set (r); + continue; + } + + if (n.name () == "null" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< null_type > r ( + null_traits::create (i, f, this)); + + this->null_.set (r); + continue; + } + + if (n.name () == "ref" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ref_type > r ( + ref_traits::create (i, f, this)); + + this->ref_.set (r); + continue; + } + } + + if (!type_.present ()) + { + this->type_.set (type_default_value ()); + } + } + + VALUES* VALUES:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class VALUES (*this, f, c); + } + + VALUES:: + ~VALUES () + { + } + + // LINK + // + + LINK:: + LINK () + : ::xml_schema::type (), + ID_ (::xml_schema::flags (), this), + content_role_ (::xml_schema::flags (), this), + content_type_ (::xml_schema::flags (), this), + title_ (::xml_schema::flags (), this), + value_ (::xml_schema::flags (), this), + href_ (::xml_schema::flags (), this), + gref_ (::xml_schema::flags (), this), + action_ (::xml_schema::flags (), this) + { + } + + LINK:: + LINK (const LINK& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + ID_ (x.ID_, f, this), + content_role_ (x.content_role_, f, this), + content_type_ (x.content_type_, f, this), + title_ (x.title_, f, this), + value_ (x.value_, f, this), + href_ (x.href_, f, this), + gref_ (x.gref_, f, this), + action_ (x.action_, f, this) + { + } + + LINK:: + LINK (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + ID_ (f, this), + content_role_ (f, this), + content_type_ (f, this), + title_ (f, this), + value_ (f, this), + href_ (f, this), + gref_ (f, this), + action_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, false, true); + this->parse (p, f); + } + } + + void LINK:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "ID" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ID_type > r ( + ID_traits::create (i, f, this)); + + this->ID_.set (r); + continue; + } + + if (n.name () == "content-role" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< content_role_type > r ( + content_role_traits::create (i, f, this)); + + this->content_role_.set (r); + continue; + } + + if (n.name () == "content-type" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< content_type_type > r ( + content_type_traits::create (i, f, this)); + + this->content_type_.set (r); + continue; + } + + if (n.name () == "title" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< title_type > r ( + title_traits::create (i, f, this)); + + this->title_.set (r); + continue; + } + + if (n.name () == "value" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< value_type > r ( + value_traits::create (i, f, this)); + + this->value_.set (r); + continue; + } + + if (n.name () == "href" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< href_type > r ( + href_traits::create (i, f, this)); + + this->href_.set (r); + continue; + } + + if (n.name () == "gref" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< gref_type > r ( + gref_traits::create (i, f, this)); + + this->gref_.set (r); + continue; + } + + if (n.name () == "action" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< action_type > r ( + action_traits::create (i, f, this)); + + this->action_.set (r); + continue; + } + } + } + + LINK* LINK:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class LINK (*this, f, c); + } + + LINK:: + ~LINK () + { + } + + // INFO + // + + INFO:: + INFO (const name_type& name, + const value_type& value) + : ::xml_schema::string (), + ID_ (::xml_schema::flags (), this), + name_ (name, ::xml_schema::flags (), this), + value_ (value, ::xml_schema::flags (), this), + unit_ (::xml_schema::flags (), this), + xtype_ (::xml_schema::flags (), this), + ref_ (::xml_schema::flags (), this), + ucd_ (::xml_schema::flags (), this), + utype_ (::xml_schema::flags (), this) + { + } + + INFO:: + INFO (const char* _xsd_string_base, + const name_type& name, + const value_type& value) + : ::xml_schema::string (_xsd_string_base), + ID_ (::xml_schema::flags (), this), + name_ (name, ::xml_schema::flags (), this), + value_ (value, ::xml_schema::flags (), this), + unit_ (::xml_schema::flags (), this), + xtype_ (::xml_schema::flags (), this), + ref_ (::xml_schema::flags (), this), + ucd_ (::xml_schema::flags (), this), + utype_ (::xml_schema::flags (), this) + { + } + + INFO:: + INFO (const ::std::string& _xsd_string_base, + const name_type& name, + const value_type& value) + : ::xml_schema::string (_xsd_string_base), + ID_ (::xml_schema::flags (), this), + name_ (name, ::xml_schema::flags (), this), + value_ (value, ::xml_schema::flags (), this), + unit_ (::xml_schema::flags (), this), + xtype_ (::xml_schema::flags (), this), + ref_ (::xml_schema::flags (), this), + ucd_ (::xml_schema::flags (), this), + utype_ (::xml_schema::flags (), this) + { + } + + INFO:: + INFO (const ::xml_schema::string& _xsd_string_base, + const name_type& name, + const value_type& value) + : ::xml_schema::string (_xsd_string_base), + ID_ (::xml_schema::flags (), this), + name_ (name, ::xml_schema::flags (), this), + value_ (value, ::xml_schema::flags (), this), + unit_ (::xml_schema::flags (), this), + xtype_ (::xml_schema::flags (), this), + ref_ (::xml_schema::flags (), this), + ucd_ (::xml_schema::flags (), this), + utype_ (::xml_schema::flags (), this) + { + } + + INFO:: + INFO (const INFO& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::string (x, f, c), + ID_ (x.ID_, f, this), + name_ (x.name_, f, this), + value_ (x.value_, f, this), + unit_ (x.unit_, f, this), + xtype_ (x.xtype_, f, this), + ref_ (x.ref_, f, this), + ucd_ (x.ucd_, f, this), + utype_ (x.utype_, f, this) + { + } + + INFO:: + INFO (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::string (e, f | ::xml_schema::flags::base, c), + ID_ (f, this), + name_ (f, this), + value_ (f, this), + unit_ (f, this), + xtype_ (f, this), + ref_ (f, this), + ucd_ (f, this), + utype_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, false, true); + this->parse (p, f); + } + } + + void INFO:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "ID" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ID_type > r ( + ID_traits::create (i, f, this)); + + this->ID_.set (r); + continue; + } + + if (n.name () == "name" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< name_type > r ( + name_traits::create (i, f, this)); + + this->name_.set (r); + continue; + } + + if (n.name () == "value" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< value_type > r ( + value_traits::create (i, f, this)); + + this->value_.set (r); + continue; + } + + if (n.name () == "unit" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< unit_type > r ( + unit_traits::create (i, f, this)); + + this->unit_.set (r); + continue; + } + + if (n.name () == "xtype" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< xtype_type > r ( + xtype_traits::create (i, f, this)); + + this->xtype_.set (r); + continue; + } + + if (n.name () == "ref" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ref_type > r ( + ref_traits::create (i, f, this)); + + this->ref_.set (r); + continue; + } + + if (n.name () == "ucd" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ucd_type > r ( + ucd_traits::create (i, f, this)); + + this->ucd_.set (r); + continue; + } + + if (n.name () == "utype" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< utype_type > r ( + utype_traits::create (i, f, this)); + + this->utype_.set (r); + continue; + } + } + + if (!name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "name", + ""); + } + + if (!value_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "value", + ""); + } + } + + INFO* INFO:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class INFO (*this, f, c); + } + + INFO:: + ~INFO () + { + } + + // COOSYS + // + + const COOSYS::system_type COOSYS::system_default_value_ ( + "eq_FK5"); + + COOSYS:: + COOSYS (const ID_type& ID) + : ::xml_schema::string (), + ID_ (ID, ::xml_schema::flags (), this), + equinox_ (::xml_schema::flags (), this), + epoch_ (::xml_schema::flags (), this), + system_ (system_default_value (), ::xml_schema::flags (), this) + { + } + + COOSYS:: + COOSYS (const char* _xsd_string_base, + const ID_type& ID) + : ::xml_schema::string (_xsd_string_base), + ID_ (ID, ::xml_schema::flags (), this), + equinox_ (::xml_schema::flags (), this), + epoch_ (::xml_schema::flags (), this), + system_ (system_default_value (), ::xml_schema::flags (), this) + { + } + + COOSYS:: + COOSYS (const ::std::string& _xsd_string_base, + const ID_type& ID) + : ::xml_schema::string (_xsd_string_base), + ID_ (ID, ::xml_schema::flags (), this), + equinox_ (::xml_schema::flags (), this), + epoch_ (::xml_schema::flags (), this), + system_ (system_default_value (), ::xml_schema::flags (), this) + { + } + + COOSYS:: + COOSYS (const ::xml_schema::string& _xsd_string_base, + const ID_type& ID) + : ::xml_schema::string (_xsd_string_base), + ID_ (ID, ::xml_schema::flags (), this), + equinox_ (::xml_schema::flags (), this), + epoch_ (::xml_schema::flags (), this), + system_ (system_default_value (), ::xml_schema::flags (), this) + { + } + + COOSYS:: + COOSYS (const COOSYS& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::string (x, f, c), + ID_ (x.ID_, f, this), + equinox_ (x.equinox_, f, this), + epoch_ (x.epoch_, f, this), + system_ (x.system_, f, this) + { + } + + COOSYS:: + COOSYS (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::string (e, f | ::xml_schema::flags::base, c), + ID_ (f, this), + equinox_ (f, this), + epoch_ (f, this), + system_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, false, true); + this->parse (p, f); + } + } + + void COOSYS:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "ID" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ID_type > r ( + ID_traits::create (i, f, this)); + + this->ID_.set (r); + continue; + } + + if (n.name () == "equinox" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< equinox_type > r ( + equinox_traits::create (i, f, this)); + + this->equinox_.set (r); + continue; + } + + if (n.name () == "epoch" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< epoch_type > r ( + epoch_traits::create (i, f, this)); + + this->epoch_.set (r); + continue; + } + + if (n.name () == "system" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< system_type > r ( + system_traits::create (i, f, this)); + + this->system_.set (r); + continue; + } + } + + if (!ID_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "ID", + ""); + } + + if (!system_.present ()) + { + this->system_.set (system_default_value ()); + } + } + + COOSYS* COOSYS:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class COOSYS (*this, f, c); + } + + COOSYS:: + ~COOSYS () + { + } + + // DEFINITIONS + // + + DEFINITIONS:: + DEFINITIONS () + : ::xml_schema::type (), + COOSYS_ (::xml_schema::flags (), this), + PARAM_ (::xml_schema::flags (), this) + { + } + + DEFINITIONS:: + DEFINITIONS (const DEFINITIONS& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + COOSYS_ (x.COOSYS_, f, this), + PARAM_ (x.PARAM_, f, this) + { + } + + DEFINITIONS:: + DEFINITIONS (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + COOSYS_ (f, this), + PARAM_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, false); + this->parse (p, f); + } + } + + void DEFINITIONS:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + for (; p.more_elements (); p.next_element ()) + { + const ::xercesc::DOMElement& i (p.cur_element ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + // COOSYS + // + if (n.name () == "COOSYS" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< COOSYS_type > r ( + COOSYS_traits::create (i, f, this)); + + this->COOSYS_.push_back (r); + continue; + } + + // PARAM + // + if (n.name () == "PARAM" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< PARAM_type > r ( + PARAM_traits::create (i, f, this)); + + this->PARAM_.push_back (r); + continue; + } + + break; + } + } + + DEFINITIONS* DEFINITIONS:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class DEFINITIONS (*this, f, c); + } + + DEFINITIONS:: + ~DEFINITIONS () + { + } + + // FIELD + // + + FIELD:: + FIELD () + : ::xml_schema::type (), + DESCRIPTION_ (::xml_schema::flags (), this), + VALUES_ (::xml_schema::flags (), this), + LINK_ (::xml_schema::flags (), this), + ID_ (::xml_schema::flags (), this), + unit_ (::xml_schema::flags (), this), + datatype_ (::xml_schema::flags (), this), + precision_ (::xml_schema::flags (), this), + width_ (::xml_schema::flags (), this), + xtype_ (::xml_schema::flags (), this), + ref_ (::xml_schema::flags (), this), + name_ (::xml_schema::flags (), this), + ucd_ (::xml_schema::flags (), this), + utype_ (::xml_schema::flags (), this), + arraysize_ (::xml_schema::flags (), this), + type_ (::xml_schema::flags (), this) + { + } + + FIELD:: + FIELD (const FIELD& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + DESCRIPTION_ (x.DESCRIPTION_, f, this), + VALUES_ (x.VALUES_, f, this), + LINK_ (x.LINK_, f, this), + ID_ (x.ID_, f, this), + unit_ (x.unit_, f, this), + datatype_ (x.datatype_, f, this), + precision_ (x.precision_, f, this), + width_ (x.width_, f, this), + xtype_ (x.xtype_, f, this), + ref_ (x.ref_, f, this), + name_ (x.name_, f, this), + ucd_ (x.ucd_, f, this), + utype_ (x.utype_, f, this), + arraysize_ (x.arraysize_, f, this), + type_ (x.type_, f, this) + { + } + + FIELD:: + FIELD (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + DESCRIPTION_ (f, this), + VALUES_ (f, this), + LINK_ (f, this), + ID_ (f, this), + unit_ (f, this), + datatype_ (f, this), + precision_ (f, this), + width_ (f, this), + xtype_ (f, this), + ref_ (f, this), + name_ (f, this), + ucd_ (f, this), + utype_ (f, this), + arraysize_ (f, this), + type_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, true); + this->parse (p, f); + } + } + + void FIELD:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + for (; p.more_elements (); p.next_element ()) + { + const ::xercesc::DOMElement& i (p.cur_element ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + // DESCRIPTION + // + if (n.name () == "DESCRIPTION" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< DESCRIPTION_type > r ( + DESCRIPTION_traits::create (i, f, this)); + + if (!this->DESCRIPTION_) + { + this->DESCRIPTION_.set (r); + continue; + } + } + + // VALUES + // + if (n.name () == "VALUES" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< VALUES_type > r ( + VALUES_traits::create (i, f, this)); + + if (!this->VALUES_) + { + this->VALUES_.set (r); + continue; + } + } + + // LINK + // + if (n.name () == "LINK" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< LINK_type > r ( + LINK_traits::create (i, f, this)); + + this->LINK_.push_back (r); + continue; + } + + break; + } + + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "ID" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ID_type > r ( + ID_traits::create (i, f, this)); + + this->ID_.set (r); + continue; + } + + if (n.name () == "unit" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< unit_type > r ( + unit_traits::create (i, f, this)); + + this->unit_.set (r); + continue; + } + + if (n.name () == "datatype" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< datatype_type > r ( + datatype_traits::create (i, f, this)); + + this->datatype_.set (r); + continue; + } + + if (n.name () == "precision" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< precision_type > r ( + precision_traits::create (i, f, this)); + + this->precision_.set (r); + continue; + } + + if (n.name () == "width" && n.namespace_ ().empty ()) + { + this->width_.set (width_traits::create (i, f, this)); + continue; + } + + if (n.name () == "xtype" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< xtype_type > r ( + xtype_traits::create (i, f, this)); + + this->xtype_.set (r); + continue; + } + + if (n.name () == "ref" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ref_type > r ( + ref_traits::create (i, f, this)); + + this->ref_.set (r); + continue; + } + + if (n.name () == "name" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< name_type > r ( + name_traits::create (i, f, this)); + + this->name_.set (r); + continue; + } + + if (n.name () == "ucd" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ucd_type > r ( + ucd_traits::create (i, f, this)); + + this->ucd_.set (r); + continue; + } + + if (n.name () == "utype" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< utype_type > r ( + utype_traits::create (i, f, this)); + + this->utype_.set (r); + continue; + } + + if (n.name () == "arraysize" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< arraysize_type > r ( + arraysize_traits::create (i, f, this)); + + this->arraysize_.set (r); + continue; + } + + if (n.name () == "type" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< type_type > r ( + type_traits::create (i, f, this)); + + this->type_.set (r); + continue; + } + } + } + + FIELD* FIELD:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class FIELD (*this, f, c); + } + + FIELD:: + ~FIELD () + { + } + + // PARAM + // + + PARAM:: + PARAM () + : ::votable_13::FIELD (), + value_ (::xml_schema::flags (), this) + { + } + + PARAM:: + PARAM (const PARAM& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::votable_13::FIELD (x, f, c), + value_ (x.value_, f, this) + { + } + + PARAM:: + PARAM (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::votable_13::FIELD (e, f | ::xml_schema::flags::base, c), + value_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, true); + this->parse (p, f); + } + } + + void PARAM:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + this->::votable_13::FIELD::parse (p, f); + + p.reset_attributes (); + + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "value" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< value_type > r ( + value_traits::create (i, f, this)); + + this->value_.set (r); + continue; + } + } + } + + PARAM* PARAM:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class PARAM (*this, f, c); + } + + PARAM:: + ~PARAM () + { + } + + // GROUP + // + + GROUP:: + GROUP () + : ::xml_schema::type (), + DESCRIPTION_ (::xml_schema::flags (), this), + FIELDref_ (::xml_schema::flags (), this), + PARAMref_ (::xml_schema::flags (), this), + PARAM_ (::xml_schema::flags (), this), + GROUP1_ (::xml_schema::flags (), this), + ID_ (::xml_schema::flags (), this), + name_ (::xml_schema::flags (), this), + ref_ (::xml_schema::flags (), this), + ucd_ (::xml_schema::flags (), this), + utype_ (::xml_schema::flags (), this) + { + } + + GROUP:: + GROUP (const GROUP& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + DESCRIPTION_ (x.DESCRIPTION_, f, this), + FIELDref_ (x.FIELDref_, f, this), + PARAMref_ (x.PARAMref_, f, this), + PARAM_ (x.PARAM_, f, this), + GROUP1_ (x.GROUP1_, f, this), + ID_ (x.ID_, f, this), + name_ (x.name_, f, this), + ref_ (x.ref_, f, this), + ucd_ (x.ucd_, f, this), + utype_ (x.utype_, f, this) + { + } + + GROUP:: + GROUP (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + DESCRIPTION_ (f, this), + FIELDref_ (f, this), + PARAMref_ (f, this), + PARAM_ (f, this), + GROUP1_ (f, this), + ID_ (f, this), + name_ (f, this), + ref_ (f, this), + ucd_ (f, this), + utype_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, true); + this->parse (p, f); + } + } + + void GROUP:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + for (; p.more_elements (); p.next_element ()) + { + const ::xercesc::DOMElement& i (p.cur_element ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + // DESCRIPTION + // + if (n.name () == "DESCRIPTION" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< DESCRIPTION_type > r ( + DESCRIPTION_traits::create (i, f, this)); + + if (!this->DESCRIPTION_) + { + this->DESCRIPTION_.set (r); + continue; + } + } + + // FIELDref + // + if (n.name () == "FIELDref" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< FIELDref_type > r ( + FIELDref_traits::create (i, f, this)); + + this->FIELDref_.push_back (r); + continue; + } + + // PARAMref + // + if (n.name () == "PARAMref" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< PARAMref_type > r ( + PARAMref_traits::create (i, f, this)); + + this->PARAMref_.push_back (r); + continue; + } + + // PARAM + // + if (n.name () == "PARAM" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< PARAM_type > r ( + PARAM_traits::create (i, f, this)); + + this->PARAM_.push_back (r); + continue; + } + + // GROUP + // + if (n.name () == "GROUP" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< GROUP1_type > r ( + GROUP1_traits::create (i, f, this)); + + this->GROUP1_.push_back (r); + continue; + } + + break; + } + + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "ID" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ID_type > r ( + ID_traits::create (i, f, this)); + + this->ID_.set (r); + continue; + } + + if (n.name () == "name" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< name_type > r ( + name_traits::create (i, f, this)); + + this->name_.set (r); + continue; + } + + if (n.name () == "ref" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ref_type > r ( + ref_traits::create (i, f, this)); + + this->ref_.set (r); + continue; + } + + if (n.name () == "ucd" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ucd_type > r ( + ucd_traits::create (i, f, this)); + + this->ucd_.set (r); + continue; + } + + if (n.name () == "utype" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< utype_type > r ( + utype_traits::create (i, f, this)); + + this->utype_.set (r); + continue; + } + } + } + + GROUP* GROUP:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class GROUP (*this, f, c); + } + + GROUP:: + ~GROUP () + { + } + + // FIELDref + // + + FIELDref:: + FIELDref (const ref_type& ref) + : ::xml_schema::type (), + ref_ (ref, ::xml_schema::flags (), this), + ucd_ (::xml_schema::flags (), this), + utype_ (::xml_schema::flags (), this) + { + } + + FIELDref:: + FIELDref (const FIELDref& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + ref_ (x.ref_, f, this), + ucd_ (x.ucd_, f, this), + utype_ (x.utype_, f, this) + { + } + + FIELDref:: + FIELDref (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + ref_ (f, this), + ucd_ (f, this), + utype_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, false, true); + this->parse (p, f); + } + } + + void FIELDref:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "ref" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ref_type > r ( + ref_traits::create (i, f, this)); + + this->ref_.set (r); + continue; + } + + if (n.name () == "ucd" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ucd_type > r ( + ucd_traits::create (i, f, this)); + + this->ucd_.set (r); + continue; + } + + if (n.name () == "utype" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< utype_type > r ( + utype_traits::create (i, f, this)); + + this->utype_.set (r); + continue; + } + } + + if (!ref_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "ref", + ""); + } + } + + FIELDref* FIELDref:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class FIELDref (*this, f, c); + } + + FIELDref:: + ~FIELDref () + { + } + + // PARAMref + // + + PARAMref:: + PARAMref (const ref_type& ref) + : ::xml_schema::type (), + ref_ (ref, ::xml_schema::flags (), this), + ucd_ (::xml_schema::flags (), this), + utype_ (::xml_schema::flags (), this) + { + } + + PARAMref:: + PARAMref (const PARAMref& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + ref_ (x.ref_, f, this), + ucd_ (x.ucd_, f, this), + utype_ (x.utype_, f, this) + { + } + + PARAMref:: + PARAMref (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + ref_ (f, this), + ucd_ (f, this), + utype_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, false, true); + this->parse (p, f); + } + } + + void PARAMref:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "ref" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ref_type > r ( + ref_traits::create (i, f, this)); + + this->ref_.set (r); + continue; + } + + if (n.name () == "ucd" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ucd_type > r ( + ucd_traits::create (i, f, this)); + + this->ucd_.set (r); + continue; + } + + if (n.name () == "utype" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< utype_type > r ( + utype_traits::create (i, f, this)); + + this->utype_.set (r); + continue; + } + } + + if (!ref_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "ref", + ""); + } + } + + PARAMref* PARAMref:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class PARAMref (*this, f, c); + } + + PARAMref:: + ~PARAMref () + { + } + + // DATA + // + + DATA:: + DATA () + : ::xml_schema::type (), + TABLEDATA_ (::xml_schema::flags (), this), + BINARY_ (::xml_schema::flags (), this), + BINARY2_ (::xml_schema::flags (), this), + FITS_ (::xml_schema::flags (), this), + INFO_ (::xml_schema::flags (), this) + { + } + + DATA:: + DATA (const DATA& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + TABLEDATA_ (x.TABLEDATA_, f, this), + BINARY_ (x.BINARY_, f, this), + BINARY2_ (x.BINARY2_, f, this), + FITS_ (x.FITS_, f, this), + INFO_ (x.INFO_, f, this) + { + } + + DATA:: + DATA (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + TABLEDATA_ (f, this), + BINARY_ (f, this), + BINARY2_ (f, this), + FITS_ (f, this), + INFO_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, false); + this->parse (p, f); + } + } + + void DATA:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + for (; p.more_elements (); p.next_element ()) + { + const ::xercesc::DOMElement& i (p.cur_element ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + // TABLEDATA + // + if (n.name () == "TABLEDATA" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< TABLEDATA_type > r ( + TABLEDATA_traits::create (i, f, this)); + + if (!this->TABLEDATA_) + { + this->TABLEDATA_.set (r); + continue; + } + } + + // BINARY + // + if (n.name () == "BINARY" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< BINARY_type > r ( + BINARY_traits::create (i, f, this)); + + if (!this->BINARY_) + { + this->BINARY_.set (r); + continue; + } + } + + // BINARY2 + // + if (n.name () == "BINARY2" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< BINARY2_type > r ( + BINARY2_traits::create (i, f, this)); + + if (!this->BINARY2_) + { + this->BINARY2_.set (r); + continue; + } + } + + // FITS + // + if (n.name () == "FITS" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< FITS_type > r ( + FITS_traits::create (i, f, this)); + + if (!this->FITS_) + { + this->FITS_.set (r); + continue; + } + } + + // INFO + // + if (n.name () == "INFO" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< INFO_type > r ( + INFO_traits::create (i, f, this)); + + this->INFO_.push_back (r); + continue; + } + + break; + } + } + + DATA* DATA:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class DATA (*this, f, c); + } + + DATA:: + ~DATA () + { + } + + // TABLEDATA + // + + TABLEDATA:: + TABLEDATA () + : ::xml_schema::type (), + TR_ (::xml_schema::flags (), this) + { + } + + TABLEDATA:: + TABLEDATA (const TABLEDATA& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + TR_ (x.TR_, f, this) + { + } + + TABLEDATA:: + TABLEDATA (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + TR_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, false); + this->parse (p, f); + } + } + + void TABLEDATA:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + for (; p.more_elements (); p.next_element ()) + { + const ::xercesc::DOMElement& i (p.cur_element ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + // TR + // + if (n.name () == "TR" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< TR_type > r ( + TR_traits::create (i, f, this)); + + this->TR_.push_back (r); + continue; + } + + break; + } + } + + TABLEDATA* TABLEDATA:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class TABLEDATA (*this, f, c); + } + + TABLEDATA:: + ~TABLEDATA () + { + } + + // TD + // + + TD:: + TD () + : ::xml_schema::string (), + encoding_ (::xml_schema::flags (), this) + { + } + + TD:: + TD (const char* _xsd_string_base) + : ::xml_schema::string (_xsd_string_base), + encoding_ (::xml_schema::flags (), this) + { + } + + TD:: + TD (const ::std::string& _xsd_string_base) + : ::xml_schema::string (_xsd_string_base), + encoding_ (::xml_schema::flags (), this) + { + } + + TD:: + TD (const ::xml_schema::string& _xsd_string_base) + : ::xml_schema::string (_xsd_string_base), + encoding_ (::xml_schema::flags (), this) + { + } + + TD:: + TD (const TD& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::string (x, f, c), + encoding_ (x.encoding_, f, this) + { + } + + TD:: + TD (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::string (e, f | ::xml_schema::flags::base, c), + encoding_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, false, true); + this->parse (p, f); + } + } + + void TD:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "encoding" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< encoding_type > r ( + encoding_traits::create (i, f, this)); + + this->encoding_.set (r); + continue; + } + } + } + + TD* TD:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class TD (*this, f, c); + } + + TD:: + ~TD () + { + } + + // TR + // + + TR:: + TR () + : ::xml_schema::type (), + TD_ (::xml_schema::flags (), this), + ID_ (::xml_schema::flags (), this) + { + } + + TR:: + TR (const TR& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + TD_ (x.TD_, f, this), + ID_ (x.ID_, f, this) + { + } + + TR:: + TR (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + TD_ (f, this), + ID_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, true); + this->parse (p, f); + } + } + + void TR:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + for (; p.more_elements (); p.next_element ()) + { + const ::xercesc::DOMElement& i (p.cur_element ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + // TD + // + if (n.name () == "TD" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< TD_type > r ( + TD_traits::create (i, f, this)); + + this->TD_.push_back (r); + continue; + } + + break; + } + + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "ID" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ID_type > r ( + ID_traits::create (i, f, this)); + + this->ID_.set (r); + continue; + } + } + } + + TR* TR:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class TR (*this, f, c); + } + + TR:: + ~TR () + { + } + + // FITS + // + + FITS:: + FITS (const STREAM_type& STREAM) + : ::xml_schema::type (), + STREAM_ (STREAM, ::xml_schema::flags (), this), + extnum_ (::xml_schema::flags (), this) + { + } + + FITS:: + FITS (::std::auto_ptr< STREAM_type >& STREAM) + : ::xml_schema::type (), + STREAM_ (STREAM, ::xml_schema::flags (), this), + extnum_ (::xml_schema::flags (), this) + { + } + + FITS:: + FITS (const FITS& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + STREAM_ (x.STREAM_, f, this), + extnum_ (x.extnum_, f, this) + { + } + + FITS:: + FITS (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + STREAM_ (f, this), + extnum_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, true); + this->parse (p, f); + } + } + + void FITS:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + for (; p.more_elements (); p.next_element ()) + { + const ::xercesc::DOMElement& i (p.cur_element ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + // STREAM + // + if (n.name () == "STREAM" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< STREAM_type > r ( + STREAM_traits::create (i, f, this)); + + if (!STREAM_.present ()) + { + this->STREAM_.set (r); + continue; + } + } + + break; + } + + if (!STREAM_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "STREAM", + "http://www.ivoa.net/xml/VOTable/v1.3"); + } + + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "extnum" && n.namespace_ ().empty ()) + { + this->extnum_.set (extnum_traits::create (i, f, this)); + continue; + } + } + } + + FITS* FITS:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class FITS (*this, f, c); + } + + FITS:: + ~FITS () + { + } + + // BINARY + // + + BINARY:: + BINARY (const STREAM_type& STREAM) + : ::xml_schema::type (), + STREAM_ (STREAM, ::xml_schema::flags (), this) + { + } + + BINARY:: + BINARY (::std::auto_ptr< STREAM_type >& STREAM) + : ::xml_schema::type (), + STREAM_ (STREAM, ::xml_schema::flags (), this) + { + } + + BINARY:: + BINARY (const BINARY& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + STREAM_ (x.STREAM_, f, this) + { + } + + BINARY:: + BINARY (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + STREAM_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, false); + this->parse (p, f); + } + } + + void BINARY:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + for (; p.more_elements (); p.next_element ()) + { + const ::xercesc::DOMElement& i (p.cur_element ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + // STREAM + // + if (n.name () == "STREAM" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< STREAM_type > r ( + STREAM_traits::create (i, f, this)); + + if (!STREAM_.present ()) + { + this->STREAM_.set (r); + continue; + } + } + + break; + } + + if (!STREAM_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "STREAM", + "http://www.ivoa.net/xml/VOTable/v1.3"); + } + } + + BINARY* BINARY:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class BINARY (*this, f, c); + } + + BINARY:: + ~BINARY () + { + } + + // BINARY2 + // + + BINARY2:: + BINARY2 (const STREAM_type& STREAM) + : ::xml_schema::type (), + STREAM_ (STREAM, ::xml_schema::flags (), this) + { + } + + BINARY2:: + BINARY2 (::std::auto_ptr< STREAM_type >& STREAM) + : ::xml_schema::type (), + STREAM_ (STREAM, ::xml_schema::flags (), this) + { + } + + BINARY2:: + BINARY2 (const BINARY2& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + STREAM_ (x.STREAM_, f, this) + { + } + + BINARY2:: + BINARY2 (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + STREAM_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, false); + this->parse (p, f); + } + } + + void BINARY2:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + for (; p.more_elements (); p.next_element ()) + { + const ::xercesc::DOMElement& i (p.cur_element ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + // STREAM + // + if (n.name () == "STREAM" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< STREAM_type > r ( + STREAM_traits::create (i, f, this)); + + if (!STREAM_.present ()) + { + this->STREAM_.set (r); + continue; + } + } + + break; + } + + if (!STREAM_.present ()) + { + throw ::xsd::cxx::tree::expected_element< char > ( + "STREAM", + "http://www.ivoa.net/xml/VOTable/v1.3"); + } + } + + BINARY2* BINARY2:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class BINARY2 (*this, f, c); + } + + BINARY2:: + ~BINARY2 () + { + } + + // STREAM + // + + const STREAM::type_type STREAM::type_default_value_ ( + "locator"); + + const STREAM::actuate_type STREAM::actuate_default_value_ ( + "onRequest"); + + const STREAM::encoding_type STREAM::encoding_default_value_ ( + "none"); + + STREAM:: + STREAM () + : ::xml_schema::string (), + type_ (type_default_value (), ::xml_schema::flags (), this), + href_ (::xml_schema::flags (), this), + actuate_ (actuate_default_value (), ::xml_schema::flags (), this), + encoding_ (encoding_default_value (), ::xml_schema::flags (), this), + expires_ (::xml_schema::flags (), this), + rights_ (::xml_schema::flags (), this) + { + } + + STREAM:: + STREAM (const char* _xsd_string_base) + : ::xml_schema::string (_xsd_string_base), + type_ (type_default_value (), ::xml_schema::flags (), this), + href_ (::xml_schema::flags (), this), + actuate_ (actuate_default_value (), ::xml_schema::flags (), this), + encoding_ (encoding_default_value (), ::xml_schema::flags (), this), + expires_ (::xml_schema::flags (), this), + rights_ (::xml_schema::flags (), this) + { + } + + STREAM:: + STREAM (const ::std::string& _xsd_string_base) + : ::xml_schema::string (_xsd_string_base), + type_ (type_default_value (), ::xml_schema::flags (), this), + href_ (::xml_schema::flags (), this), + actuate_ (actuate_default_value (), ::xml_schema::flags (), this), + encoding_ (encoding_default_value (), ::xml_schema::flags (), this), + expires_ (::xml_schema::flags (), this), + rights_ (::xml_schema::flags (), this) + { + } + + STREAM:: + STREAM (const ::xml_schema::string& _xsd_string_base) + : ::xml_schema::string (_xsd_string_base), + type_ (type_default_value (), ::xml_schema::flags (), this), + href_ (::xml_schema::flags (), this), + actuate_ (actuate_default_value (), ::xml_schema::flags (), this), + encoding_ (encoding_default_value (), ::xml_schema::flags (), this), + expires_ (::xml_schema::flags (), this), + rights_ (::xml_schema::flags (), this) + { + } + + STREAM:: + STREAM (const STREAM& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::string (x, f, c), + type_ (x.type_, f, this), + href_ (x.href_, f, this), + actuate_ (x.actuate_, f, this), + encoding_ (x.encoding_, f, this), + expires_ (x.expires_, f, this), + rights_ (x.rights_, f, this) + { + } + + STREAM:: + STREAM (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::string (e, f | ::xml_schema::flags::base, c), + type_ (f, this), + href_ (f, this), + actuate_ (f, this), + encoding_ (f, this), + expires_ (f, this), + rights_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, false, true); + this->parse (p, f); + } + } + + void STREAM:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "type" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< type_type > r ( + type_traits::create (i, f, this)); + + this->type_.set (r); + continue; + } + + if (n.name () == "href" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< href_type > r ( + href_traits::create (i, f, this)); + + this->href_.set (r); + continue; + } + + if (n.name () == "actuate" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< actuate_type > r ( + actuate_traits::create (i, f, this)); + + this->actuate_.set (r); + continue; + } + + if (n.name () == "encoding" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< encoding_type > r ( + encoding_traits::create (i, f, this)); + + this->encoding_.set (r); + continue; + } + + if (n.name () == "expires" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< expires_type > r ( + expires_traits::create (i, f, this)); + + this->expires_.set (r); + continue; + } + + if (n.name () == "rights" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< rights_type > r ( + rights_traits::create (i, f, this)); + + this->rights_.set (r); + continue; + } + } + + if (!type_.present ()) + { + this->type_.set (type_default_value ()); + } + + if (!actuate_.present ()) + { + this->actuate_.set (actuate_default_value ()); + } + + if (!encoding_.present ()) + { + this->encoding_.set (encoding_default_value ()); + } + } + + STREAM* STREAM:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class STREAM (*this, f, c); + } + + STREAM:: + ~STREAM () + { + } + + // TABLE + // + + TABLE:: + TABLE () + : ::xml_schema::type (), + DESCRIPTION_ (::xml_schema::flags (), this), + INFO_ (::xml_schema::flags (), this), + FIELD_ (::xml_schema::flags (), this), + PARAM_ (::xml_schema::flags (), this), + GROUP_ (::xml_schema::flags (), this), + LINK_ (::xml_schema::flags (), this), + DATA_ (::xml_schema::flags (), this), + ID_ (::xml_schema::flags (), this), + name_ (::xml_schema::flags (), this), + ref_ (::xml_schema::flags (), this), + ucd_ (::xml_schema::flags (), this), + utype_ (::xml_schema::flags (), this), + nrows_ (::xml_schema::flags (), this) + { + } + + TABLE:: + TABLE (const TABLE& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + DESCRIPTION_ (x.DESCRIPTION_, f, this), + INFO_ (x.INFO_, f, this), + FIELD_ (x.FIELD_, f, this), + PARAM_ (x.PARAM_, f, this), + GROUP_ (x.GROUP_, f, this), + LINK_ (x.LINK_, f, this), + DATA_ (x.DATA_, f, this), + ID_ (x.ID_, f, this), + name_ (x.name_, f, this), + ref_ (x.ref_, f, this), + ucd_ (x.ucd_, f, this), + utype_ (x.utype_, f, this), + nrows_ (x.nrows_, f, this) + { + } + + TABLE:: + TABLE (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + DESCRIPTION_ (f, this), + INFO_ (f, this), + FIELD_ (f, this), + PARAM_ (f, this), + GROUP_ (f, this), + LINK_ (f, this), + DATA_ (f, this), + ID_ (f, this), + name_ (f, this), + ref_ (f, this), + ucd_ (f, this), + utype_ (f, this), + nrows_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, true); + this->parse (p, f); + } + } + + void TABLE:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + for (; p.more_elements (); p.next_element ()) + { + const ::xercesc::DOMElement& i (p.cur_element ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + // DESCRIPTION + // + if (n.name () == "DESCRIPTION" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< DESCRIPTION_type > r ( + DESCRIPTION_traits::create (i, f, this)); + + if (!this->DESCRIPTION_) + { + this->DESCRIPTION_.set (r); + continue; + } + } + + // INFO + // + if (n.name () == "INFO" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< INFO_type > r ( + INFO_traits::create (i, f, this)); + + this->INFO_.push_back (r); + continue; + } + + // FIELD + // + if (n.name () == "FIELD" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< FIELD_type > r ( + FIELD_traits::create (i, f, this)); + + this->FIELD_.push_back (r); + continue; + } + + // PARAM + // + if (n.name () == "PARAM" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< PARAM_type > r ( + PARAM_traits::create (i, f, this)); + + this->PARAM_.push_back (r); + continue; + } + + // GROUP + // + if (n.name () == "GROUP" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< GROUP_type > r ( + GROUP_traits::create (i, f, this)); + + this->GROUP_.push_back (r); + continue; + } + + // LINK + // + if (n.name () == "LINK" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< LINK_type > r ( + LINK_traits::create (i, f, this)); + + this->LINK_.push_back (r); + continue; + } + + // DATA + // + if (n.name () == "DATA" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< DATA_type > r ( + DATA_traits::create (i, f, this)); + + if (!this->DATA_) + { + this->DATA_.set (r); + continue; + } + } + + break; + } + + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "ID" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ID_type > r ( + ID_traits::create (i, f, this)); + + this->ID_.set (r); + continue; + } + + if (n.name () == "name" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< name_type > r ( + name_traits::create (i, f, this)); + + this->name_.set (r); + continue; + } + + if (n.name () == "ref" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ref_type > r ( + ref_traits::create (i, f, this)); + + this->ref_.set (r); + continue; + } + + if (n.name () == "ucd" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ucd_type > r ( + ucd_traits::create (i, f, this)); + + this->ucd_.set (r); + continue; + } + + if (n.name () == "utype" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< utype_type > r ( + utype_traits::create (i, f, this)); + + this->utype_.set (r); + continue; + } + + if (n.name () == "nrows" && n.namespace_ ().empty ()) + { + this->nrows_.set (nrows_traits::create (i, f, this)); + continue; + } + } + } + + TABLE* TABLE:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class TABLE (*this, f, c); + } + + TABLE:: + ~TABLE () + { + } + + // RESOURCE + // + + const RESOURCE::type_type RESOURCE::type_default_value_ ( + "results"); + + RESOURCE:: + RESOURCE () + : ::xml_schema::type (), + dom_document_ (::xsd::cxx::xml::dom::create_document< char > ()), + DESCRIPTION_ (::xml_schema::flags (), this), + INFO_ (::xml_schema::flags (), this), + COOSYS_ (::xml_schema::flags (), this), + GROUP_ (::xml_schema::flags (), this), + PARAM_ (::xml_schema::flags (), this), + LINK_ (::xml_schema::flags (), this), + TABLE_ (::xml_schema::flags (), this), + RESOURCE1_ (::xml_schema::flags (), this), + any_ (this->dom_document ()), + name_ (::xml_schema::flags (), this), + ID_ (::xml_schema::flags (), this), + utype_ (::xml_schema::flags (), this), + type_ (type_default_value (), ::xml_schema::flags (), this), + any_attribute_ (this->dom_document ()) + { + } + + RESOURCE:: + RESOURCE (const RESOURCE& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + dom_document_ (::xsd::cxx::xml::dom::create_document< char > ()), + DESCRIPTION_ (x.DESCRIPTION_, f, this), + INFO_ (x.INFO_, f, this), + COOSYS_ (x.COOSYS_, f, this), + GROUP_ (x.GROUP_, f, this), + PARAM_ (x.PARAM_, f, this), + LINK_ (x.LINK_, f, this), + TABLE_ (x.TABLE_, f, this), + RESOURCE1_ (x.RESOURCE1_, f, this), + any_ (x.any_, this->dom_document ()), + name_ (x.name_, f, this), + ID_ (x.ID_, f, this), + utype_ (x.utype_, f, this), + type_ (x.type_, f, this), + any_attribute_ (x.any_attribute_, this->dom_document ()) + { + } + + RESOURCE:: + RESOURCE (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + dom_document_ (::xsd::cxx::xml::dom::create_document< char > ()), + DESCRIPTION_ (f, this), + INFO_ (f, this), + COOSYS_ (f, this), + GROUP_ (f, this), + PARAM_ (f, this), + LINK_ (f, this), + TABLE_ (f, this), + RESOURCE1_ (f, this), + any_ (this->dom_document ()), + name_ (f, this), + ID_ (f, this), + utype_ (f, this), + type_ (f, this), + any_attribute_ (this->dom_document ()) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, true); + this->parse (p, f); + } + } + + void RESOURCE:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + for (; p.more_elements (); p.next_element ()) + { + const ::xercesc::DOMElement& i (p.cur_element ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + // DESCRIPTION + // + if (n.name () == "DESCRIPTION" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< DESCRIPTION_type > r ( + DESCRIPTION_traits::create (i, f, this)); + + if (!this->DESCRIPTION_) + { + this->DESCRIPTION_.set (r); + continue; + } + } + + // INFO + // + if (n.name () == "INFO" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< INFO_type > r ( + INFO_traits::create (i, f, this)); + + this->INFO_.push_back (r); + continue; + } + + // COOSYS + // + if (n.name () == "COOSYS" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< COOSYS_type > r ( + COOSYS_traits::create (i, f, this)); + + this->COOSYS_.push_back (r); + continue; + } + + // GROUP + // + if (n.name () == "GROUP" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< GROUP_type > r ( + GROUP_traits::create (i, f, this)); + + this->GROUP_.push_back (r); + continue; + } + + // PARAM + // + if (n.name () == "PARAM" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< PARAM_type > r ( + PARAM_traits::create (i, f, this)); + + this->PARAM_.push_back (r); + continue; + } + + // LINK + // + if (n.name () == "LINK" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< LINK_type > r ( + LINK_traits::create (i, f, this)); + + this->LINK_.push_back (r); + continue; + } + + // TABLE + // + if (n.name () == "TABLE" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< TABLE_type > r ( + TABLE_traits::create (i, f, this)); + + this->TABLE_.push_back (r); + continue; + } + + // RESOURCE + // + if (n.name () == "RESOURCE" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< RESOURCE1_type > r ( + RESOURCE1_traits::create (i, f, this)); + + this->RESOURCE1_.push_back (r); + continue; + } + + // any + // + if ((!n.namespace_ ().empty () && n.namespace_ () != "http://www.ivoa.net/xml/VOTable/v1.3")) + { + ::xercesc::DOMElement* r ( + static_cast< ::xercesc::DOMElement* > ( + this->dom_document ().importNode ( + const_cast< ::xercesc::DOMElement* > (&i), true))); + this->any_ .push_back (r); + continue; + } + + break; + } + + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "name" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< name_type > r ( + name_traits::create (i, f, this)); + + this->name_.set (r); + continue; + } + + if (n.name () == "ID" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ID_type > r ( + ID_traits::create (i, f, this)); + + this->ID_.set (r); + continue; + } + + if (n.name () == "utype" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< utype_type > r ( + utype_traits::create (i, f, this)); + + this->utype_.set (r); + continue; + } + + if (n.name () == "type" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< type_type > r ( + type_traits::create (i, f, this)); + + this->type_.set (r); + continue; + } + + // any_attribute + // + if ((!n.namespace_ ().empty () && + n.namespace_ () != "http://www.ivoa.net/xml/VOTable/v1.3" && + n.namespace_ () != ::xsd::cxx::xml::bits::xmlns_namespace< char > () && + n.namespace_ () != ::xsd::cxx::xml::bits::xsi_namespace< char > ())) + { + ::xercesc::DOMAttr* r ( + static_cast< ::xercesc::DOMAttr* > ( + this->dom_document ().importNode ( + const_cast< ::xercesc::DOMAttr* > (&i), true))); + this->any_attribute_ .insert (r); + continue; + } + } + + if (!type_.present ()) + { + this->type_.set (type_default_value ()); + } + } + + RESOURCE* RESOURCE:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class RESOURCE (*this, f, c); + } + + RESOURCE:: + ~RESOURCE () + { + } + + // type + // + + type:: + type (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (e, f, c) + { + _xsd_type_convert (); + } + + type:: + type (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (a, f, c) + { + _xsd_type_convert (); + } + + type:: + type (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (s, e, f, c) + { + _xsd_type_convert (); + } + + type* type:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class type (*this, f, c); + } + + type::value type:: + _xsd_type_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_type_literals_); + const value* i (::std::lower_bound ( + _xsd_type_indexes_, + _xsd_type_indexes_ + 2, + *this, + c)); + + if (i == _xsd_type_indexes_ + 2 || _xsd_type_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const type:: + _xsd_type_literals_[2] = + { + "legal", + "actual" + }; + + const type::value type:: + _xsd_type_indexes_[2] = + { + ::votable_13::type::actual, + ::votable_13::type::legal + }; + + // system + // + + system:: + system (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (e, f, c) + { + _xsd_system_convert (); + } + + system:: + system (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (a, f, c) + { + _xsd_system_convert (); + } + + system:: + system (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (s, e, f, c) + { + _xsd_system_convert (); + } + + system* system:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class system (*this, f, c); + } + + system::value system:: + _xsd_system_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_system_literals_); + const value* i (::std::lower_bound ( + _xsd_system_indexes_, + _xsd_system_indexes_ + 10, + *this, + c)); + + if (i == _xsd_system_indexes_ + 10 || _xsd_system_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const system:: + _xsd_system_literals_[10] = + { + "eq_FK4", + "eq_FK5", + "ICRS", + "ecl_FK4", + "ecl_FK5", + "galactic", + "supergalactic", + "xy", + "barycentric", + "geo_app" + }; + + const system::value system:: + _xsd_system_indexes_[10] = + { + ::votable_13::system::ICRS, + ::votable_13::system::barycentric, + ::votable_13::system::ecl_FK4, + ::votable_13::system::ecl_FK5, + ::votable_13::system::eq_FK4, + ::votable_13::system::eq_FK5, + ::votable_13::system::galactic, + ::votable_13::system::geo_app, + ::votable_13::system::supergalactic, + ::votable_13::system::xy + }; + + // type1 + // + + type1:: + type1 (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (e, f, c) + { + _xsd_type1_convert (); + } + + type1:: + type1 (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (a, f, c) + { + _xsd_type1_convert (); + } + + type1:: + type1 (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (s, e, f, c) + { + _xsd_type1_convert (); + } + + type1* type1:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class type1 (*this, f, c); + } + + type1::value type1:: + _xsd_type1_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_type1_literals_); + const value* i (::std::lower_bound ( + _xsd_type1_indexes_, + _xsd_type1_indexes_ + 4, + *this, + c)); + + if (i == _xsd_type1_indexes_ + 4 || _xsd_type1_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const type1:: + _xsd_type1_literals_[4] = + { + "hidden", + "no_query", + "trigger", + "location" + }; + + const type1::value type1:: + _xsd_type1_indexes_[4] = + { + ::votable_13::type1::hidden, + ::votable_13::type1::location, + ::votable_13::type1::no_query, + ::votable_13::type1::trigger + }; + + // type2 + // + + type2:: + type2 (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (e, f, c) + { + _xsd_type2_convert (); + } + + type2:: + type2 (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (a, f, c) + { + _xsd_type2_convert (); + } + + type2:: + type2 (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (s, e, f, c) + { + _xsd_type2_convert (); + } + + type2* type2:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class type2 (*this, f, c); + } + + type2::value type2:: + _xsd_type2_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_type2_literals_); + const value* i (::std::lower_bound ( + _xsd_type2_indexes_, + _xsd_type2_indexes_ + 2, + *this, + c)); + + if (i == _xsd_type2_indexes_ + 2 || _xsd_type2_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const type2:: + _xsd_type2_literals_[2] = + { + "locator", + "other" + }; + + const type2::value type2:: + _xsd_type2_indexes_[2] = + { + ::votable_13::type2::locator, + ::votable_13::type2::other + }; + + // actuate + // + + actuate:: + actuate (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (e, f, c) + { + _xsd_actuate_convert (); + } + + actuate:: + actuate (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (a, f, c) + { + _xsd_actuate_convert (); + } + + actuate:: + actuate (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (s, e, f, c) + { + _xsd_actuate_convert (); + } + + actuate* actuate:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class actuate (*this, f, c); + } + + actuate::value actuate:: + _xsd_actuate_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_actuate_literals_); + const value* i (::std::lower_bound ( + _xsd_actuate_indexes_, + _xsd_actuate_indexes_ + 4, + *this, + c)); + + if (i == _xsd_actuate_indexes_ + 4 || _xsd_actuate_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const actuate:: + _xsd_actuate_literals_[4] = + { + "onLoad", + "onRequest", + "other", + "none" + }; + + const actuate::value actuate:: + _xsd_actuate_indexes_[4] = + { + ::votable_13::actuate::none, + ::votable_13::actuate::onLoad, + ::votable_13::actuate::onRequest, + ::votable_13::actuate::other + }; + + // type3 + // + + type3:: + type3 (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (e, f, c) + { + _xsd_type3_convert (); + } + + type3:: + type3 (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (a, f, c) + { + _xsd_type3_convert (); + } + + type3:: + type3 (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (s, e, f, c) + { + _xsd_type3_convert (); + } + + type3* type3:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class type3 (*this, f, c); + } + + type3::value type3:: + _xsd_type3_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_type3_literals_); + const value* i (::std::lower_bound ( + _xsd_type3_indexes_, + _xsd_type3_indexes_ + 2, + *this, + c)); + + if (i == _xsd_type3_indexes_ + 2 || _xsd_type3_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const type3:: + _xsd_type3_literals_[2] = + { + "results", + "meta" + }; + + const type3::value type3:: + _xsd_type3_indexes_[2] = + { + ::votable_13::type3::meta, + ::votable_13::type3::results + }; + + // VOTABLE + // + + VOTABLE:: + VOTABLE () + : ::xml_schema::type (), + DESCRIPTION_ (::xml_schema::flags (), this), + DEFINITIONS_ (::xml_schema::flags (), this), + COOSYS_ (::xml_schema::flags (), this), + GROUP_ (::xml_schema::flags (), this), + PARAM_ (::xml_schema::flags (), this), + INFO_ (::xml_schema::flags (), this), + RESOURCE_ (::xml_schema::flags (), this), + ID_ (::xml_schema::flags (), this), + version_ (::xml_schema::flags (), this) + { + } + + VOTABLE:: + VOTABLE (const VOTABLE& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + DESCRIPTION_ (x.DESCRIPTION_, f, this), + DEFINITIONS_ (x.DEFINITIONS_, f, this), + COOSYS_ (x.COOSYS_, f, this), + GROUP_ (x.GROUP_, f, this), + PARAM_ (x.PARAM_, f, this), + INFO_ (x.INFO_, f, this), + RESOURCE_ (x.RESOURCE_, f, this), + ID_ (x.ID_, f, this), + version_ (x.version_, f, this) + { + } + + VOTABLE:: + VOTABLE (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + DESCRIPTION_ (f, this), + DEFINITIONS_ (f, this), + COOSYS_ (f, this), + GROUP_ (f, this), + PARAM_ (f, this), + INFO_ (f, this), + RESOURCE_ (f, this), + ID_ (f, this), + version_ (f, this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, true); + this->parse (p, f); + } + } + + void VOTABLE:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + for (; p.more_elements (); p.next_element ()) + { + const ::xercesc::DOMElement& i (p.cur_element ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + // DESCRIPTION + // + if (n.name () == "DESCRIPTION" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< DESCRIPTION_type > r ( + DESCRIPTION_traits::create (i, f, this)); + + if (!this->DESCRIPTION_) + { + this->DESCRIPTION_.set (r); + continue; + } + } + + // DEFINITIONS + // + if (n.name () == "DEFINITIONS" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< DEFINITIONS_type > r ( + DEFINITIONS_traits::create (i, f, this)); + + if (!this->DEFINITIONS_) + { + this->DEFINITIONS_.set (r); + continue; + } + } + + // COOSYS + // + if (n.name () == "COOSYS" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< COOSYS_type > r ( + COOSYS_traits::create (i, f, this)); + + this->COOSYS_.push_back (r); + continue; + } + + // GROUP + // + if (n.name () == "GROUP" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< GROUP_type > r ( + GROUP_traits::create (i, f, this)); + + this->GROUP_.push_back (r); + continue; + } + + // PARAM + // + if (n.name () == "PARAM" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< PARAM_type > r ( + PARAM_traits::create (i, f, this)); + + this->PARAM_.push_back (r); + continue; + } + + // INFO + // + if (n.name () == "INFO" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< INFO_type > r ( + INFO_traits::create (i, f, this)); + + this->INFO_.push_back (r); + continue; + } + + // RESOURCE + // + if (n.name () == "RESOURCE" && n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< RESOURCE_type > r ( + RESOURCE_traits::create (i, f, this)); + + this->RESOURCE_.push_back (r); + continue; + } + + break; + } + + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "ID" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< ID_type > r ( + ID_traits::create (i, f, this)); + + this->ID_.set (r); + continue; + } + + if (n.name () == "version" && n.namespace_ ().empty ()) + { + ::std::auto_ptr< version_type > r ( + version_traits::create (i, f, this)); + + this->version_.set (r); + continue; + } + } + } + + VOTABLE* VOTABLE:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class VOTABLE (*this, f, c); + } + + VOTABLE:: + ~VOTABLE () + { + } + + // version + // + + version:: + version (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (e, f, c) + { + _xsd_version_convert (); + } + + version:: + version (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (a, f, c) + { + _xsd_version_convert (); + } + + version:: + version (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::nmtoken (s, e, f, c) + { + _xsd_version_convert (); + } + + version* version:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class version (*this, f, c); + } + + version::value version:: + _xsd_version_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_version_literals_); + const value* i (::std::lower_bound ( + _xsd_version_indexes_, + _xsd_version_indexes_ + 1, + *this, + c)); + + if (i == _xsd_version_indexes_ + 1 || _xsd_version_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const version:: + _xsd_version_literals_[1] = + { + "1.3" + }; + + const version::value version:: + _xsd_version_indexes_[1] = + { + ::votable_13::version::cxx_1_3 + }; +} + +#include +#include +#include + +namespace votable_13 +{ + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (const ::std::string& u, + ::xml_schema::flags f, + const ::xml_schema::properties& p) + { + ::xsd::cxx::xml::auto_initializer i ( + (f & ::xml_schema::flags::dont_initialize) == 0, + (f & ::xml_schema::flags::keep_dom) == 0); + + ::xsd::cxx::tree::error_handler< char > h; + + ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d ( + ::xsd::cxx::xml::dom::parse< char > ( + u, h, p, f)); + + h.throw_if_failed< ::xsd::cxx::tree::parsing< char > > (); + + ::std::auto_ptr< ::votable_13::VOTABLE > r ( + ::votable_13::VOTABLE_read ( + d, f | ::xml_schema::flags::own_dom, p)); + + return r; + } + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (const ::std::string& u, + ::xml_schema::error_handler& h, + ::xml_schema::flags f, + const ::xml_schema::properties& p) + { + ::xsd::cxx::xml::auto_initializer i ( + (f & ::xml_schema::flags::dont_initialize) == 0, + (f & ::xml_schema::flags::keep_dom) == 0); + + ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d ( + ::xsd::cxx::xml::dom::parse< char > ( + u, h, p, f)); + + if (!d.get ()) + throw ::xsd::cxx::tree::parsing< char > (); + + ::std::auto_ptr< ::votable_13::VOTABLE > r ( + ::votable_13::VOTABLE_read ( + d, f | ::xml_schema::flags::own_dom, p)); + + return r; + } + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (const ::std::string& u, + ::xercesc::DOMErrorHandler& h, + ::xml_schema::flags f, + const ::xml_schema::properties& p) + { + ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d ( + ::xsd::cxx::xml::dom::parse< char > ( + u, h, p, f)); + + if (!d.get ()) + throw ::xsd::cxx::tree::parsing< char > (); + + ::std::auto_ptr< ::votable_13::VOTABLE > r ( + ::votable_13::VOTABLE_read ( + d, f | ::xml_schema::flags::own_dom, p)); + + return r; + } + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (::std::istream& is, + ::xml_schema::flags f, + const ::xml_schema::properties& p) + { + ::xsd::cxx::xml::auto_initializer i ( + (f & ::xml_schema::flags::dont_initialize) == 0, + (f & ::xml_schema::flags::keep_dom) == 0); + + ::xsd::cxx::xml::sax::std_input_source isrc (is); + return ::votable_13::VOTABLE_read (isrc, f, p); + } + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (::std::istream& is, + ::xml_schema::error_handler& h, + ::xml_schema::flags f, + const ::xml_schema::properties& p) + { + ::xsd::cxx::xml::auto_initializer i ( + (f & ::xml_schema::flags::dont_initialize) == 0, + (f & ::xml_schema::flags::keep_dom) == 0); + + ::xsd::cxx::xml::sax::std_input_source isrc (is); + return ::votable_13::VOTABLE_read (isrc, h, f, p); + } + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (::std::istream& is, + ::xercesc::DOMErrorHandler& h, + ::xml_schema::flags f, + const ::xml_schema::properties& p) + { + ::xsd::cxx::xml::sax::std_input_source isrc (is); + return ::votable_13::VOTABLE_read (isrc, h, f, p); + } + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (::std::istream& is, + const ::std::string& sid, + ::xml_schema::flags f, + const ::xml_schema::properties& p) + { + ::xsd::cxx::xml::auto_initializer i ( + (f & ::xml_schema::flags::dont_initialize) == 0, + (f & ::xml_schema::flags::keep_dom) == 0); + + ::xsd::cxx::xml::sax::std_input_source isrc (is, sid); + return ::votable_13::VOTABLE_read (isrc, f, p); + } + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (::std::istream& is, + const ::std::string& sid, + ::xml_schema::error_handler& h, + ::xml_schema::flags f, + const ::xml_schema::properties& p) + { + ::xsd::cxx::xml::auto_initializer i ( + (f & ::xml_schema::flags::dont_initialize) == 0, + (f & ::xml_schema::flags::keep_dom) == 0); + + ::xsd::cxx::xml::sax::std_input_source isrc (is, sid); + return ::votable_13::VOTABLE_read (isrc, h, f, p); + } + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (::std::istream& is, + const ::std::string& sid, + ::xercesc::DOMErrorHandler& h, + ::xml_schema::flags f, + const ::xml_schema::properties& p) + { + ::xsd::cxx::xml::sax::std_input_source isrc (is, sid); + return ::votable_13::VOTABLE_read (isrc, h, f, p); + } + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (::xercesc::InputSource& i, + ::xml_schema::flags f, + const ::xml_schema::properties& p) + { + ::xsd::cxx::tree::error_handler< char > h; + + ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d ( + ::xsd::cxx::xml::dom::parse< char > ( + i, h, p, f)); + + h.throw_if_failed< ::xsd::cxx::tree::parsing< char > > (); + + ::std::auto_ptr< ::votable_13::VOTABLE > r ( + ::votable_13::VOTABLE_read ( + d, f | ::xml_schema::flags::own_dom, p)); + + return r; + } + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (::xercesc::InputSource& i, + ::xml_schema::error_handler& h, + ::xml_schema::flags f, + const ::xml_schema::properties& p) + { + ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d ( + ::xsd::cxx::xml::dom::parse< char > ( + i, h, p, f)); + + if (!d.get ()) + throw ::xsd::cxx::tree::parsing< char > (); + + ::std::auto_ptr< ::votable_13::VOTABLE > r ( + ::votable_13::VOTABLE_read ( + d, f | ::xml_schema::flags::own_dom, p)); + + return r; + } + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (::xercesc::InputSource& i, + ::xercesc::DOMErrorHandler& h, + ::xml_schema::flags f, + const ::xml_schema::properties& p) + { + ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d ( + ::xsd::cxx::xml::dom::parse< char > ( + i, h, p, f)); + + if (!d.get ()) + throw ::xsd::cxx::tree::parsing< char > (); + + ::std::auto_ptr< ::votable_13::VOTABLE > r ( + ::votable_13::VOTABLE_read ( + d, f | ::xml_schema::flags::own_dom, p)); + + return r; + } + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (const ::xercesc::DOMDocument& d, + ::xml_schema::flags f, + const ::xml_schema::properties& p) + { + if (f & ::xml_schema::flags::keep_dom) + { + ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > c ( + static_cast< ::xercesc::DOMDocument* > (d.cloneNode (true))); + + ::std::auto_ptr< ::votable_13::VOTABLE > r ( + ::votable_13::VOTABLE_read ( + c, f | ::xml_schema::flags::own_dom, p)); + + return r; + } + + const ::xercesc::DOMElement& e (*d.getDocumentElement ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (e)); + + if (n.name () == "VOTABLE" && + n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< ::votable_13::VOTABLE > r ( + ::xsd::cxx::tree::traits< ::votable_13::VOTABLE, char >::create ( + e, f, 0)); + return r; + } + + throw ::xsd::cxx::tree::unexpected_element < char > ( + n.name (), + n.namespace_ (), + "VOTABLE", + "http://www.ivoa.net/xml/VOTable/v1.3"); + } + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument >& d, + ::xml_schema::flags f, + const ::xml_schema::properties&) + { + ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > c ( + ((f & ::xml_schema::flags::keep_dom) && + !(f & ::xml_schema::flags::own_dom)) + ? static_cast< ::xercesc::DOMDocument* > (d->cloneNode (true)) + : 0); + + ::xercesc::DOMDocument& doc (c.get () ? *c : *d); + const ::xercesc::DOMElement& e (*doc.getDocumentElement ()); + + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (e)); + + if (f & ::xml_schema::flags::keep_dom) + doc.setUserData (::xml_schema::dom::tree_node_key, + (c.get () ? &c : &d), + 0); + + if (n.name () == "VOTABLE" && + n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + ::std::auto_ptr< ::votable_13::VOTABLE > r ( + ::xsd::cxx::tree::traits< ::votable_13::VOTABLE, char >::create ( + e, f, 0)); + return r; + } + + throw ::xsd::cxx::tree::unexpected_element < char > ( + n.name (), + n.namespace_ (), + "VOTABLE", + "http://www.ivoa.net/xml/VOTable/v1.3"); + } +} + +#include +#include +#include + +namespace votable_13 +{ + void + operator<< (::xercesc::DOMElement& e, const anyTEXT& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // any + // + for (anyTEXT::any_const_iterator + b (i.any ().begin ()), n (i.any ().end ()); + b != n; ++b) + { + e.appendChild ( + e.getOwnerDocument ()->importNode ( + const_cast< ::xercesc::DOMElement* > (&(*b)), true)); + } + } + + void + operator<< (::xercesc::DOMElement& e, const astroYear& i) + { + e << static_cast< const ::xml_schema::token& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, const astroYear& i) + { + a << static_cast< const ::xml_schema::token& > (i); + } + + void + operator<< (::xml_schema::list_stream& l, + const astroYear& i) + { + l << static_cast< const ::xml_schema::token& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, const ucdType& i) + { + e << static_cast< const ::xml_schema::token& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, const ucdType& i) + { + a << static_cast< const ::xml_schema::token& > (i); + } + + void + operator<< (::xml_schema::list_stream& l, + const ucdType& i) + { + l << static_cast< const ::xml_schema::token& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, const arrayDEF& i) + { + e << static_cast< const ::xml_schema::token& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, const arrayDEF& i) + { + a << static_cast< const ::xml_schema::token& > (i); + } + + void + operator<< (::xml_schema::list_stream& l, + const arrayDEF& i) + { + l << static_cast< const ::xml_schema::token& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, const encodingType& i) + { + e << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, const encodingType& i) + { + a << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xml_schema::list_stream& l, + const encodingType& i) + { + l << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, const dataType& i) + { + e << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, const dataType& i) + { + a << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xml_schema::list_stream& l, + const dataType& i) + { + l << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, const precType& i) + { + e << static_cast< const ::xml_schema::token& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, const precType& i) + { + a << static_cast< const ::xml_schema::token& > (i); + } + + void + operator<< (::xml_schema::list_stream& l, + const precType& i) + { + l << static_cast< const ::xml_schema::token& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, const yesno& i) + { + e << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, const yesno& i) + { + a << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xml_schema::list_stream& l, + const yesno& i) + { + l << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, const MIN& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // value + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "value", + e)); + + a << i.value (); + } + + // inclusive + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "inclusive", + e)); + + a << i.inclusive (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const MAX& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // value + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "value", + e)); + + a << i.value (); + } + + // inclusive + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "inclusive", + e)); + + a << i.inclusive (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const OPTION& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // OPTION + // + for (OPTION::OPTION1_const_iterator + b (i.OPTION1 ().begin ()), n (i.OPTION1 ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "OPTION", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // name + // + if (i.name ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "name", + e)); + + a << *i.name (); + } + + // value + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "value", + e)); + + a << i.value (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const VALUES& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // MIN + // + if (i.MIN ()) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "MIN", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *i.MIN (); + } + + // MAX + // + if (i.MAX ()) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "MAX", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *i.MAX (); + } + + // OPTION + // + for (VALUES::OPTION_const_iterator + b (i.OPTION ().begin ()), n (i.OPTION ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "OPTION", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // ID + // + if (i.ID ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ID", + e)); + + a << *i.ID (); + } + + // type + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "type", + e)); + + a << i.type (); + } + + // null + // + if (i.null ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "null", + e)); + + a << *i.null (); + } + + // ref + // + if (i.ref ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ref", + e)); + + a << *i.ref (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const LINK& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // ID + // + if (i.ID ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ID", + e)); + + a << *i.ID (); + } + + // content-role + // + if (i.content_role ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "content-role", + e)); + + a << *i.content_role (); + } + + // content-type + // + if (i.content_type ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "content-type", + e)); + + a << *i.content_type (); + } + + // title + // + if (i.title ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "title", + e)); + + a << *i.title (); + } + + // value + // + if (i.value ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "value", + e)); + + a << *i.value (); + } + + // href + // + if (i.href ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "href", + e)); + + a << *i.href (); + } + + // gref + // + if (i.gref ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "gref", + e)); + + a << *i.gref (); + } + + // action + // + if (i.action ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "action", + e)); + + a << *i.action (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const INFO& i) + { + e << static_cast< const ::xml_schema::string& > (i); + + // ID + // + if (i.ID ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ID", + e)); + + a << *i.ID (); + } + + // name + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "name", + e)); + + a << i.name (); + } + + // value + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "value", + e)); + + a << i.value (); + } + + // unit + // + if (i.unit ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "unit", + e)); + + a << *i.unit (); + } + + // xtype + // + if (i.xtype ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "xtype", + e)); + + a << *i.xtype (); + } + + // ref + // + if (i.ref ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ref", + e)); + + a << *i.ref (); + } + + // ucd + // + if (i.ucd ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ucd", + e)); + + a << *i.ucd (); + } + + // utype + // + if (i.utype ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "utype", + e)); + + a << *i.utype (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const COOSYS& i) + { + e << static_cast< const ::xml_schema::string& > (i); + + // ID + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ID", + e)); + + a << i.ID (); + } + + // equinox + // + if (i.equinox ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "equinox", + e)); + + a << *i.equinox (); + } + + // epoch + // + if (i.epoch ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "epoch", + e)); + + a << *i.epoch (); + } + + // system + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "system", + e)); + + a << i.system (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const DEFINITIONS& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // COOSYS + // + for (DEFINITIONS::COOSYS_const_iterator + b (i.COOSYS ().begin ()), n (i.COOSYS ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "COOSYS", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // PARAM + // + for (DEFINITIONS::PARAM_const_iterator + b (i.PARAM ().begin ()), n (i.PARAM ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "PARAM", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + } + + void + operator<< (::xercesc::DOMElement& e, const FIELD& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // DESCRIPTION + // + if (i.DESCRIPTION ()) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "DESCRIPTION", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *i.DESCRIPTION (); + } + + // VALUES + // + if (i.VALUES ()) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "VALUES", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *i.VALUES (); + } + + // LINK + // + for (FIELD::LINK_const_iterator + b (i.LINK ().begin ()), n (i.LINK ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "LINK", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // ID + // + if (i.ID ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ID", + e)); + + a << *i.ID (); + } + + // unit + // + if (i.unit ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "unit", + e)); + + a << *i.unit (); + } + + // datatype + // + if (i.datatype ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "datatype", + e)); + + a << *i.datatype (); + } + + // precision + // + if (i.precision ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "precision", + e)); + + a << *i.precision (); + } + + // width + // + if (i.width ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "width", + e)); + + a << *i.width (); + } + + // xtype + // + if (i.xtype ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "xtype", + e)); + + a << *i.xtype (); + } + + // ref + // + if (i.ref ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ref", + e)); + + a << *i.ref (); + } + + // name + // + if (i.name ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "name", + e)); + + a << *i.name (); + } + + // ucd + // + if (i.ucd ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ucd", + e)); + + a << *i.ucd (); + } + + // utype + // + if (i.utype ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "utype", + e)); + + a << *i.utype (); + } + + // arraysize + // + if (i.arraysize ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "arraysize", + e)); + + a << *i.arraysize (); + } + + // type + // + if (i.type ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "type", + e)); + + a << *i.type (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const PARAM& i) + { + e << static_cast< const ::votable_13::FIELD& > (i); + + // value + // + if (i.value ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "value", + e)); + + a << *i.value (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const GROUP& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // DESCRIPTION + // + if (i.DESCRIPTION ()) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "DESCRIPTION", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *i.DESCRIPTION (); + } + + // FIELDref + // + for (GROUP::FIELDref_const_iterator + b (i.FIELDref ().begin ()), n (i.FIELDref ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "FIELDref", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // PARAMref + // + for (GROUP::PARAMref_const_iterator + b (i.PARAMref ().begin ()), n (i.PARAMref ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "PARAMref", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // PARAM + // + for (GROUP::PARAM_const_iterator + b (i.PARAM ().begin ()), n (i.PARAM ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "PARAM", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // GROUP + // + for (GROUP::GROUP1_const_iterator + b (i.GROUP1 ().begin ()), n (i.GROUP1 ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "GROUP", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // ID + // + if (i.ID ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ID", + e)); + + a << *i.ID (); + } + + // name + // + if (i.name ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "name", + e)); + + a << *i.name (); + } + + // ref + // + if (i.ref ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ref", + e)); + + a << *i.ref (); + } + + // ucd + // + if (i.ucd ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ucd", + e)); + + a << *i.ucd (); + } + + // utype + // + if (i.utype ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "utype", + e)); + + a << *i.utype (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const FIELDref& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // ref + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ref", + e)); + + a << i.ref (); + } + + // ucd + // + if (i.ucd ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ucd", + e)); + + a << *i.ucd (); + } + + // utype + // + if (i.utype ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "utype", + e)); + + a << *i.utype (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const PARAMref& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // ref + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ref", + e)); + + a << i.ref (); + } + + // ucd + // + if (i.ucd ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ucd", + e)); + + a << *i.ucd (); + } + + // utype + // + if (i.utype ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "utype", + e)); + + a << *i.utype (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const DATA& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // TABLEDATA + // + if (i.TABLEDATA ()) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "TABLEDATA", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *i.TABLEDATA (); + } + + // BINARY + // + if (i.BINARY ()) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "BINARY", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *i.BINARY (); + } + + // BINARY2 + // + if (i.BINARY2 ()) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "BINARY2", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *i.BINARY2 (); + } + + // FITS + // + if (i.FITS ()) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "FITS", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *i.FITS (); + } + + // INFO + // + for (DATA::INFO_const_iterator + b (i.INFO ().begin ()), n (i.INFO ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "INFO", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + } + + void + operator<< (::xercesc::DOMElement& e, const TABLEDATA& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // TR + // + for (TABLEDATA::TR_const_iterator + b (i.TR ().begin ()), n (i.TR ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "TR", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + } + + void + operator<< (::xercesc::DOMElement& e, const TD& i) + { + e << static_cast< const ::xml_schema::string& > (i); + + // encoding + // + if (i.encoding ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "encoding", + e)); + + a << *i.encoding (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const TR& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // TD + // + for (TR::TD_const_iterator + b (i.TD ().begin ()), n (i.TD ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "TD", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // ID + // + if (i.ID ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ID", + e)); + + a << *i.ID (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const FITS& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // STREAM + // + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "STREAM", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << i.STREAM (); + } + + // extnum + // + if (i.extnum ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "extnum", + e)); + + a << *i.extnum (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const BINARY& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // STREAM + // + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "STREAM", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << i.STREAM (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const BINARY2& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // STREAM + // + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "STREAM", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << i.STREAM (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const STREAM& i) + { + e << static_cast< const ::xml_schema::string& > (i); + + // type + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "type", + e)); + + a << i.type (); + } + + // href + // + if (i.href ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "href", + e)); + + a << *i.href (); + } + + // actuate + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "actuate", + e)); + + a << i.actuate (); + } + + // encoding + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "encoding", + e)); + + a << i.encoding (); + } + + // expires + // + if (i.expires ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "expires", + e)); + + a << *i.expires (); + } + + // rights + // + if (i.rights ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "rights", + e)); + + a << *i.rights (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const TABLE& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // DESCRIPTION + // + if (i.DESCRIPTION ()) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "DESCRIPTION", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *i.DESCRIPTION (); + } + + // INFO + // + for (TABLE::INFO_const_iterator + b (i.INFO ().begin ()), n (i.INFO ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "INFO", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // FIELD + // + for (TABLE::FIELD_const_iterator + b (i.FIELD ().begin ()), n (i.FIELD ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "FIELD", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // PARAM + // + for (TABLE::PARAM_const_iterator + b (i.PARAM ().begin ()), n (i.PARAM ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "PARAM", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // GROUP + // + for (TABLE::GROUP_const_iterator + b (i.GROUP ().begin ()), n (i.GROUP ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "GROUP", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // LINK + // + for (TABLE::LINK_const_iterator + b (i.LINK ().begin ()), n (i.LINK ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "LINK", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // DATA + // + if (i.DATA ()) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "DATA", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *i.DATA (); + } + + // ID + // + if (i.ID ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ID", + e)); + + a << *i.ID (); + } + + // name + // + if (i.name ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "name", + e)); + + a << *i.name (); + } + + // ref + // + if (i.ref ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ref", + e)); + + a << *i.ref (); + } + + // ucd + // + if (i.ucd ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ucd", + e)); + + a << *i.ucd (); + } + + // utype + // + if (i.utype ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "utype", + e)); + + a << *i.utype (); + } + + // nrows + // + if (i.nrows ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "nrows", + e)); + + a << *i.nrows (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const RESOURCE& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // any_attribute + // + for (RESOURCE::any_attribute_const_iterator + b (i.any_attribute ().begin ()), n (i.any_attribute ().end ()); + b != n; ++b) + { + ::xercesc::DOMAttr* a ( + static_cast< ::xercesc::DOMAttr* > ( + e.getOwnerDocument ()->importNode ( + const_cast< ::xercesc::DOMAttr* > (&(*b)), true))); + + if (a->getLocalName () == 0) + e.setAttributeNode (a); + else + e.setAttributeNodeNS (a); + } + + // DESCRIPTION + // + if (i.DESCRIPTION ()) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "DESCRIPTION", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *i.DESCRIPTION (); + } + + // INFO + // + for (RESOURCE::INFO_const_iterator + b (i.INFO ().begin ()), n (i.INFO ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "INFO", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // COOSYS + // + for (RESOURCE::COOSYS_const_iterator + b (i.COOSYS ().begin ()), n (i.COOSYS ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "COOSYS", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // GROUP + // + for (RESOURCE::GROUP_const_iterator + b (i.GROUP ().begin ()), n (i.GROUP ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "GROUP", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // PARAM + // + for (RESOURCE::PARAM_const_iterator + b (i.PARAM ().begin ()), n (i.PARAM ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "PARAM", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // LINK + // + for (RESOURCE::LINK_const_iterator + b (i.LINK ().begin ()), n (i.LINK ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "LINK", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // TABLE + // + for (RESOURCE::TABLE_const_iterator + b (i.TABLE ().begin ()), n (i.TABLE ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "TABLE", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // RESOURCE + // + for (RESOURCE::RESOURCE1_const_iterator + b (i.RESOURCE1 ().begin ()), n (i.RESOURCE1 ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "RESOURCE", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // any + // + for (RESOURCE::any_const_iterator + b (i.any ().begin ()), n (i.any ().end ()); + b != n; ++b) + { + e.appendChild ( + e.getOwnerDocument ()->importNode ( + const_cast< ::xercesc::DOMElement* > (&(*b)), true)); + } + + // name + // + if (i.name ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "name", + e)); + + a << *i.name (); + } + + // ID + // + if (i.ID ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ID", + e)); + + a << *i.ID (); + } + + // utype + // + if (i.utype ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "utype", + e)); + + a << *i.utype (); + } + + // type + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "type", + e)); + + a << i.type (); + } + } + + void + VOTABLE_write (::std::ostream& o, + const ::votable_13::VOTABLE& s, + const ::xml_schema::namespace_infomap& m, + const ::std::string& e, + ::xml_schema::flags f) + { + ::xsd::cxx::xml::auto_initializer i ( + (f & ::xml_schema::flags::dont_initialize) == 0); + + ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d ( + ::votable_13::VOTABLE_write (s, m, f)); + + ::xsd::cxx::tree::error_handler< char > h; + + ::xsd::cxx::xml::dom::ostream_format_target t (o); + if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f)) + { + h.throw_if_failed< ::xsd::cxx::tree::serialization< char > > (); + } + } + + void + VOTABLE_write (::std::ostream& o, + const ::votable_13::VOTABLE& s, + ::xml_schema::error_handler& h, + const ::xml_schema::namespace_infomap& m, + const ::std::string& e, + ::xml_schema::flags f) + { + ::xsd::cxx::xml::auto_initializer i ( + (f & ::xml_schema::flags::dont_initialize) == 0); + + ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d ( + ::votable_13::VOTABLE_write (s, m, f)); + ::xsd::cxx::xml::dom::ostream_format_target t (o); + if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f)) + { + throw ::xsd::cxx::tree::serialization< char > (); + } + } + + void + VOTABLE_write (::std::ostream& o, + const ::votable_13::VOTABLE& s, + ::xercesc::DOMErrorHandler& h, + const ::xml_schema::namespace_infomap& m, + const ::std::string& e, + ::xml_schema::flags f) + { + ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d ( + ::votable_13::VOTABLE_write (s, m, f)); + ::xsd::cxx::xml::dom::ostream_format_target t (o); + if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f)) + { + throw ::xsd::cxx::tree::serialization< char > (); + } + } + + void + VOTABLE_write (::xercesc::XMLFormatTarget& t, + const ::votable_13::VOTABLE& s, + const ::xml_schema::namespace_infomap& m, + const ::std::string& e, + ::xml_schema::flags f) + { + ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d ( + ::votable_13::VOTABLE_write (s, m, f)); + + ::xsd::cxx::tree::error_handler< char > h; + + if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f)) + { + h.throw_if_failed< ::xsd::cxx::tree::serialization< char > > (); + } + } + + void + VOTABLE_write (::xercesc::XMLFormatTarget& t, + const ::votable_13::VOTABLE& s, + ::xml_schema::error_handler& h, + const ::xml_schema::namespace_infomap& m, + const ::std::string& e, + ::xml_schema::flags f) + { + ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d ( + ::votable_13::VOTABLE_write (s, m, f)); + if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f)) + { + throw ::xsd::cxx::tree::serialization< char > (); + } + } + + void + VOTABLE_write (::xercesc::XMLFormatTarget& t, + const ::votable_13::VOTABLE& s, + ::xercesc::DOMErrorHandler& h, + const ::xml_schema::namespace_infomap& m, + const ::std::string& e, + ::xml_schema::flags f) + { + ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d ( + ::votable_13::VOTABLE_write (s, m, f)); + if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f)) + { + throw ::xsd::cxx::tree::serialization< char > (); + } + } + + void + VOTABLE_write (::xercesc::DOMDocument& d, + const ::votable_13::VOTABLE& s, + ::xml_schema::flags) + { + ::xercesc::DOMElement& e (*d.getDocumentElement ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (e)); + + if (n.name () == "VOTABLE" && + n.namespace_ () == "http://www.ivoa.net/xml/VOTable/v1.3") + { + e << s; + } + else + { + throw ::xsd::cxx::tree::unexpected_element < char > ( + n.name (), + n.namespace_ (), + "VOTABLE", + "http://www.ivoa.net/xml/VOTable/v1.3"); + } + } + + ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > + VOTABLE_write (const ::votable_13::VOTABLE& s, + const ::xml_schema::namespace_infomap& m, + ::xml_schema::flags f) + { + ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d ( + ::xsd::cxx::xml::dom::serialize< char > ( + "VOTABLE", + "http://www.ivoa.net/xml/VOTable/v1.3", + m, f)); + + ::votable_13::VOTABLE_write (*d, s, f); + return d; + } + + void + operator<< (::xercesc::DOMElement& e, const type& i) + { + e << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, const type& i) + { + a << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xml_schema::list_stream& l, + const type& i) + { + l << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, const system& i) + { + e << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, const system& i) + { + a << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xml_schema::list_stream& l, + const system& i) + { + l << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, const type1& i) + { + e << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, const type1& i) + { + a << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xml_schema::list_stream& l, + const type1& i) + { + l << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, const type2& i) + { + e << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, const type2& i) + { + a << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xml_schema::list_stream& l, + const type2& i) + { + l << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, const actuate& i) + { + e << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, const actuate& i) + { + a << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xml_schema::list_stream& l, + const actuate& i) + { + l << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, const type3& i) + { + e << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, const type3& i) + { + a << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xml_schema::list_stream& l, + const type3& i) + { + l << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xercesc::DOMElement& e, const VOTABLE& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // DESCRIPTION + // + if (i.DESCRIPTION ()) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "DESCRIPTION", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *i.DESCRIPTION (); + } + + // DEFINITIONS + // + if (i.DEFINITIONS ()) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "DEFINITIONS", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *i.DEFINITIONS (); + } + + // COOSYS + // + for (VOTABLE::COOSYS_const_iterator + b (i.COOSYS ().begin ()), n (i.COOSYS ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "COOSYS", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // GROUP + // + for (VOTABLE::GROUP_const_iterator + b (i.GROUP ().begin ()), n (i.GROUP ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "GROUP", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // PARAM + // + for (VOTABLE::PARAM_const_iterator + b (i.PARAM ().begin ()), n (i.PARAM ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "PARAM", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // INFO + // + for (VOTABLE::INFO_const_iterator + b (i.INFO ().begin ()), n (i.INFO ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "INFO", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // RESOURCE + // + for (VOTABLE::RESOURCE_const_iterator + b (i.RESOURCE ().begin ()), n (i.RESOURCE ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "RESOURCE", + "http://www.ivoa.net/xml/VOTable/v1.3", + e)); + + s << *b; + } + + // ID + // + if (i.ID ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "ID", + e)); + + a << *i.ID (); + } + + // version + // + if (i.version ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "version", + e)); + + a << *i.version (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const version& i) + { + e << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, const version& i) + { + a << static_cast< const ::xml_schema::nmtoken& > (i); + } + + void + operator<< (::xml_schema::list_stream& l, + const version& i) + { + l << static_cast< const ::xml_schema::nmtoken& > (i); + } +} + +#include + +// Begin epilogue. +// +// +// End epilogue. + diff --git a/applications/gaia/gaiavo/generic/VOTable1.3.hxx b/applications/gaia/gaiavo/generic/VOTable1.3.hxx new file mode 100644 index 00000000000..ad6f47986f0 --- /dev/null +++ b/applications/gaia/gaiavo/generic/VOTable1.3.hxx @@ -0,0 +1,4851 @@ +// Copyright (C) 2005-2010 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 VOTABLE1_3_HXX +#define VOTABLE1_3_HXX + +// Begin prologue. +// +// +// End prologue. + +#include + +#if (XSD_INT_VERSION != 3030000L) +#error XSD runtime version mismatch +#endif + +#include + +#ifndef XSD_USE_CHAR +#define XSD_USE_CHAR +#endif + +#ifndef XSD_CXX_TREE_USE_CHAR +#define XSD_CXX_TREE_USE_CHAR +#endif + +#include + +#include +#include +#include + +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace xml_schema +{ + // anyType and anySimpleType. + // + typedef ::xsd::cxx::tree::type type; + typedef ::xsd::cxx::tree::simple_type< 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; + + // 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::auto_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 votable_13 +{ + class anyTEXT; + class astroYear; + class ucdType; + class arrayDEF; + class encodingType; + class dataType; + class precType; + class yesno; + class MIN; + class MAX; + class OPTION; + class VALUES; + class LINK; + class INFO; + class COOSYS; + class DEFINITIONS; + class FIELD; + class PARAM; + class GROUP; + class FIELDref; + class PARAMref; + class DATA; + class TABLEDATA; + class TD; + class TR; + class FITS; + class BINARY; + class BINARY2; + class STREAM; + class TABLE; + class RESOURCE; + class type; + class system; + class type1; + class type2; + class actuate; + class type3; + class VOTABLE; + class version; +} + + +#include // std::auto_ptr +#include // std::numeric_limits +#include // std::binary_search + +#include + +#include +#include +#include +#include + +#include + +#include + +namespace votable_13 +{ + class anyTEXT: public ::xml_schema::type + { + public: + // any + // + typedef ::xsd::cxx::tree::element_sequence any_sequence; + typedef any_sequence::iterator any_iterator; + typedef any_sequence::const_iterator any_const_iterator; + + const any_sequence& + any () const; + + any_sequence& + any (); + + void + any (const any_sequence& s); + + // DOMDocument for wildcard content. + // + const ::xercesc::DOMDocument& + dom_document () const; + + ::xercesc::DOMDocument& + dom_document (); + + // Constructors. + // + anyTEXT (); + + anyTEXT (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + anyTEXT (const anyTEXT& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual anyTEXT* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~anyTEXT (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > dom_document_; + + any_sequence any_; + }; + + class astroYear: public ::xml_schema::token + { + public: + // Constructors. + // + astroYear (); + + astroYear (const char*); + + astroYear (const ::std::string&); + + astroYear (const ::xml_schema::token&); + + astroYear (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + astroYear (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + astroYear (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + astroYear (const astroYear& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual astroYear* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~astroYear (); + }; + + class ucdType: public ::xml_schema::token + { + public: + // Constructors. + // + ucdType (); + + ucdType (const char*); + + ucdType (const ::std::string&); + + ucdType (const ::xml_schema::token&); + + ucdType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + ucdType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + ucdType (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + ucdType (const ucdType& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual ucdType* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~ucdType (); + }; + + class arrayDEF: public ::xml_schema::token + { + public: + // Constructors. + // + arrayDEF (); + + arrayDEF (const char*); + + arrayDEF (const ::std::string&); + + arrayDEF (const ::xml_schema::token&); + + arrayDEF (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + arrayDEF (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + arrayDEF (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + arrayDEF (const arrayDEF& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual arrayDEF* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~arrayDEF (); + }; + + class encodingType: public ::xml_schema::nmtoken + { + public: + enum value + { + gzip, + base64, + dynamic, + none + }; + + encodingType (value v); + + encodingType (const char* v); + + encodingType (const ::std::string& v); + + encodingType (const ::xml_schema::nmtoken& v); + + encodingType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + encodingType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + encodingType (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + encodingType (const encodingType& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual encodingType* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + encodingType& + operator= (value v); + + virtual + operator value () const + { + return _xsd_encodingType_convert (); + } + + protected: + value + _xsd_encodingType_convert () const; + + public: + static const char* const _xsd_encodingType_literals_[4]; + static const value _xsd_encodingType_indexes_[4]; + }; + + class dataType: public ::xml_schema::nmtoken + { + public: + enum value + { + boolean, + bit, + unsignedByte, + short_, + int_, + long_, + char_, + unicodeChar, + float_, + double_, + floatComplex, + doubleComplex + }; + + dataType (value v); + + dataType (const char* v); + + dataType (const ::std::string& v); + + dataType (const ::xml_schema::nmtoken& v); + + dataType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + dataType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + dataType (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + dataType (const dataType& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual dataType* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + dataType& + operator= (value v); + + virtual + operator value () const + { + return _xsd_dataType_convert (); + } + + protected: + value + _xsd_dataType_convert () const; + + public: + static const char* const _xsd_dataType_literals_[12]; + static const value _xsd_dataType_indexes_[12]; + }; + + class precType: public ::xml_schema::token + { + public: + // Constructors. + // + precType (); + + precType (const char*); + + precType (const ::std::string&); + + precType (const ::xml_schema::token&); + + precType (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + precType (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + precType (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + precType (const precType& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual precType* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~precType (); + }; + + class yesno: public ::xml_schema::nmtoken + { + public: + enum value + { + yes, + no + }; + + yesno (value v); + + yesno (const char* v); + + yesno (const ::std::string& v); + + yesno (const ::xml_schema::nmtoken& v); + + yesno (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + yesno (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + yesno (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + yesno (const yesno& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual yesno* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + yesno& + operator= (value v); + + virtual + operator value () const + { + return _xsd_yesno_convert (); + } + + protected: + value + _xsd_yesno_convert () const; + + public: + static const char* const _xsd_yesno_literals_[2]; + static const value _xsd_yesno_indexes_[2]; + }; + + class MIN: public ::xml_schema::type + { + public: + // value + // + typedef ::xml_schema::string value_type; + typedef ::xsd::cxx::tree::traits< value_type, char > value_traits; + + const value_type& + value () const; + + value_type& + value (); + + void + value (const value_type& x); + + void + value (::std::auto_ptr< value_type > p); + + // inclusive + // + typedef ::votable_13::yesno inclusive_type; + typedef ::xsd::cxx::tree::traits< inclusive_type, char > inclusive_traits; + + const inclusive_type& + inclusive () const; + + inclusive_type& + inclusive (); + + void + inclusive (const inclusive_type& x); + + void + inclusive (::std::auto_ptr< inclusive_type > p); + + static const inclusive_type& + inclusive_default_value (); + + // Constructors. + // + MIN (const value_type&); + + MIN (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + MIN (const MIN& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual MIN* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~MIN (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + ::xsd::cxx::tree::one< value_type > value_; + ::xsd::cxx::tree::one< inclusive_type > inclusive_; + static const inclusive_type inclusive_default_value_; + }; + + class MAX: public ::xml_schema::type + { + public: + // value + // + typedef ::xml_schema::string value_type; + typedef ::xsd::cxx::tree::traits< value_type, char > value_traits; + + const value_type& + value () const; + + value_type& + value (); + + void + value (const value_type& x); + + void + value (::std::auto_ptr< value_type > p); + + // inclusive + // + typedef ::votable_13::yesno inclusive_type; + typedef ::xsd::cxx::tree::traits< inclusive_type, char > inclusive_traits; + + const inclusive_type& + inclusive () const; + + inclusive_type& + inclusive (); + + void + inclusive (const inclusive_type& x); + + void + inclusive (::std::auto_ptr< inclusive_type > p); + + static const inclusive_type& + inclusive_default_value (); + + // Constructors. + // + MAX (const value_type&); + + MAX (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + MAX (const MAX& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual MAX* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~MAX (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + ::xsd::cxx::tree::one< value_type > value_; + ::xsd::cxx::tree::one< inclusive_type > inclusive_; + static const inclusive_type inclusive_default_value_; + }; + + class OPTION: public ::xml_schema::type + { + public: + // OPTION + // + typedef ::votable_13::OPTION OPTION1_type; + typedef ::xsd::cxx::tree::sequence< OPTION1_type > OPTION1_sequence; + typedef OPTION1_sequence::iterator OPTION1_iterator; + typedef OPTION1_sequence::const_iterator OPTION1_const_iterator; + typedef ::xsd::cxx::tree::traits< OPTION1_type, char > OPTION1_traits; + + const OPTION1_sequence& + OPTION1 () const; + + OPTION1_sequence& + OPTION1 (); + + void + OPTION1 (const OPTION1_sequence& s); + + // name + // + typedef ::xml_schema::token name_type; + typedef ::xsd::cxx::tree::optional< name_type > name_optional; + typedef ::xsd::cxx::tree::traits< name_type, char > name_traits; + + const name_optional& + name () const; + + name_optional& + name (); + + void + name (const name_type& x); + + void + name (const name_optional& x); + + void + name (::std::auto_ptr< name_type > p); + + // value + // + typedef ::xml_schema::string value_type; + typedef ::xsd::cxx::tree::traits< value_type, char > value_traits; + + const value_type& + value () const; + + value_type& + value (); + + void + value (const value_type& x); + + void + value (::std::auto_ptr< value_type > p); + + // Constructors. + // + OPTION (const value_type&); + + OPTION (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + OPTION (const OPTION& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual OPTION* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~OPTION (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + OPTION1_sequence OPTION1_; + name_optional name_; + ::xsd::cxx::tree::one< value_type > value_; + }; + + class VALUES: public ::xml_schema::type + { + public: + // MIN + // + typedef ::votable_13::MIN MIN_type; + typedef ::xsd::cxx::tree::optional< MIN_type > MIN_optional; + typedef ::xsd::cxx::tree::traits< MIN_type, char > MIN_traits; + + const MIN_optional& + MIN () const; + + MIN_optional& + MIN (); + + void + MIN (const MIN_type& x); + + void + MIN (const MIN_optional& x); + + void + MIN (::std::auto_ptr< MIN_type > p); + + // MAX + // + typedef ::votable_13::MAX MAX_type; + typedef ::xsd::cxx::tree::optional< MAX_type > MAX_optional; + typedef ::xsd::cxx::tree::traits< MAX_type, char > MAX_traits; + + const MAX_optional& + MAX () const; + + MAX_optional& + MAX (); + + void + MAX (const MAX_type& x); + + void + MAX (const MAX_optional& x); + + void + MAX (::std::auto_ptr< MAX_type > p); + + // OPTION + // + typedef ::votable_13::OPTION OPTION_type; + typedef ::xsd::cxx::tree::sequence< OPTION_type > OPTION_sequence; + typedef OPTION_sequence::iterator OPTION_iterator; + typedef OPTION_sequence::const_iterator OPTION_const_iterator; + typedef ::xsd::cxx::tree::traits< OPTION_type, char > OPTION_traits; + + const OPTION_sequence& + OPTION () const; + + OPTION_sequence& + OPTION (); + + void + OPTION (const OPTION_sequence& s); + + // ID + // + typedef ::xml_schema::id ID_type; + typedef ::xsd::cxx::tree::optional< ID_type > ID_optional; + typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits; + + const ID_optional& + ID () const; + + ID_optional& + ID (); + + void + ID (const ID_type& x); + + void + ID (const ID_optional& x); + + void + ID (::std::auto_ptr< ID_type > p); + + // type + // + typedef ::votable_13::type type_type; + typedef ::xsd::cxx::tree::traits< type_type, char > type_traits; + + const type_type& + type () const; + + type_type& + type (); + + void + type (const type_type& x); + + void + type (::std::auto_ptr< type_type > p); + + static const type_type& + type_default_value (); + + // null + // + typedef ::xml_schema::token 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 (); + + void + null (const null_type& x); + + void + null (const null_optional& x); + + void + null (::std::auto_ptr< null_type > p); + + // ref + // + typedef ::xml_schema::idref ref_type; + typedef ::xsd::cxx::tree::optional< ref_type > ref_optional; + typedef ::xsd::cxx::tree::traits< ref_type, char > ref_traits; + + const ref_optional& + ref () const; + + ref_optional& + ref (); + + void + ref (const ref_type& x); + + void + ref (const ref_optional& x); + + void + ref (::std::auto_ptr< ref_type > p); + + // Constructors. + // + VALUES (); + + VALUES (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + VALUES (const VALUES& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual VALUES* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~VALUES (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + MIN_optional MIN_; + MAX_optional MAX_; + OPTION_sequence OPTION_; + ID_optional ID_; + ::xsd::cxx::tree::one< type_type > type_; + static const type_type type_default_value_; + null_optional null_; + ref_optional ref_; + }; + + class LINK: public ::xml_schema::type + { + public: + // ID + // + typedef ::xml_schema::id ID_type; + typedef ::xsd::cxx::tree::optional< ID_type > ID_optional; + typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits; + + const ID_optional& + ID () const; + + ID_optional& + ID (); + + void + ID (const ID_type& x); + + void + ID (const ID_optional& x); + + void + ID (::std::auto_ptr< ID_type > p); + + // content-role + // + typedef ::xml_schema::token content_role_type; + typedef ::xsd::cxx::tree::optional< content_role_type > content_role_optional; + typedef ::xsd::cxx::tree::traits< content_role_type, char > content_role_traits; + + const content_role_optional& + content_role () const; + + content_role_optional& + content_role (); + + void + content_role (const content_role_type& x); + + void + content_role (const content_role_optional& x); + + void + content_role (::std::auto_ptr< content_role_type > p); + + // content-type + // + typedef ::xml_schema::token content_type_type; + typedef ::xsd::cxx::tree::optional< content_type_type > content_type_optional; + typedef ::xsd::cxx::tree::traits< content_type_type, char > content_type_traits; + + const content_type_optional& + content_type () const; + + content_type_optional& + content_type (); + + void + content_type (const content_type_type& x); + + void + content_type (const content_type_optional& x); + + void + content_type (::std::auto_ptr< content_type_type > p); + + // title + // + typedef ::xml_schema::string title_type; + typedef ::xsd::cxx::tree::optional< title_type > title_optional; + typedef ::xsd::cxx::tree::traits< title_type, char > title_traits; + + const title_optional& + title () const; + + title_optional& + title (); + + void + title (const title_type& x); + + void + title (const title_optional& x); + + void + title (::std::auto_ptr< title_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 (); + + void + value (const value_type& x); + + void + value (const value_optional& x); + + void + value (::std::auto_ptr< value_type > p); + + // href + // + typedef ::xml_schema::uri href_type; + typedef ::xsd::cxx::tree::optional< href_type > href_optional; + typedef ::xsd::cxx::tree::traits< href_type, char > href_traits; + + const href_optional& + href () const; + + href_optional& + href (); + + void + href (const href_type& x); + + void + href (const href_optional& x); + + void + href (::std::auto_ptr< href_type > p); + + // gref + // + typedef ::xml_schema::token gref_type; + typedef ::xsd::cxx::tree::optional< gref_type > gref_optional; + typedef ::xsd::cxx::tree::traits< gref_type, char > gref_traits; + + const gref_optional& + gref () const; + + gref_optional& + gref (); + + void + gref (const gref_type& x); + + void + gref (const gref_optional& x); + + void + gref (::std::auto_ptr< gref_type > p); + + // action + // + typedef ::xml_schema::uri action_type; + typedef ::xsd::cxx::tree::optional< action_type > action_optional; + typedef ::xsd::cxx::tree::traits< action_type, char > action_traits; + + const action_optional& + action () const; + + action_optional& + action (); + + void + action (const action_type& x); + + void + action (const action_optional& x); + + void + action (::std::auto_ptr< action_type > p); + + // Constructors. + // + LINK (); + + LINK (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + LINK (const LINK& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual LINK* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~LINK (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + ID_optional ID_; + content_role_optional content_role_; + content_type_optional content_type_; + title_optional title_; + value_optional value_; + href_optional href_; + gref_optional gref_; + action_optional action_; + }; + + class INFO: public ::xml_schema::string + { + public: + // ID + // + typedef ::xml_schema::id ID_type; + typedef ::xsd::cxx::tree::optional< ID_type > ID_optional; + typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits; + + const ID_optional& + ID () const; + + ID_optional& + ID (); + + void + ID (const ID_type& x); + + void + ID (const ID_optional& x); + + void + ID (::std::auto_ptr< ID_type > p); + + // name + // + typedef ::xml_schema::token name_type; + typedef ::xsd::cxx::tree::traits< name_type, char > name_traits; + + const name_type& + name () const; + + name_type& + name (); + + void + name (const name_type& x); + + void + name (::std::auto_ptr< name_type > p); + + // value + // + typedef ::xml_schema::string value_type; + typedef ::xsd::cxx::tree::traits< value_type, char > value_traits; + + const value_type& + value () const; + + value_type& + value (); + + void + value (const value_type& x); + + void + value (::std::auto_ptr< value_type > p); + + // unit + // + typedef ::xml_schema::token unit_type; + typedef ::xsd::cxx::tree::optional< unit_type > unit_optional; + typedef ::xsd::cxx::tree::traits< unit_type, char > unit_traits; + + const unit_optional& + unit () const; + + unit_optional& + unit (); + + void + unit (const unit_type& x); + + void + unit (const unit_optional& x); + + void + unit (::std::auto_ptr< unit_type > p); + + // xtype + // + typedef ::xml_schema::token xtype_type; + typedef ::xsd::cxx::tree::optional< xtype_type > xtype_optional; + typedef ::xsd::cxx::tree::traits< xtype_type, char > xtype_traits; + + const xtype_optional& + xtype () const; + + xtype_optional& + xtype (); + + void + xtype (const xtype_type& x); + + void + xtype (const xtype_optional& x); + + void + xtype (::std::auto_ptr< xtype_type > p); + + // ref + // + typedef ::xml_schema::idref ref_type; + typedef ::xsd::cxx::tree::optional< ref_type > ref_optional; + typedef ::xsd::cxx::tree::traits< ref_type, char > ref_traits; + + const ref_optional& + ref () const; + + ref_optional& + ref (); + + void + ref (const ref_type& x); + + void + ref (const ref_optional& x); + + void + ref (::std::auto_ptr< ref_type > p); + + // ucd + // + typedef ::votable_13::ucdType ucd_type; + typedef ::xsd::cxx::tree::optional< ucd_type > ucd_optional; + typedef ::xsd::cxx::tree::traits< ucd_type, char > ucd_traits; + + const ucd_optional& + ucd () const; + + ucd_optional& + ucd (); + + void + ucd (const ucd_type& x); + + void + ucd (const ucd_optional& x); + + void + ucd (::std::auto_ptr< ucd_type > p); + + // utype + // + typedef ::xml_schema::string utype_type; + typedef ::xsd::cxx::tree::optional< utype_type > utype_optional; + typedef ::xsd::cxx::tree::traits< utype_type, char > utype_traits; + + const utype_optional& + utype () const; + + utype_optional& + utype (); + + void + utype (const utype_type& x); + + void + utype (const utype_optional& x); + + void + utype (::std::auto_ptr< utype_type > p); + + // Constructors. + // + INFO (const name_type&, + const value_type&); + + INFO (const char*, + const name_type&, + const value_type&); + + INFO (const ::std::string&, + const name_type&, + const value_type&); + + INFO (const ::xml_schema::string&, + const name_type&, + const value_type&); + + INFO (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + INFO (const INFO& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual INFO* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~INFO (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + ID_optional ID_; + ::xsd::cxx::tree::one< name_type > name_; + ::xsd::cxx::tree::one< value_type > value_; + unit_optional unit_; + xtype_optional xtype_; + ref_optional ref_; + ucd_optional ucd_; + utype_optional utype_; + }; + + class COOSYS: public ::xml_schema::string + { + public: + // ID + // + typedef ::xml_schema::id ID_type; + typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits; + + const ID_type& + ID () const; + + ID_type& + ID (); + + void + ID (const ID_type& x); + + void + ID (::std::auto_ptr< ID_type > p); + + // equinox + // + typedef ::votable_13::astroYear equinox_type; + typedef ::xsd::cxx::tree::optional< equinox_type > equinox_optional; + typedef ::xsd::cxx::tree::traits< equinox_type, char > equinox_traits; + + const equinox_optional& + equinox () const; + + equinox_optional& + equinox (); + + void + equinox (const equinox_type& x); + + void + equinox (const equinox_optional& x); + + void + equinox (::std::auto_ptr< equinox_type > p); + + // epoch + // + typedef ::votable_13::astroYear epoch_type; + typedef ::xsd::cxx::tree::optional< epoch_type > epoch_optional; + typedef ::xsd::cxx::tree::traits< epoch_type, char > epoch_traits; + + const epoch_optional& + epoch () const; + + epoch_optional& + epoch (); + + void + epoch (const epoch_type& x); + + void + epoch (const epoch_optional& x); + + void + epoch (::std::auto_ptr< epoch_type > p); + + // system + // + typedef ::votable_13::system system_type; + typedef ::xsd::cxx::tree::traits< system_type, char > system_traits; + + const system_type& + system () const; + + system_type& + system (); + + void + system (const system_type& x); + + void + system (::std::auto_ptr< system_type > p); + + static const system_type& + system_default_value (); + + // Constructors. + // + COOSYS (const ID_type&); + + COOSYS (const char*, + const ID_type&); + + COOSYS (const ::std::string&, + const ID_type&); + + COOSYS (const ::xml_schema::string&, + const ID_type&); + + COOSYS (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + COOSYS (const COOSYS& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual COOSYS* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~COOSYS (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + ::xsd::cxx::tree::one< ID_type > ID_; + equinox_optional equinox_; + epoch_optional epoch_; + ::xsd::cxx::tree::one< system_type > system_; + static const system_type system_default_value_; + }; + + class DEFINITIONS: public ::xml_schema::type + { + public: + // COOSYS + // + typedef ::votable_13::COOSYS COOSYS_type; + typedef ::xsd::cxx::tree::sequence< COOSYS_type > COOSYS_sequence; + typedef COOSYS_sequence::iterator COOSYS_iterator; + typedef COOSYS_sequence::const_iterator COOSYS_const_iterator; + typedef ::xsd::cxx::tree::traits< COOSYS_type, char > COOSYS_traits; + + const COOSYS_sequence& + COOSYS () const; + + COOSYS_sequence& + COOSYS (); + + void + COOSYS (const COOSYS_sequence& s); + + // PARAM + // + typedef ::votable_13::PARAM PARAM_type; + typedef ::xsd::cxx::tree::sequence< PARAM_type > PARAM_sequence; + typedef PARAM_sequence::iterator PARAM_iterator; + typedef PARAM_sequence::const_iterator PARAM_const_iterator; + typedef ::xsd::cxx::tree::traits< PARAM_type, char > PARAM_traits; + + const PARAM_sequence& + PARAM () const; + + PARAM_sequence& + PARAM (); + + void + PARAM (const PARAM_sequence& s); + + // Constructors. + // + DEFINITIONS (); + + DEFINITIONS (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + DEFINITIONS (const DEFINITIONS& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual DEFINITIONS* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~DEFINITIONS (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + COOSYS_sequence COOSYS_; + PARAM_sequence PARAM_; + }; + + class FIELD: public ::xml_schema::type + { + public: + // DESCRIPTION + // + typedef ::votable_13::anyTEXT DESCRIPTION_type; + typedef ::xsd::cxx::tree::optional< DESCRIPTION_type > DESCRIPTION_optional; + typedef ::xsd::cxx::tree::traits< DESCRIPTION_type, char > DESCRIPTION_traits; + + const DESCRIPTION_optional& + DESCRIPTION () const; + + DESCRIPTION_optional& + DESCRIPTION (); + + void + DESCRIPTION (const DESCRIPTION_type& x); + + void + DESCRIPTION (const DESCRIPTION_optional& x); + + void + DESCRIPTION (::std::auto_ptr< DESCRIPTION_type > p); + + // VALUES + // + typedef ::votable_13::VALUES VALUES_type; + typedef ::xsd::cxx::tree::optional< VALUES_type > VALUES_optional; + typedef ::xsd::cxx::tree::traits< VALUES_type, char > VALUES_traits; + + const VALUES_optional& + VALUES () const; + + VALUES_optional& + VALUES (); + + void + VALUES (const VALUES_type& x); + + void + VALUES (const VALUES_optional& x); + + void + VALUES (::std::auto_ptr< VALUES_type > p); + + // LINK + // + typedef ::votable_13::LINK LINK_type; + typedef ::xsd::cxx::tree::sequence< LINK_type > LINK_sequence; + typedef LINK_sequence::iterator LINK_iterator; + typedef LINK_sequence::const_iterator LINK_const_iterator; + typedef ::xsd::cxx::tree::traits< LINK_type, char > LINK_traits; + + const LINK_sequence& + LINK () const; + + LINK_sequence& + LINK (); + + void + LINK (const LINK_sequence& s); + + // ID + // + typedef ::xml_schema::id ID_type; + typedef ::xsd::cxx::tree::optional< ID_type > ID_optional; + typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits; + + const ID_optional& + ID () const; + + ID_optional& + ID (); + + void + ID (const ID_type& x); + + void + ID (const ID_optional& x); + + void + ID (::std::auto_ptr< ID_type > p); + + // unit + // + typedef ::xml_schema::token unit_type; + typedef ::xsd::cxx::tree::optional< unit_type > unit_optional; + typedef ::xsd::cxx::tree::traits< unit_type, char > unit_traits; + + const unit_optional& + unit () const; + + unit_optional& + unit (); + + void + unit (const unit_type& x); + + void + unit (const unit_optional& x); + + void + unit (::std::auto_ptr< unit_type > p); + + // datatype + // + typedef ::votable_13::dataType datatype_type; + typedef ::xsd::cxx::tree::optional< datatype_type > datatype_optional; + typedef ::xsd::cxx::tree::traits< datatype_type, char > datatype_traits; + + const datatype_optional& + datatype () const; + + datatype_optional& + datatype (); + + void + datatype (const datatype_type& x); + + void + datatype (const datatype_optional& x); + + void + datatype (::std::auto_ptr< datatype_type > p); + + // precision + // + typedef ::votable_13::precType precision_type; + typedef ::xsd::cxx::tree::optional< precision_type > precision_optional; + typedef ::xsd::cxx::tree::traits< precision_type, char > precision_traits; + + const precision_optional& + precision () const; + + precision_optional& + precision (); + + void + precision (const precision_type& x); + + void + precision (const precision_optional& x); + + void + precision (::std::auto_ptr< precision_type > p); + + // width + // + typedef ::xml_schema::positive_integer width_type; + typedef ::xsd::cxx::tree::optional< width_type > width_optional; + typedef ::xsd::cxx::tree::traits< width_type, char > width_traits; + + const width_optional& + width () const; + + width_optional& + width (); + + void + width (const width_type& x); + + void + width (const width_optional& x); + + // xtype + // + typedef ::xml_schema::token xtype_type; + typedef ::xsd::cxx::tree::optional< xtype_type > xtype_optional; + typedef ::xsd::cxx::tree::traits< xtype_type, char > xtype_traits; + + const xtype_optional& + xtype () const; + + xtype_optional& + xtype (); + + void + xtype (const xtype_type& x); + + void + xtype (const xtype_optional& x); + + void + xtype (::std::auto_ptr< xtype_type > p); + + // ref + // + typedef ::xml_schema::idref ref_type; + typedef ::xsd::cxx::tree::optional< ref_type > ref_optional; + typedef ::xsd::cxx::tree::traits< ref_type, char > ref_traits; + + const ref_optional& + ref () const; + + ref_optional& + ref (); + + void + ref (const ref_type& x); + + void + ref (const ref_optional& x); + + void + ref (::std::auto_ptr< ref_type > p); + + // name + // + typedef ::xml_schema::token name_type; + typedef ::xsd::cxx::tree::optional< name_type > name_optional; + typedef ::xsd::cxx::tree::traits< name_type, char > name_traits; + + const name_optional& + name () const; + + name_optional& + name (); + + void + name (const name_type& x); + + void + name (const name_optional& x); + + void + name (::std::auto_ptr< name_type > p); + + // ucd + // + typedef ::votable_13::ucdType ucd_type; + typedef ::xsd::cxx::tree::optional< ucd_type > ucd_optional; + typedef ::xsd::cxx::tree::traits< ucd_type, char > ucd_traits; + + const ucd_optional& + ucd () const; + + ucd_optional& + ucd (); + + void + ucd (const ucd_type& x); + + void + ucd (const ucd_optional& x); + + void + ucd (::std::auto_ptr< ucd_type > p); + + // utype + // + typedef ::xml_schema::string utype_type; + typedef ::xsd::cxx::tree::optional< utype_type > utype_optional; + typedef ::xsd::cxx::tree::traits< utype_type, char > utype_traits; + + const utype_optional& + utype () const; + + utype_optional& + utype (); + + void + utype (const utype_type& x); + + void + utype (const utype_optional& x); + + void + utype (::std::auto_ptr< utype_type > p); + + // arraysize + // + typedef ::xml_schema::string arraysize_type; + typedef ::xsd::cxx::tree::optional< arraysize_type > arraysize_optional; + typedef ::xsd::cxx::tree::traits< arraysize_type, char > arraysize_traits; + + const arraysize_optional& + arraysize () const; + + arraysize_optional& + arraysize (); + + void + arraysize (const arraysize_type& x); + + void + arraysize (const arraysize_optional& x); + + void + arraysize (::std::auto_ptr< arraysize_type > p); + + // type + // + typedef ::votable_13::type1 type_type; + typedef ::xsd::cxx::tree::optional< type_type > type_optional; + typedef ::xsd::cxx::tree::traits< type_type, char > type_traits; + + const type_optional& + type () const; + + type_optional& + type (); + + void + type (const type_type& x); + + void + type (const type_optional& x); + + void + type (::std::auto_ptr< type_type > p); + + // Constructors. + // + FIELD (); + + FIELD (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + FIELD (const FIELD& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual FIELD* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~FIELD (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + DESCRIPTION_optional DESCRIPTION_; + VALUES_optional VALUES_; + LINK_sequence LINK_; + ID_optional ID_; + unit_optional unit_; + datatype_optional datatype_; + precision_optional precision_; + width_optional width_; + xtype_optional xtype_; + ref_optional ref_; + name_optional name_; + ucd_optional ucd_; + utype_optional utype_; + arraysize_optional arraysize_; + type_optional type_; + }; + + class PARAM: public ::votable_13::FIELD + { + public: + // 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 (); + + void + value (const value_type& x); + + void + value (const value_optional& x); + + void + value (::std::auto_ptr< value_type > p); + + // Constructors. + // + PARAM (); + + PARAM (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + PARAM (const PARAM& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual PARAM* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~PARAM (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + value_optional value_; + }; + + class GROUP: public ::xml_schema::type + { + public: + // DESCRIPTION + // + typedef ::votable_13::anyTEXT DESCRIPTION_type; + typedef ::xsd::cxx::tree::optional< DESCRIPTION_type > DESCRIPTION_optional; + typedef ::xsd::cxx::tree::traits< DESCRIPTION_type, char > DESCRIPTION_traits; + + const DESCRIPTION_optional& + DESCRIPTION () const; + + DESCRIPTION_optional& + DESCRIPTION (); + + void + DESCRIPTION (const DESCRIPTION_type& x); + + void + DESCRIPTION (const DESCRIPTION_optional& x); + + void + DESCRIPTION (::std::auto_ptr< DESCRIPTION_type > p); + + // FIELDref + // + typedef ::votable_13::FIELDref FIELDref_type; + typedef ::xsd::cxx::tree::sequence< FIELDref_type > FIELDref_sequence; + typedef FIELDref_sequence::iterator FIELDref_iterator; + typedef FIELDref_sequence::const_iterator FIELDref_const_iterator; + typedef ::xsd::cxx::tree::traits< FIELDref_type, char > FIELDref_traits; + + const FIELDref_sequence& + FIELDref () const; + + FIELDref_sequence& + FIELDref (); + + void + FIELDref (const FIELDref_sequence& s); + + // PARAMref + // + typedef ::votable_13::PARAMref PARAMref_type; + typedef ::xsd::cxx::tree::sequence< PARAMref_type > PARAMref_sequence; + typedef PARAMref_sequence::iterator PARAMref_iterator; + typedef PARAMref_sequence::const_iterator PARAMref_const_iterator; + typedef ::xsd::cxx::tree::traits< PARAMref_type, char > PARAMref_traits; + + const PARAMref_sequence& + PARAMref () const; + + PARAMref_sequence& + PARAMref (); + + void + PARAMref (const PARAMref_sequence& s); + + // PARAM + // + typedef ::votable_13::PARAM PARAM_type; + typedef ::xsd::cxx::tree::sequence< PARAM_type > PARAM_sequence; + typedef PARAM_sequence::iterator PARAM_iterator; + typedef PARAM_sequence::const_iterator PARAM_const_iterator; + typedef ::xsd::cxx::tree::traits< PARAM_type, char > PARAM_traits; + + const PARAM_sequence& + PARAM () const; + + PARAM_sequence& + PARAM (); + + void + PARAM (const PARAM_sequence& s); + + // GROUP + // + typedef ::votable_13::GROUP GROUP1_type; + typedef ::xsd::cxx::tree::sequence< GROUP1_type > GROUP1_sequence; + typedef GROUP1_sequence::iterator GROUP1_iterator; + typedef GROUP1_sequence::const_iterator GROUP1_const_iterator; + typedef ::xsd::cxx::tree::traits< GROUP1_type, char > GROUP1_traits; + + const GROUP1_sequence& + GROUP1 () const; + + GROUP1_sequence& + GROUP1 (); + + void + GROUP1 (const GROUP1_sequence& s); + + // ID + // + typedef ::xml_schema::id ID_type; + typedef ::xsd::cxx::tree::optional< ID_type > ID_optional; + typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits; + + const ID_optional& + ID () const; + + ID_optional& + ID (); + + void + ID (const ID_type& x); + + void + ID (const ID_optional& x); + + void + ID (::std::auto_ptr< ID_type > p); + + // name + // + typedef ::xml_schema::token name_type; + typedef ::xsd::cxx::tree::optional< name_type > name_optional; + typedef ::xsd::cxx::tree::traits< name_type, char > name_traits; + + const name_optional& + name () const; + + name_optional& + name (); + + void + name (const name_type& x); + + void + name (const name_optional& x); + + void + name (::std::auto_ptr< name_type > p); + + // ref + // + typedef ::xml_schema::idref ref_type; + typedef ::xsd::cxx::tree::optional< ref_type > ref_optional; + typedef ::xsd::cxx::tree::traits< ref_type, char > ref_traits; + + const ref_optional& + ref () const; + + ref_optional& + ref (); + + void + ref (const ref_type& x); + + void + ref (const ref_optional& x); + + void + ref (::std::auto_ptr< ref_type > p); + + // ucd + // + typedef ::votable_13::ucdType ucd_type; + typedef ::xsd::cxx::tree::optional< ucd_type > ucd_optional; + typedef ::xsd::cxx::tree::traits< ucd_type, char > ucd_traits; + + const ucd_optional& + ucd () const; + + ucd_optional& + ucd (); + + void + ucd (const ucd_type& x); + + void + ucd (const ucd_optional& x); + + void + ucd (::std::auto_ptr< ucd_type > p); + + // utype + // + typedef ::xml_schema::string utype_type; + typedef ::xsd::cxx::tree::optional< utype_type > utype_optional; + typedef ::xsd::cxx::tree::traits< utype_type, char > utype_traits; + + const utype_optional& + utype () const; + + utype_optional& + utype (); + + void + utype (const utype_type& x); + + void + utype (const utype_optional& x); + + void + utype (::std::auto_ptr< utype_type > p); + + // Constructors. + // + GROUP (); + + GROUP (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + GROUP (const GROUP& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual GROUP* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~GROUP (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + DESCRIPTION_optional DESCRIPTION_; + FIELDref_sequence FIELDref_; + PARAMref_sequence PARAMref_; + PARAM_sequence PARAM_; + GROUP1_sequence GROUP1_; + ID_optional ID_; + name_optional name_; + ref_optional ref_; + ucd_optional ucd_; + utype_optional utype_; + }; + + class FIELDref: public ::xml_schema::type + { + public: + // ref + // + typedef ::xml_schema::idref ref_type; + typedef ::xsd::cxx::tree::traits< ref_type, char > ref_traits; + + const ref_type& + ref () const; + + ref_type& + ref (); + + void + ref (const ref_type& x); + + void + ref (::std::auto_ptr< ref_type > p); + + // ucd + // + typedef ::votable_13::ucdType ucd_type; + typedef ::xsd::cxx::tree::optional< ucd_type > ucd_optional; + typedef ::xsd::cxx::tree::traits< ucd_type, char > ucd_traits; + + const ucd_optional& + ucd () const; + + ucd_optional& + ucd (); + + void + ucd (const ucd_type& x); + + void + ucd (const ucd_optional& x); + + void + ucd (::std::auto_ptr< ucd_type > p); + + // utype + // + typedef ::xml_schema::string utype_type; + typedef ::xsd::cxx::tree::optional< utype_type > utype_optional; + typedef ::xsd::cxx::tree::traits< utype_type, char > utype_traits; + + const utype_optional& + utype () const; + + utype_optional& + utype (); + + void + utype (const utype_type& x); + + void + utype (const utype_optional& x); + + void + utype (::std::auto_ptr< utype_type > p); + + // Constructors. + // + FIELDref (const ref_type&); + + FIELDref (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + FIELDref (const FIELDref& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual FIELDref* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~FIELDref (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + ::xsd::cxx::tree::one< ref_type > ref_; + ucd_optional ucd_; + utype_optional utype_; + }; + + class PARAMref: public ::xml_schema::type + { + public: + // ref + // + typedef ::xml_schema::idref ref_type; + typedef ::xsd::cxx::tree::traits< ref_type, char > ref_traits; + + const ref_type& + ref () const; + + ref_type& + ref (); + + void + ref (const ref_type& x); + + void + ref (::std::auto_ptr< ref_type > p); + + // ucd + // + typedef ::votable_13::ucdType ucd_type; + typedef ::xsd::cxx::tree::optional< ucd_type > ucd_optional; + typedef ::xsd::cxx::tree::traits< ucd_type, char > ucd_traits; + + const ucd_optional& + ucd () const; + + ucd_optional& + ucd (); + + void + ucd (const ucd_type& x); + + void + ucd (const ucd_optional& x); + + void + ucd (::std::auto_ptr< ucd_type > p); + + // utype + // + typedef ::xml_schema::string utype_type; + typedef ::xsd::cxx::tree::optional< utype_type > utype_optional; + typedef ::xsd::cxx::tree::traits< utype_type, char > utype_traits; + + const utype_optional& + utype () const; + + utype_optional& + utype (); + + void + utype (const utype_type& x); + + void + utype (const utype_optional& x); + + void + utype (::std::auto_ptr< utype_type > p); + + // Constructors. + // + PARAMref (const ref_type&); + + PARAMref (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + PARAMref (const PARAMref& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual PARAMref* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~PARAMref (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + ::xsd::cxx::tree::one< ref_type > ref_; + ucd_optional ucd_; + utype_optional utype_; + }; + + class DATA: public ::xml_schema::type + { + public: + // TABLEDATA + // + typedef ::votable_13::TABLEDATA TABLEDATA_type; + typedef ::xsd::cxx::tree::optional< TABLEDATA_type > TABLEDATA_optional; + typedef ::xsd::cxx::tree::traits< TABLEDATA_type, char > TABLEDATA_traits; + + const TABLEDATA_optional& + TABLEDATA () const; + + TABLEDATA_optional& + TABLEDATA (); + + void + TABLEDATA (const TABLEDATA_type& x); + + void + TABLEDATA (const TABLEDATA_optional& x); + + void + TABLEDATA (::std::auto_ptr< TABLEDATA_type > p); + + // BINARY + // + typedef ::votable_13::BINARY BINARY_type; + typedef ::xsd::cxx::tree::optional< BINARY_type > BINARY_optional; + typedef ::xsd::cxx::tree::traits< BINARY_type, char > BINARY_traits; + + const BINARY_optional& + BINARY () const; + + BINARY_optional& + BINARY (); + + void + BINARY (const BINARY_type& x); + + void + BINARY (const BINARY_optional& x); + + void + BINARY (::std::auto_ptr< BINARY_type > p); + + // BINARY2 + // + typedef ::votable_13::BINARY2 BINARY2_type; + typedef ::xsd::cxx::tree::optional< BINARY2_type > BINARY2_optional; + typedef ::xsd::cxx::tree::traits< BINARY2_type, char > BINARY2_traits; + + const BINARY2_optional& + BINARY2 () const; + + BINARY2_optional& + BINARY2 (); + + void + BINARY2 (const BINARY2_type& x); + + void + BINARY2 (const BINARY2_optional& x); + + void + BINARY2 (::std::auto_ptr< BINARY2_type > p); + + // FITS + // + typedef ::votable_13::FITS FITS_type; + typedef ::xsd::cxx::tree::optional< FITS_type > FITS_optional; + typedef ::xsd::cxx::tree::traits< FITS_type, char > FITS_traits; + + const FITS_optional& + FITS () const; + + FITS_optional& + FITS (); + + void + FITS (const FITS_type& x); + + void + FITS (const FITS_optional& x); + + void + FITS (::std::auto_ptr< FITS_type > p); + + // INFO + // + typedef ::votable_13::INFO INFO_type; + typedef ::xsd::cxx::tree::sequence< INFO_type > INFO_sequence; + typedef INFO_sequence::iterator INFO_iterator; + typedef INFO_sequence::const_iterator INFO_const_iterator; + typedef ::xsd::cxx::tree::traits< INFO_type, char > INFO_traits; + + const INFO_sequence& + INFO () const; + + INFO_sequence& + INFO (); + + void + INFO (const INFO_sequence& s); + + // Constructors. + // + DATA (); + + DATA (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + DATA (const DATA& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual DATA* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~DATA (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + TABLEDATA_optional TABLEDATA_; + BINARY_optional BINARY_; + BINARY2_optional BINARY2_; + FITS_optional FITS_; + INFO_sequence INFO_; + }; + + class TABLEDATA: public ::xml_schema::type + { + public: + // TR + // + typedef ::votable_13::TR TR_type; + typedef ::xsd::cxx::tree::sequence< TR_type > TR_sequence; + typedef TR_sequence::iterator TR_iterator; + typedef TR_sequence::const_iterator TR_const_iterator; + typedef ::xsd::cxx::tree::traits< TR_type, char > TR_traits; + + const TR_sequence& + TR () const; + + TR_sequence& + TR (); + + void + TR (const TR_sequence& s); + + // Constructors. + // + TABLEDATA (); + + TABLEDATA (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + TABLEDATA (const TABLEDATA& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual TABLEDATA* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~TABLEDATA (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + TR_sequence TR_; + }; + + class TD: public ::xml_schema::string + { + public: + // encoding + // + typedef ::votable_13::encodingType encoding_type; + typedef ::xsd::cxx::tree::optional< encoding_type > encoding_optional; + typedef ::xsd::cxx::tree::traits< encoding_type, char > encoding_traits; + + const encoding_optional& + encoding () const; + + encoding_optional& + encoding (); + + void + encoding (const encoding_type& x); + + void + encoding (const encoding_optional& x); + + void + encoding (::std::auto_ptr< encoding_type > p); + + // Constructors. + // + TD (); + + TD (const char*); + + TD (const ::std::string&); + + TD (const ::xml_schema::string&); + + TD (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + TD (const TD& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual TD* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~TD (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + encoding_optional encoding_; + }; + + class TR: public ::xml_schema::type + { + public: + // TD + // + typedef ::votable_13::TD TD_type; + typedef ::xsd::cxx::tree::sequence< TD_type > TD_sequence; + typedef TD_sequence::iterator TD_iterator; + typedef TD_sequence::const_iterator TD_const_iterator; + typedef ::xsd::cxx::tree::traits< TD_type, char > TD_traits; + + const TD_sequence& + TD () const; + + TD_sequence& + TD (); + + void + TD (const TD_sequence& s); + + // ID + // + typedef ::xml_schema::id ID_type; + typedef ::xsd::cxx::tree::optional< ID_type > ID_optional; + typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits; + + const ID_optional& + ID () const; + + ID_optional& + ID (); + + void + ID (const ID_type& x); + + void + ID (const ID_optional& x); + + void + ID (::std::auto_ptr< ID_type > p); + + // Constructors. + // + TR (); + + TR (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + TR (const TR& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual TR* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~TR (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + TD_sequence TD_; + ID_optional ID_; + }; + + class FITS: public ::xml_schema::type + { + public: + // STREAM + // + typedef ::votable_13::STREAM STREAM_type; + typedef ::xsd::cxx::tree::traits< STREAM_type, char > STREAM_traits; + + const STREAM_type& + STREAM () const; + + STREAM_type& + STREAM (); + + void + STREAM (const STREAM_type& x); + + void + STREAM (::std::auto_ptr< STREAM_type > p); + + // extnum + // + typedef ::xml_schema::positive_integer extnum_type; + typedef ::xsd::cxx::tree::optional< extnum_type > extnum_optional; + typedef ::xsd::cxx::tree::traits< extnum_type, char > extnum_traits; + + const extnum_optional& + extnum () const; + + extnum_optional& + extnum (); + + void + extnum (const extnum_type& x); + + void + extnum (const extnum_optional& x); + + // Constructors. + // + FITS (const STREAM_type&); + + FITS (::std::auto_ptr< STREAM_type >&); + + FITS (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + FITS (const FITS& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual FITS* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~FITS (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + ::xsd::cxx::tree::one< STREAM_type > STREAM_; + extnum_optional extnum_; + }; + + class BINARY: public ::xml_schema::type + { + public: + // STREAM + // + typedef ::votable_13::STREAM STREAM_type; + typedef ::xsd::cxx::tree::traits< STREAM_type, char > STREAM_traits; + + const STREAM_type& + STREAM () const; + + STREAM_type& + STREAM (); + + void + STREAM (const STREAM_type& x); + + void + STREAM (::std::auto_ptr< STREAM_type > p); + + // Constructors. + // + BINARY (const STREAM_type&); + + BINARY (::std::auto_ptr< STREAM_type >&); + + BINARY (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + BINARY (const BINARY& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual BINARY* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~BINARY (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + ::xsd::cxx::tree::one< STREAM_type > STREAM_; + }; + + class BINARY2: public ::xml_schema::type + { + public: + // STREAM + // + typedef ::votable_13::STREAM STREAM_type; + typedef ::xsd::cxx::tree::traits< STREAM_type, char > STREAM_traits; + + const STREAM_type& + STREAM () const; + + STREAM_type& + STREAM (); + + void + STREAM (const STREAM_type& x); + + void + STREAM (::std::auto_ptr< STREAM_type > p); + + // Constructors. + // + BINARY2 (const STREAM_type&); + + BINARY2 (::std::auto_ptr< STREAM_type >&); + + BINARY2 (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + BINARY2 (const BINARY2& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual BINARY2* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~BINARY2 (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + ::xsd::cxx::tree::one< STREAM_type > STREAM_; + }; + + class STREAM: public ::xml_schema::string + { + public: + // type + // + typedef ::votable_13::type2 type_type; + typedef ::xsd::cxx::tree::traits< type_type, char > type_traits; + + const type_type& + type () const; + + type_type& + type (); + + void + type (const type_type& x); + + void + type (::std::auto_ptr< type_type > p); + + static const type_type& + type_default_value (); + + // href + // + typedef ::xml_schema::uri href_type; + typedef ::xsd::cxx::tree::optional< href_type > href_optional; + typedef ::xsd::cxx::tree::traits< href_type, char > href_traits; + + const href_optional& + href () const; + + href_optional& + href (); + + void + href (const href_type& x); + + void + href (const href_optional& x); + + void + href (::std::auto_ptr< href_type > p); + + // actuate + // + typedef ::votable_13::actuate actuate_type; + typedef ::xsd::cxx::tree::traits< actuate_type, char > actuate_traits; + + const actuate_type& + actuate () const; + + actuate_type& + actuate (); + + void + actuate (const actuate_type& x); + + void + actuate (::std::auto_ptr< actuate_type > p); + + static const actuate_type& + actuate_default_value (); + + // encoding + // + typedef ::votable_13::encodingType encoding_type; + typedef ::xsd::cxx::tree::traits< encoding_type, char > encoding_traits; + + const encoding_type& + encoding () const; + + encoding_type& + encoding (); + + void + encoding (const encoding_type& x); + + void + encoding (::std::auto_ptr< encoding_type > p); + + static const encoding_type& + encoding_default_value (); + + // expires + // + typedef ::xml_schema::date_time expires_type; + typedef ::xsd::cxx::tree::optional< expires_type > expires_optional; + typedef ::xsd::cxx::tree::traits< expires_type, char > expires_traits; + + const expires_optional& + expires () const; + + expires_optional& + expires (); + + void + expires (const expires_type& x); + + void + expires (const expires_optional& x); + + void + expires (::std::auto_ptr< expires_type > p); + + // rights + // + typedef ::xml_schema::token rights_type; + typedef ::xsd::cxx::tree::optional< rights_type > rights_optional; + typedef ::xsd::cxx::tree::traits< rights_type, char > rights_traits; + + const rights_optional& + rights () const; + + rights_optional& + rights (); + + void + rights (const rights_type& x); + + void + rights (const rights_optional& x); + + void + rights (::std::auto_ptr< rights_type > p); + + // Constructors. + // + STREAM (); + + STREAM (const char*); + + STREAM (const ::std::string&); + + STREAM (const ::xml_schema::string&); + + STREAM (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + STREAM (const STREAM& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual STREAM* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~STREAM (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + ::xsd::cxx::tree::one< type_type > type_; + static const type_type type_default_value_; + href_optional href_; + ::xsd::cxx::tree::one< actuate_type > actuate_; + static const actuate_type actuate_default_value_; + ::xsd::cxx::tree::one< encoding_type > encoding_; + static const encoding_type encoding_default_value_; + expires_optional expires_; + rights_optional rights_; + }; + + class TABLE: public ::xml_schema::type + { + public: + // DESCRIPTION + // + typedef ::votable_13::anyTEXT DESCRIPTION_type; + typedef ::xsd::cxx::tree::optional< DESCRIPTION_type > DESCRIPTION_optional; + typedef ::xsd::cxx::tree::traits< DESCRIPTION_type, char > DESCRIPTION_traits; + + const DESCRIPTION_optional& + DESCRIPTION () const; + + DESCRIPTION_optional& + DESCRIPTION (); + + void + DESCRIPTION (const DESCRIPTION_type& x); + + void + DESCRIPTION (const DESCRIPTION_optional& x); + + void + DESCRIPTION (::std::auto_ptr< DESCRIPTION_type > p); + + // INFO + // + typedef ::votable_13::INFO INFO_type; + typedef ::xsd::cxx::tree::sequence< INFO_type > INFO_sequence; + typedef INFO_sequence::iterator INFO_iterator; + typedef INFO_sequence::const_iterator INFO_const_iterator; + typedef ::xsd::cxx::tree::traits< INFO_type, char > INFO_traits; + + const INFO_sequence& + INFO () const; + + INFO_sequence& + INFO (); + + void + INFO (const INFO_sequence& s); + + // FIELD + // + typedef ::votable_13::FIELD FIELD_type; + typedef ::xsd::cxx::tree::sequence< FIELD_type > FIELD_sequence; + typedef FIELD_sequence::iterator FIELD_iterator; + typedef FIELD_sequence::const_iterator FIELD_const_iterator; + typedef ::xsd::cxx::tree::traits< FIELD_type, char > FIELD_traits; + + const FIELD_sequence& + FIELD () const; + + FIELD_sequence& + FIELD (); + + void + FIELD (const FIELD_sequence& s); + + // PARAM + // + typedef ::votable_13::PARAM PARAM_type; + typedef ::xsd::cxx::tree::sequence< PARAM_type > PARAM_sequence; + typedef PARAM_sequence::iterator PARAM_iterator; + typedef PARAM_sequence::const_iterator PARAM_const_iterator; + typedef ::xsd::cxx::tree::traits< PARAM_type, char > PARAM_traits; + + const PARAM_sequence& + PARAM () const; + + PARAM_sequence& + PARAM (); + + void + PARAM (const PARAM_sequence& s); + + // GROUP + // + typedef ::votable_13::GROUP GROUP_type; + typedef ::xsd::cxx::tree::sequence< GROUP_type > GROUP_sequence; + typedef GROUP_sequence::iterator GROUP_iterator; + typedef GROUP_sequence::const_iterator GROUP_const_iterator; + typedef ::xsd::cxx::tree::traits< GROUP_type, char > GROUP_traits; + + const GROUP_sequence& + GROUP () const; + + GROUP_sequence& + GROUP (); + + void + GROUP (const GROUP_sequence& s); + + // LINK + // + typedef ::votable_13::LINK LINK_type; + typedef ::xsd::cxx::tree::sequence< LINK_type > LINK_sequence; + typedef LINK_sequence::iterator LINK_iterator; + typedef LINK_sequence::const_iterator LINK_const_iterator; + typedef ::xsd::cxx::tree::traits< LINK_type, char > LINK_traits; + + const LINK_sequence& + LINK () const; + + LINK_sequence& + LINK (); + + void + LINK (const LINK_sequence& s); + + // DATA + // + typedef ::votable_13::DATA DATA_type; + typedef ::xsd::cxx::tree::optional< DATA_type > DATA_optional; + typedef ::xsd::cxx::tree::traits< DATA_type, char > DATA_traits; + + const DATA_optional& + DATA () const; + + DATA_optional& + DATA (); + + void + DATA (const DATA_type& x); + + void + DATA (const DATA_optional& x); + + void + DATA (::std::auto_ptr< DATA_type > p); + + // ID + // + typedef ::xml_schema::id ID_type; + typedef ::xsd::cxx::tree::optional< ID_type > ID_optional; + typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits; + + const ID_optional& + ID () const; + + ID_optional& + ID (); + + void + ID (const ID_type& x); + + void + ID (const ID_optional& x); + + void + ID (::std::auto_ptr< ID_type > p); + + // name + // + typedef ::xml_schema::token name_type; + typedef ::xsd::cxx::tree::optional< name_type > name_optional; + typedef ::xsd::cxx::tree::traits< name_type, char > name_traits; + + const name_optional& + name () const; + + name_optional& + name (); + + void + name (const name_type& x); + + void + name (const name_optional& x); + + void + name (::std::auto_ptr< name_type > p); + + // ref + // + typedef ::xml_schema::idref ref_type; + typedef ::xsd::cxx::tree::optional< ref_type > ref_optional; + typedef ::xsd::cxx::tree::traits< ref_type, char > ref_traits; + + const ref_optional& + ref () const; + + ref_optional& + ref (); + + void + ref (const ref_type& x); + + void + ref (const ref_optional& x); + + void + ref (::std::auto_ptr< ref_type > p); + + // ucd + // + typedef ::votable_13::ucdType ucd_type; + typedef ::xsd::cxx::tree::optional< ucd_type > ucd_optional; + typedef ::xsd::cxx::tree::traits< ucd_type, char > ucd_traits; + + const ucd_optional& + ucd () const; + + ucd_optional& + ucd (); + + void + ucd (const ucd_type& x); + + void + ucd (const ucd_optional& x); + + void + ucd (::std::auto_ptr< ucd_type > p); + + // utype + // + typedef ::xml_schema::string utype_type; + typedef ::xsd::cxx::tree::optional< utype_type > utype_optional; + typedef ::xsd::cxx::tree::traits< utype_type, char > utype_traits; + + const utype_optional& + utype () const; + + utype_optional& + utype (); + + void + utype (const utype_type& x); + + void + utype (const utype_optional& x); + + void + utype (::std::auto_ptr< utype_type > p); + + // nrows + // + typedef ::xml_schema::non_negative_integer nrows_type; + typedef ::xsd::cxx::tree::optional< nrows_type > nrows_optional; + typedef ::xsd::cxx::tree::traits< nrows_type, char > nrows_traits; + + const nrows_optional& + nrows () const; + + nrows_optional& + nrows (); + + void + nrows (const nrows_type& x); + + void + nrows (const nrows_optional& x); + + // Constructors. + // + TABLE (); + + TABLE (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + TABLE (const TABLE& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual TABLE* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~TABLE (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + DESCRIPTION_optional DESCRIPTION_; + INFO_sequence INFO_; + FIELD_sequence FIELD_; + PARAM_sequence PARAM_; + GROUP_sequence GROUP_; + LINK_sequence LINK_; + DATA_optional DATA_; + ID_optional ID_; + name_optional name_; + ref_optional ref_; + ucd_optional ucd_; + utype_optional utype_; + nrows_optional nrows_; + }; + + class RESOURCE: public ::xml_schema::type + { + public: + // DESCRIPTION + // + typedef ::votable_13::anyTEXT DESCRIPTION_type; + typedef ::xsd::cxx::tree::optional< DESCRIPTION_type > DESCRIPTION_optional; + typedef ::xsd::cxx::tree::traits< DESCRIPTION_type, char > DESCRIPTION_traits; + + const DESCRIPTION_optional& + DESCRIPTION () const; + + DESCRIPTION_optional& + DESCRIPTION (); + + void + DESCRIPTION (const DESCRIPTION_type& x); + + void + DESCRIPTION (const DESCRIPTION_optional& x); + + void + DESCRIPTION (::std::auto_ptr< DESCRIPTION_type > p); + + // INFO + // + typedef ::votable_13::INFO INFO_type; + typedef ::xsd::cxx::tree::sequence< INFO_type > INFO_sequence; + typedef INFO_sequence::iterator INFO_iterator; + typedef INFO_sequence::const_iterator INFO_const_iterator; + typedef ::xsd::cxx::tree::traits< INFO_type, char > INFO_traits; + + const INFO_sequence& + INFO () const; + + INFO_sequence& + INFO (); + + void + INFO (const INFO_sequence& s); + + // COOSYS + // + typedef ::votable_13::COOSYS COOSYS_type; + typedef ::xsd::cxx::tree::sequence< COOSYS_type > COOSYS_sequence; + typedef COOSYS_sequence::iterator COOSYS_iterator; + typedef COOSYS_sequence::const_iterator COOSYS_const_iterator; + typedef ::xsd::cxx::tree::traits< COOSYS_type, char > COOSYS_traits; + + const COOSYS_sequence& + COOSYS () const; + + COOSYS_sequence& + COOSYS (); + + void + COOSYS (const COOSYS_sequence& s); + + // GROUP + // + typedef ::votable_13::GROUP GROUP_type; + typedef ::xsd::cxx::tree::sequence< GROUP_type > GROUP_sequence; + typedef GROUP_sequence::iterator GROUP_iterator; + typedef GROUP_sequence::const_iterator GROUP_const_iterator; + typedef ::xsd::cxx::tree::traits< GROUP_type, char > GROUP_traits; + + const GROUP_sequence& + GROUP () const; + + GROUP_sequence& + GROUP (); + + void + GROUP (const GROUP_sequence& s); + + // PARAM + // + typedef ::votable_13::PARAM PARAM_type; + typedef ::xsd::cxx::tree::sequence< PARAM_type > PARAM_sequence; + typedef PARAM_sequence::iterator PARAM_iterator; + typedef PARAM_sequence::const_iterator PARAM_const_iterator; + typedef ::xsd::cxx::tree::traits< PARAM_type, char > PARAM_traits; + + const PARAM_sequence& + PARAM () const; + + PARAM_sequence& + PARAM (); + + void + PARAM (const PARAM_sequence& s); + + // LINK + // + typedef ::votable_13::LINK LINK_type; + typedef ::xsd::cxx::tree::sequence< LINK_type > LINK_sequence; + typedef LINK_sequence::iterator LINK_iterator; + typedef LINK_sequence::const_iterator LINK_const_iterator; + typedef ::xsd::cxx::tree::traits< LINK_type, char > LINK_traits; + + const LINK_sequence& + LINK () const; + + LINK_sequence& + LINK (); + + void + LINK (const LINK_sequence& s); + + // TABLE + // + typedef ::votable_13::TABLE TABLE_type; + typedef ::xsd::cxx::tree::sequence< TABLE_type > TABLE_sequence; + typedef TABLE_sequence::iterator TABLE_iterator; + typedef TABLE_sequence::const_iterator TABLE_const_iterator; + typedef ::xsd::cxx::tree::traits< TABLE_type, char > TABLE_traits; + + const TABLE_sequence& + TABLE () const; + + TABLE_sequence& + TABLE (); + + void + TABLE (const TABLE_sequence& s); + + // RESOURCE + // + typedef ::votable_13::RESOURCE RESOURCE1_type; + typedef ::xsd::cxx::tree::sequence< RESOURCE1_type > RESOURCE1_sequence; + typedef RESOURCE1_sequence::iterator RESOURCE1_iterator; + typedef RESOURCE1_sequence::const_iterator RESOURCE1_const_iterator; + typedef ::xsd::cxx::tree::traits< RESOURCE1_type, char > RESOURCE1_traits; + + const RESOURCE1_sequence& + RESOURCE1 () const; + + RESOURCE1_sequence& + RESOURCE1 (); + + void + RESOURCE1 (const RESOURCE1_sequence& s); + + // any + // + typedef ::xsd::cxx::tree::element_sequence any_sequence; + typedef any_sequence::iterator any_iterator; + typedef any_sequence::const_iterator any_const_iterator; + + const any_sequence& + any () const; + + any_sequence& + any (); + + void + any (const any_sequence& s); + + // name + // + typedef ::xml_schema::token name_type; + typedef ::xsd::cxx::tree::optional< name_type > name_optional; + typedef ::xsd::cxx::tree::traits< name_type, char > name_traits; + + const name_optional& + name () const; + + name_optional& + name (); + + void + name (const name_type& x); + + void + name (const name_optional& x); + + void + name (::std::auto_ptr< name_type > p); + + // ID + // + typedef ::xml_schema::id ID_type; + typedef ::xsd::cxx::tree::optional< ID_type > ID_optional; + typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits; + + const ID_optional& + ID () const; + + ID_optional& + ID (); + + void + ID (const ID_type& x); + + void + ID (const ID_optional& x); + + void + ID (::std::auto_ptr< ID_type > p); + + // utype + // + typedef ::xml_schema::string utype_type; + typedef ::xsd::cxx::tree::optional< utype_type > utype_optional; + typedef ::xsd::cxx::tree::traits< utype_type, char > utype_traits; + + const utype_optional& + utype () const; + + utype_optional& + utype (); + + void + utype (const utype_type& x); + + void + utype (const utype_optional& x); + + void + utype (::std::auto_ptr< utype_type > p); + + // type + // + typedef ::votable_13::type3 type_type; + typedef ::xsd::cxx::tree::traits< type_type, char > type_traits; + + const type_type& + type () const; + + type_type& + type (); + + void + type (const type_type& x); + + void + type (::std::auto_ptr< type_type > p); + + static const type_type& + type_default_value (); + + // any_attribute + // + typedef ::xsd::cxx::tree::attribute_set< char > any_attribute_set; + typedef any_attribute_set::iterator any_attribute_iterator; + typedef any_attribute_set::const_iterator any_attribute_const_iterator; + + const any_attribute_set& + any_attribute () const; + + any_attribute_set& + any_attribute (); + + void + any_attribute (const any_attribute_set& s); + + // DOMDocument for wildcard content. + // + const ::xercesc::DOMDocument& + dom_document () const; + + ::xercesc::DOMDocument& + dom_document (); + + // Constructors. + // + RESOURCE (); + + RESOURCE (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + RESOURCE (const RESOURCE& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual RESOURCE* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~RESOURCE (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > dom_document_; + + DESCRIPTION_optional DESCRIPTION_; + INFO_sequence INFO_; + COOSYS_sequence COOSYS_; + GROUP_sequence GROUP_; + PARAM_sequence PARAM_; + LINK_sequence LINK_; + TABLE_sequence TABLE_; + RESOURCE1_sequence RESOURCE1_; + any_sequence any_; + name_optional name_; + ID_optional ID_; + utype_optional utype_; + ::xsd::cxx::tree::one< type_type > type_; + static const type_type type_default_value_; + any_attribute_set any_attribute_; + }; + + class type: public ::xml_schema::nmtoken + { + public: + enum value + { + legal, + actual + }; + + type (value v); + + type (const char* v); + + type (const ::std::string& v); + + type (const ::xml_schema::nmtoken& v); + + type (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + type (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + type (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + type (const type& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual type* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + type& + operator= (value v); + + virtual + operator value () const + { + return _xsd_type_convert (); + } + + protected: + value + _xsd_type_convert () const; + + public: + static const char* const _xsd_type_literals_[2]; + static const value _xsd_type_indexes_[2]; + }; + + class system: public ::xml_schema::nmtoken + { + public: + enum value + { + eq_FK4, + eq_FK5, + ICRS, + ecl_FK4, + ecl_FK5, + galactic, + supergalactic, + xy, + barycentric, + geo_app + }; + + system (value v); + + system (const char* v); + + system (const ::std::string& v); + + system (const ::xml_schema::nmtoken& v); + + system (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + system (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + system (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + system (const system& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual system* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + system& + operator= (value v); + + virtual + operator value () const + { + return _xsd_system_convert (); + } + + protected: + value + _xsd_system_convert () const; + + public: + static const char* const _xsd_system_literals_[10]; + static const value _xsd_system_indexes_[10]; + }; + + class type1: public ::xml_schema::nmtoken + { + public: + enum value + { + hidden, + no_query, + trigger, + location + }; + + type1 (value v); + + type1 (const char* v); + + type1 (const ::std::string& v); + + type1 (const ::xml_schema::nmtoken& v); + + type1 (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + type1 (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + type1 (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + type1 (const type1& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual type1* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + type1& + operator= (value v); + + virtual + operator value () const + { + return _xsd_type1_convert (); + } + + protected: + value + _xsd_type1_convert () const; + + public: + static const char* const _xsd_type1_literals_[4]; + static const value _xsd_type1_indexes_[4]; + }; + + class type2: public ::xml_schema::nmtoken + { + public: + enum value + { + locator, + other + }; + + type2 (value v); + + type2 (const char* v); + + type2 (const ::std::string& v); + + type2 (const ::xml_schema::nmtoken& v); + + type2 (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + type2 (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + type2 (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + type2 (const type2& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual type2* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + type2& + operator= (value v); + + virtual + operator value () const + { + return _xsd_type2_convert (); + } + + protected: + value + _xsd_type2_convert () const; + + public: + static const char* const _xsd_type2_literals_[2]; + static const value _xsd_type2_indexes_[2]; + }; + + class actuate: public ::xml_schema::nmtoken + { + public: + enum value + { + onLoad, + onRequest, + other, + none + }; + + actuate (value v); + + actuate (const char* v); + + actuate (const ::std::string& v); + + actuate (const ::xml_schema::nmtoken& v); + + actuate (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + actuate (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + actuate (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + actuate (const actuate& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual actuate* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + actuate& + operator= (value v); + + virtual + operator value () const + { + return _xsd_actuate_convert (); + } + + protected: + value + _xsd_actuate_convert () const; + + public: + static const char* const _xsd_actuate_literals_[4]; + static const value _xsd_actuate_indexes_[4]; + }; + + class type3: public ::xml_schema::nmtoken + { + public: + enum value + { + results, + meta + }; + + type3 (value v); + + type3 (const char* v); + + type3 (const ::std::string& v); + + type3 (const ::xml_schema::nmtoken& v); + + type3 (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + type3 (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + type3 (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + type3 (const type3& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual type3* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + type3& + operator= (value v); + + virtual + operator value () const + { + return _xsd_type3_convert (); + } + + protected: + value + _xsd_type3_convert () const; + + public: + static const char* const _xsd_type3_literals_[2]; + static const value _xsd_type3_indexes_[2]; + }; + + class VOTABLE: public ::xml_schema::type + { + public: + // DESCRIPTION + // + typedef ::votable_13::anyTEXT DESCRIPTION_type; + typedef ::xsd::cxx::tree::optional< DESCRIPTION_type > DESCRIPTION_optional; + typedef ::xsd::cxx::tree::traits< DESCRIPTION_type, char > DESCRIPTION_traits; + + const DESCRIPTION_optional& + DESCRIPTION () const; + + DESCRIPTION_optional& + DESCRIPTION (); + + void + DESCRIPTION (const DESCRIPTION_type& x); + + void + DESCRIPTION (const DESCRIPTION_optional& x); + + void + DESCRIPTION (::std::auto_ptr< DESCRIPTION_type > p); + + // DEFINITIONS + // + typedef ::votable_13::DEFINITIONS DEFINITIONS_type; + typedef ::xsd::cxx::tree::optional< DEFINITIONS_type > DEFINITIONS_optional; + typedef ::xsd::cxx::tree::traits< DEFINITIONS_type, char > DEFINITIONS_traits; + + const DEFINITIONS_optional& + DEFINITIONS () const; + + DEFINITIONS_optional& + DEFINITIONS (); + + void + DEFINITIONS (const DEFINITIONS_type& x); + + void + DEFINITIONS (const DEFINITIONS_optional& x); + + void + DEFINITIONS (::std::auto_ptr< DEFINITIONS_type > p); + + // COOSYS + // + typedef ::votable_13::COOSYS COOSYS_type; + typedef ::xsd::cxx::tree::sequence< COOSYS_type > COOSYS_sequence; + typedef COOSYS_sequence::iterator COOSYS_iterator; + typedef COOSYS_sequence::const_iterator COOSYS_const_iterator; + typedef ::xsd::cxx::tree::traits< COOSYS_type, char > COOSYS_traits; + + const COOSYS_sequence& + COOSYS () const; + + COOSYS_sequence& + COOSYS (); + + void + COOSYS (const COOSYS_sequence& s); + + // GROUP + // + typedef ::votable_13::GROUP GROUP_type; + typedef ::xsd::cxx::tree::sequence< GROUP_type > GROUP_sequence; + typedef GROUP_sequence::iterator GROUP_iterator; + typedef GROUP_sequence::const_iterator GROUP_const_iterator; + typedef ::xsd::cxx::tree::traits< GROUP_type, char > GROUP_traits; + + const GROUP_sequence& + GROUP () const; + + GROUP_sequence& + GROUP (); + + void + GROUP (const GROUP_sequence& s); + + // PARAM + // + typedef ::votable_13::PARAM PARAM_type; + typedef ::xsd::cxx::tree::sequence< PARAM_type > PARAM_sequence; + typedef PARAM_sequence::iterator PARAM_iterator; + typedef PARAM_sequence::const_iterator PARAM_const_iterator; + typedef ::xsd::cxx::tree::traits< PARAM_type, char > PARAM_traits; + + const PARAM_sequence& + PARAM () const; + + PARAM_sequence& + PARAM (); + + void + PARAM (const PARAM_sequence& s); + + // INFO + // + typedef ::votable_13::INFO INFO_type; + typedef ::xsd::cxx::tree::sequence< INFO_type > INFO_sequence; + typedef INFO_sequence::iterator INFO_iterator; + typedef INFO_sequence::const_iterator INFO_const_iterator; + typedef ::xsd::cxx::tree::traits< INFO_type, char > INFO_traits; + + const INFO_sequence& + INFO () const; + + INFO_sequence& + INFO (); + + void + INFO (const INFO_sequence& s); + + // RESOURCE + // + typedef ::votable_13::RESOURCE RESOURCE_type; + typedef ::xsd::cxx::tree::sequence< RESOURCE_type > RESOURCE_sequence; + typedef RESOURCE_sequence::iterator RESOURCE_iterator; + typedef RESOURCE_sequence::const_iterator RESOURCE_const_iterator; + typedef ::xsd::cxx::tree::traits< RESOURCE_type, char > RESOURCE_traits; + + const RESOURCE_sequence& + RESOURCE () const; + + RESOURCE_sequence& + RESOURCE (); + + void + RESOURCE (const RESOURCE_sequence& s); + + // ID + // + typedef ::xml_schema::id ID_type; + typedef ::xsd::cxx::tree::optional< ID_type > ID_optional; + typedef ::xsd::cxx::tree::traits< ID_type, char > ID_traits; + + const ID_optional& + ID () const; + + ID_optional& + ID (); + + void + ID (const ID_type& x); + + void + ID (const ID_optional& x); + + void + ID (::std::auto_ptr< ID_type > p); + + // version + // + typedef ::votable_13::version version_type; + typedef ::xsd::cxx::tree::optional< version_type > version_optional; + typedef ::xsd::cxx::tree::traits< version_type, char > version_traits; + + const version_optional& + version () const; + + version_optional& + version (); + + void + version (const version_type& x); + + void + version (const version_optional& x); + + void + version (::std::auto_ptr< version_type > p); + + // Constructors. + // + VOTABLE (); + + VOTABLE (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + VOTABLE (const VOTABLE& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual VOTABLE* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + virtual + ~VOTABLE (); + + // Implementation. + // + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + DESCRIPTION_optional DESCRIPTION_; + DEFINITIONS_optional DEFINITIONS_; + COOSYS_sequence COOSYS_; + GROUP_sequence GROUP_; + PARAM_sequence PARAM_; + INFO_sequence INFO_; + RESOURCE_sequence RESOURCE_; + ID_optional ID_; + version_optional version_; + }; + + class version: public ::xml_schema::nmtoken + { + public: + enum value + { + cxx_1_3 + }; + + version (value v); + + version (const char* v); + + version (const ::std::string& v); + + version (const ::xml_schema::nmtoken& v); + + version (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + version (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + version (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + version (const version& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + virtual version* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + version& + operator= (value v); + + virtual + operator value () const + { + return _xsd_version_convert (); + } + + protected: + value + _xsd_version_convert () const; + + public: + static const char* const _xsd_version_literals_[1]; + static const value _xsd_version_indexes_[1]; + }; +} + +#include + +#include +#include +#include + +namespace votable_13 +{ + // Parse a URI or a local file. + // + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (const ::std::string& uri, + ::xml_schema::flags f = 0, + const ::xml_schema::properties& p = ::xml_schema::properties ()); + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (const ::std::string& uri, + ::xml_schema::error_handler& eh, + ::xml_schema::flags f = 0, + const ::xml_schema::properties& p = ::xml_schema::properties ()); + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (const ::std::string& uri, + ::xercesc::DOMErrorHandler& eh, + ::xml_schema::flags f = 0, + const ::xml_schema::properties& p = ::xml_schema::properties ()); + + // Parse std::istream. + // + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (::std::istream& is, + ::xml_schema::flags f = 0, + const ::xml_schema::properties& p = ::xml_schema::properties ()); + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (::std::istream& is, + ::xml_schema::error_handler& eh, + ::xml_schema::flags f = 0, + const ::xml_schema::properties& p = ::xml_schema::properties ()); + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (::std::istream& is, + ::xercesc::DOMErrorHandler& eh, + ::xml_schema::flags f = 0, + const ::xml_schema::properties& p = ::xml_schema::properties ()); + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (::std::istream& is, + const ::std::string& id, + ::xml_schema::flags f = 0, + const ::xml_schema::properties& p = ::xml_schema::properties ()); + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (::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::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (::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::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (::xercesc::InputSource& is, + ::xml_schema::flags f = 0, + const ::xml_schema::properties& p = ::xml_schema::properties ()); + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (::xercesc::InputSource& is, + ::xml_schema::error_handler& eh, + ::xml_schema::flags f = 0, + const ::xml_schema::properties& p = ::xml_schema::properties ()); + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (::xercesc::InputSource& is, + ::xercesc::DOMErrorHandler& eh, + ::xml_schema::flags f = 0, + const ::xml_schema::properties& p = ::xml_schema::properties ()); + + // Parse xercesc::DOMDocument. + // + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (const ::xercesc::DOMDocument& d, + ::xml_schema::flags f = 0, + const ::xml_schema::properties& p = ::xml_schema::properties ()); + + ::std::auto_ptr< ::votable_13::VOTABLE > + VOTABLE_read (::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument >& d, + ::xml_schema::flags f = 0, + const ::xml_schema::properties& p = ::xml_schema::properties ()); +} + +#include + +#include +#include +#include + +#include + +namespace votable_13 +{ + void + operator<< (::xercesc::DOMElement&, const anyTEXT&); + + void + operator<< (::xercesc::DOMElement&, const astroYear&); + + void + operator<< (::xercesc::DOMAttr&, const astroYear&); + + void + operator<< (::xml_schema::list_stream&, + const astroYear&); + + void + operator<< (::xercesc::DOMElement&, const ucdType&); + + void + operator<< (::xercesc::DOMAttr&, const ucdType&); + + void + operator<< (::xml_schema::list_stream&, + const ucdType&); + + void + operator<< (::xercesc::DOMElement&, const arrayDEF&); + + void + operator<< (::xercesc::DOMAttr&, const arrayDEF&); + + void + operator<< (::xml_schema::list_stream&, + const arrayDEF&); + + void + operator<< (::xercesc::DOMElement&, const encodingType&); + + void + operator<< (::xercesc::DOMAttr&, const encodingType&); + + void + operator<< (::xml_schema::list_stream&, + const encodingType&); + + void + operator<< (::xercesc::DOMElement&, const dataType&); + + void + operator<< (::xercesc::DOMAttr&, const dataType&); + + void + operator<< (::xml_schema::list_stream&, + const dataType&); + + void + operator<< (::xercesc::DOMElement&, const precType&); + + void + operator<< (::xercesc::DOMAttr&, const precType&); + + void + operator<< (::xml_schema::list_stream&, + const precType&); + + void + operator<< (::xercesc::DOMElement&, const yesno&); + + void + operator<< (::xercesc::DOMAttr&, const yesno&); + + void + operator<< (::xml_schema::list_stream&, + const yesno&); + + void + operator<< (::xercesc::DOMElement&, const MIN&); + + void + operator<< (::xercesc::DOMElement&, const MAX&); + + void + operator<< (::xercesc::DOMElement&, const OPTION&); + + void + operator<< (::xercesc::DOMElement&, const VALUES&); + + void + operator<< (::xercesc::DOMElement&, const LINK&); + + void + operator<< (::xercesc::DOMElement&, const INFO&); + + void + operator<< (::xercesc::DOMElement&, const COOSYS&); + + void + operator<< (::xercesc::DOMElement&, const DEFINITIONS&); + + void + operator<< (::xercesc::DOMElement&, const FIELD&); + + void + operator<< (::xercesc::DOMElement&, const PARAM&); + + void + operator<< (::xercesc::DOMElement&, const GROUP&); + + void + operator<< (::xercesc::DOMElement&, const FIELDref&); + + void + operator<< (::xercesc::DOMElement&, const PARAMref&); + + void + operator<< (::xercesc::DOMElement&, const DATA&); + + void + operator<< (::xercesc::DOMElement&, const TABLEDATA&); + + void + operator<< (::xercesc::DOMElement&, const TD&); + + void + operator<< (::xercesc::DOMElement&, const TR&); + + void + operator<< (::xercesc::DOMElement&, const FITS&); + + void + operator<< (::xercesc::DOMElement&, const BINARY&); + + void + operator<< (::xercesc::DOMElement&, const BINARY2&); + + void + operator<< (::xercesc::DOMElement&, const STREAM&); + + void + operator<< (::xercesc::DOMElement&, const TABLE&); + + void + operator<< (::xercesc::DOMElement&, const RESOURCE&); + + // Serialize to std::ostream. + // + + void + VOTABLE_write (::std::ostream& os, + const ::votable_13::VOTABLE& x, + const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (), + const ::std::string& e = "UTF-8", + ::xml_schema::flags f = 0); + + void + VOTABLE_write (::std::ostream& os, + const ::votable_13::VOTABLE& 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 + VOTABLE_write (::std::ostream& os, + const ::votable_13::VOTABLE& 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 + VOTABLE_write (::xercesc::XMLFormatTarget& ft, + const ::votable_13::VOTABLE& x, + const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (), + const ::std::string& e = "UTF-8", + ::xml_schema::flags f = 0); + + void + VOTABLE_write (::xercesc::XMLFormatTarget& ft, + const ::votable_13::VOTABLE& 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 + VOTABLE_write (::xercesc::XMLFormatTarget& ft, + const ::votable_13::VOTABLE& 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 + VOTABLE_write (::xercesc::DOMDocument& d, + const ::votable_13::VOTABLE& x, + ::xml_schema::flags f = 0); + + // Serialize to a new xercesc::DOMDocument. + // + + ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > + VOTABLE_write (const ::votable_13::VOTABLE& x, + const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (), + ::xml_schema::flags f = 0); + + void + operator<< (::xercesc::DOMElement&, const type&); + + void + operator<< (::xercesc::DOMAttr&, const type&); + + void + operator<< (::xml_schema::list_stream&, + const type&); + + void + operator<< (::xercesc::DOMElement&, const system&); + + void + operator<< (::xercesc::DOMAttr&, const system&); + + void + operator<< (::xml_schema::list_stream&, + const system&); + + void + operator<< (::xercesc::DOMElement&, const type1&); + + void + operator<< (::xercesc::DOMAttr&, const type1&); + + void + operator<< (::xml_schema::list_stream&, + const type1&); + + void + operator<< (::xercesc::DOMElement&, const type2&); + + void + operator<< (::xercesc::DOMAttr&, const type2&); + + void + operator<< (::xml_schema::list_stream&, + const type2&); + + void + operator<< (::xercesc::DOMElement&, const actuate&); + + void + operator<< (::xercesc::DOMAttr&, const actuate&); + + void + operator<< (::xml_schema::list_stream&, + const actuate&); + + void + operator<< (::xercesc::DOMElement&, const type3&); + + void + operator<< (::xercesc::DOMAttr&, const type3&); + + void + operator<< (::xml_schema::list_stream&, + const type3&); + + void + operator<< (::xercesc::DOMElement&, const VOTABLE&); + + void + operator<< (::xercesc::DOMElement&, const version&); + + void + operator<< (::xercesc::DOMAttr&, const version&); + + void + operator<< (::xml_schema::list_stream&, + const version&); +} + +#include + +// Begin epilogue. +// +// +// End epilogue. + +#endif // VOTABLE1_3_HXX diff --git a/applications/gaia/gaiavo/generic/VOTableStream.C b/applications/gaia/gaiavo/generic/VOTableStream.C index 04f6874f30c..e239d980152 100644 --- a/applications/gaia/gaiavo/generic/VOTableStream.C +++ b/applications/gaia/gaiavo/generic/VOTableStream.C @@ -3,13 +3,13 @@ * gaia::VOTableStream * Purpose: - * Class for handling a VOTable BINARY stream. + * Class for handling VOTable BINARY and BINARY2 streams. * Language: * C++ * Copyright: - * Copyright (C) 2008 Science and Technology Facilities Council. + * Copyright (C) 2008-2014 Science and Technology Facilities Council. * All Rights Reserved. * Licence: @@ -49,6 +49,7 @@ #include #include #include +#include /* Local includes. */ #include "VOTableStream.h" @@ -126,7 +127,8 @@ namespace gaia { } break; case SHORT: { - return readValues( quantity, havenull, nullstring, out ); + return readValues( quantity, havenull, nullstring, + out ); } break; case INT: { @@ -150,18 +152,18 @@ namespace gaia { } break; case DOUBLE: { - return readValues( quantity, havenull, - nullstring, out ); + return readFloatValues( quantity, havenull, + nullstring, out ); } break; case FLOATCOMPLEX: { - return readValues( quantity * 2, havenull, - nullstring, out ); + return readFloatValues( quantity * 2, havenull, + nullstring, out ); } break; case DOUBLECOMPLEX: { - return readValues( quantity * 2, havenull, - nullstring, out ); + return readFloatValues( quantity * 2, havenull, + nullstring, out ); } break; } @@ -183,7 +185,17 @@ namespace gaia { // If runlength encoded, first four bytes are the quantity. if ( quantity == 0 ) { - readValue( quantity ); + if ( readValue( quantity ) ) { + if ( quantity == 0 ) { + // No value. + *out << " "; + } + } + else { + /* End of stream. */ + result = false; + quantity = 0; + } } for ( int i = 0; i < quantity; i++ ) { @@ -237,7 +249,17 @@ namespace gaia { // If runlength encoded, first four bytes are the quantity. if ( quantity == 0 ) { - readValue( quantity ); + if ( readValue( quantity ) ) { + if ( quantity == 0 ) { + // No value. + *out << " "; + } + } + else { + /* End of stream. */ + result = false; + quantity = 0; + } } for ( int i = 0; i < quantity; i++ ) { @@ -284,7 +306,17 @@ namespace gaia { // If runlength encoded, first four bytes are the quantity. if ( quantity == 0 ) { - readValue( quantity ); + if ( readValue( quantity ) ) { + if ( quantity == 0 ) { + // No value. + *out << " "; + } + } + else { + /* End of stream. */ + result = false; + quantity = 0; + } } // Extract the null value. @@ -347,14 +379,25 @@ namespace gaia { // If runlength encoded, first four bytes are the quantity. if ( quantity == 0 ) { - readValue( quantity ); + if ( readValue( quantity ) ) { + if ( quantity == 0 ) { + // No value. + *out << " "; + } + } + else { + /* End of stream. */ + result = false; + quantity = 0; + } } for ( int i = 0; i < quantity; i++ ) { if ( readChar( value ) ) { if ( value == '\0' ) { - // End of string. - break; + // End of string, so don't print more, but we + // need to read stream for required quantity. + continue; } else { *out << value; @@ -385,26 +428,45 @@ namespace gaia { /** * Read a VOTable unicode string from the stream and write the decoded * value to the output stream. Usually a string, which can be terminated - * by a '\0'. If this is required then the quantity may be specified as - * 0. Returns false if the read fails. + * by a ='\0'. If this is required then the quantity may be specified as + * 0. Returns false if the read fails. Note the output stream does not + * support unicode, so we convert to ASCII and hope for the best. */ bool VOTableStream::readUniChars( int quantity, ostream *out ) { bool result = true; - wchar_t value; + char value; // If runlength encoded, first four bytes are the quantity. if ( quantity == 0 ) { - readValue( quantity ); + if ( readValue( quantity ) ) { + if ( quantity == 0 ) { + // No value. + *out << " "; + } + } + else { + /* End of stream. */ + result = false; + quantity = 0; + } } for ( int i = 0; i < quantity; i++ ) { if ( readUniChar( value ) ) { if ( value == '\0' ) { - break; + // End of string, so don't print more, but we + // need to read stream for required quantity. + continue; } else { - *out << value; + // Avoid newlines, tabs etc. These will break the format. + if ( iscntrl( value ) ) { + *out << " "; + } + else { + *out << value; + } } } else { @@ -416,30 +478,25 @@ namespace gaia { } /** - * Read a VOTable unicode character from the stream and return the result. - * Returns false if the read fails. + * Read a VOTable unicode character from the stream and return the result + * as an ASCII char. Returns false if the read fails. Note no bigendian + * checks as that is assumed by the encoding (UCS-2), so we just return + * byte 2 as the ASCII. */ - bool VOTableStream::readUniChar( wchar_t &value ) + bool VOTableStream::readUniChar( char &value ) { bool result = true; - union { - char b[2]; - wchar_t w; - } u; + char b[2]; - if ( bigendian_ ) { - u.b[0] = in_->sbumpc(); - u.b[1] = in_->sbumpc(); - } - else { - u.b[1] = in_->sbumpc(); - u.b[0] = in_->sbumpc(); - } - if ( ( u.b[1] == EOF || u.b[0] == EOF ) ) { + b[0] = in_->sbumpc(); + b[1] = in_->sbumpc(); + + if ( ( b[1] == EOF || b[0] == EOF ) ) { + value = '\0'; result = false; } else { - value = u.w; + value = b[1]; } return result; } @@ -461,7 +518,17 @@ namespace gaia { // If runlength encoded, first four bytes are the quantity. if ( quantity == 0 ) { - readValue( quantity ); + if ( readValue( quantity ) ) { + if ( quantity == 0 ) { + // No value. + *out << " "; + } + } + else { + /* End of stream. */ + result = false; + quantity = 0; + } } T nullvalue; @@ -516,7 +583,17 @@ namespace gaia { // If runlength encoded, first four bytes are the quantity. if ( quantity == 0 ) { - readValue( quantity ); + if ( readValue( quantity ) ) { + if ( quantity == 0 ) { + // No value. + *out << " "; + } + } + else { + /* End of stream. */ + result = false; + quantity = 0; + } } T nullvalue; @@ -585,4 +662,272 @@ namespace gaia { } return false; } + + + // BINARY2 specific support. + + /** + * Read n bytes from the stream and interpret as a BINARY2 null bit mask. + * Returning the 0/1 bit values as false/true in the bitmask array. + * The bitmask array should be of size n*8. + */ + bool VOTableStream::readBitMask( int n, bool bitmask[] ) + { + bool result = true; + char b; + int k = 0; + + for ( int i = 0; i < n; i++ ) { + char b = in_->sbumpc(); + if ( b != EOF ) { + bitset<8> bs( b ); + for ( int j = 7; j >= 0; j-- ) { + bitmask[k] = bs.test( j ); + k++; + } + } + else { + result = false; + break; + } + } + + return result; + } + + /** + * Read a supported vector of data objects from the input stream and + * discard their content. Returns false if the read fails. Use to skip + * over null elements in a BINARY2 stream. + */ + bool VOTableStream::readSkip( datatype type, int quantity ) + { + switch ( type ) { + case BOOLEAN: { + return skipBooleans( quantity ); + } + break; + case BITARRAY: { + return skipBitArrays( quantity ); + } + break; + case BYTE: { + return skipBytes( quantity ); + } + break; + case CHAR: { + return skipChars( quantity ); + } + break; + case UNICODE: { + return skipUniChars( quantity ); + } + break; + case SHORT: { + return skipValues( quantity ); + } + break; + case INT: { + return skipValues( quantity ); + } + break; + case LONG: { + if ( uselonglong_ ) { + return skipValues( quantity ); + } + else { + return skipValues( quantity ); + } + } + break; + case FLOAT: { + return skipValues( quantity ); + } + break; + case DOUBLE: { + return skipValues( quantity ); + } + break; + case FLOATCOMPLEX: { + return skipValues( quantity * 2 ); + } + break; + case DOUBLECOMPLEX: { + return skipValues( quantity * 2 ); + } + break; + } + + // Cannot happen (unless a datatype is missed). + return false; + } + + /** + * Read a vector of VOTable booleans from the stream and discard + * them. Result is false if the read fails. + */ + bool VOTableStream::skipBooleans( int quantity ) + { + bool result = true; + bool value; + int status; + + // If runlength encoded, first four bytes are the quantity. + if ( quantity == 0 ) { + if ( ! readValue( quantity ) ) { + /* End of stream. */ + result = false; + quantity = 0; + } + } + + for ( int i = 0; i < quantity; i++ ) { + if ( ! readBoolean( value ) ) { + result = false; + break; + } + } + return result; + } + + /** + * Read a VOTable bit array vector from the stream and discard. + * The result is false if the read fails. + */ + bool VOTableStream::skipBitArrays( int quantity ) + { + bool result = true; + string value; + + // If runlength encoded, first four bytes are the quantity. + if ( quantity == 0 ) { + if ( ! readValue( quantity ) ) { + /* End of stream. */ + result = false; + quantity = 0; + } + } + + for ( int i = 0; i < quantity; i++ ) { + if ( ! readBitArray( value ) ) { + result = false; + break; + } + } + return result; + } + + /** + * Read a VOTable byte vector from the stream and discard. + * Returns false if the read fails. + */ + bool VOTableStream::skipBytes( int quantity ) + { + bool result = true; + unsigned char value; + + // If runlength encoded, first four bytes are the quantity. + if ( quantity == 0 ) { + if ( ! readValue( quantity ) ) { + /* End of stream. */ + result = false; + quantity = 0; + } + } + + for ( int i = 0; i < quantity; i++ ) { + if ( ! readByte( value ) ) { + result = false; + break; + } + } + return result; + } + + /** + * Read a VOTable string from the stream and discard. + */ + bool VOTableStream::skipChars( int quantity ) + { + bool result = true; + char value; + + // If runlength encoded, first four bytes are the quantity. + if ( quantity == 0 ) { + if ( ! readValue( quantity ) ) { + /* End of stream. */ + result = false; + quantity = 0; + } + } + + for ( int i = 0; i < quantity; i++ ) { + if ( readChar( value ) ) { + if ( value == '\0' ) { + // End of string, so don't print more, but we + // need to read stream for required quantity. + continue; + } + } + else { + result = false; + break; + } + } + return result; + } + + /** + * Read a VOTable unicode string from the stream and discard. + */ + bool VOTableStream::skipUniChars( int quantity ) + { + bool result = true; + char value; + + // If runlength encoded, first four bytes are the quantity. + if ( quantity == 0 ) { + if ( ! readValue( quantity ) ) { + /* End of stream. */ + result = false; + quantity = 0; + } + } + + for ( int i = 0; i < quantity; i++ ) { + if ( ! readUniChar( value ) ) { + result = false; + break; + } + } + return result; + } + + /** + * Read a vector of values from the input stream and discard. + * If the read fails then false is returned. + */ + template + bool VOTableStream::skipValues( int quantity ) + { + bool result = true; + T value; + + // If runlength encoded, first four bytes are the quantity. + if ( quantity == 0 ) { + if ( ! readValue( quantity ) ) { + /* End of stream. */ + result = false; + quantity = 0; + } + } + + for ( int i = 0; i < quantity; i++ ) { + if ( ! readValue( value ) ) { + result = false; + break; + } + } + return result; + } } diff --git a/applications/gaia/gaiavo/generic/VOTableStream.h b/applications/gaia/gaiavo/generic/VOTableStream.h index aaa1d47da04..0cb72daa1cd 100644 --- a/applications/gaia/gaiavo/generic/VOTableStream.h +++ b/applications/gaia/gaiavo/generic/VOTableStream.h @@ -70,12 +70,20 @@ namespace gaia { bool readPrint( datatype type, int quantity, bool havenull, string &nullstring, ostream *out ); + /* Read vector of given types from the stream and discard. + * Need to do this when the values are known to be null as + * the BINARY2 bitmask is set. */ + bool readSkip( datatype type, int quantity ); + /* Native type access to the values in the stream. */ bool readBitArray( string &value ); int readBoolean( bool &value ); bool readByte( unsigned char &value ); bool readChar( char &value ); - bool readUniChar( wchar_t &value ); + bool readUniChar( char &value ); + + /* BINARY2 null support. */ + bool readBitMask( int n, bool bitmask[] ); template bool readValue( T &value ); @@ -101,5 +109,13 @@ namespace gaia { string &nullvalue, ostream *out ); template bool readValues( int quantity, bool havenull, string &nullvalue, ostream *out ); + + /* Discard values that are known to be null (BINARY2). */ + bool skipBitArrays( int quantity ); + bool skipBooleans( int quantity ); + bool skipBytes( int quantity ); + bool skipChars( int quantity ); + bool skipUniChars( int quantity ); + template bool skipValues( int quantity ); }; } diff --git a/applications/gaia/gaiavo/generic/VOTableWriteFunctions.C b/applications/gaia/gaiavo/generic/VOTableWriteFunctions.C index 9a4853c0cbb..0de29e19fce 100644 --- a/applications/gaia/gaiavo/generic/VOTableWriteFunctions.C +++ b/applications/gaia/gaiavo/generic/VOTableWriteFunctions.C @@ -87,6 +87,7 @@ #include "VOTable1.1_dns.hxx" #include "VOTable1.1.hxx" #include "VOTable1.2.hxx" +#include "VOTable1.3.hxx" #include "VOTable.h" #include "VOTableStream.h" #include "GaiaUtils.h" @@ -102,15 +103,27 @@ namespace gaia { // Actual members are defined elsewhere. #define NS votable_11_dns +#define NSVERS 11 #include "VOTableWriteFunctions.icc" #undef NS +#undef NSVERS #define NS votable_11 +#define NSVERS 11 #include "VOTableWriteFunctions.icc" #undef NS +#undef NSVERS #define NS votable_12 +#define NSVERS 12 #include "VOTableWriteFunctions.icc" #undef NS +#undef NSVERS + +#define NS votable_13 +#define NSVERS 13 +#include "VOTableWriteFunctions.icc" +#undef NS +#undef NSVERS } diff --git a/applications/gaia/gaiavo/generic/VOTableWriteFunctions.h b/applications/gaia/gaiavo/generic/VOTableWriteFunctions.h index dab16e3e088..efb9df33437 100644 --- a/applications/gaia/gaiavo/generic/VOTableWriteFunctions.h +++ b/applications/gaia/gaiavo/generic/VOTableWriteFunctions.h @@ -73,10 +73,21 @@ int data_tabledata( const NS::TABLE& table, const NS::TABLEDATA& tdata, int& ra_index, bool& ra_radians, string& ra_unit, int& dec_index, bool& dec_radians, string& dec_unit ); -int data_binarydata( const NS::TABLE& table, const NS::BINARY& bdata, +#if NSVERS == 13 +int data_binarydata2( bool binary2, const NS::TABLE& table, const NS::BINARY2& bdata, + ofstream& out, int& id_index, int& ra_index, + bool& ra_radians, int& dec_index, bool& dec_radians ); +#endif +int data_binarydata( bool binary2, const NS::TABLE& table, const NS::BINARY& bdata, ofstream& out, int& id_index, int& ra_index, bool& ra_radians, int& dec_index, bool& dec_radians ); +int data_binarystream( bool binary2, const NS::TABLE& table, + const string& stream, const string& encoding, + NS::STREAM::href_optional& href, + ofstream& out, int& id_index, int& ra_index, + bool& ra_radians, int& dec_index, bool& dec_radians ); + int data_fitsdata( const NS::FITS& fdata, ofstream& out, int& id_index, int& ra_index, bool& ra_radians, int& dec_index, bool& dec_radians ); diff --git a/applications/gaia/gaiavo/generic/VOTableWriteFunctions.icc b/applications/gaia/gaiavo/generic/VOTableWriteFunctions.icc index 897836bcce7..a27be3347c7 100644 --- a/applications/gaia/gaiavo/generic/VOTableWriteFunctions.icc +++ b/applications/gaia/gaiavo/generic/VOTableWriteFunctions.icc @@ -757,8 +757,9 @@ void VOTable::table_coosys( const NS::COOSYS& coosys, ofstream& out ) * are converted from radians to degrees if needed. */ int VOTable::table_columns( const NS::TABLE& table, ofstream& out, - int& id_index, int& ra_index, bool& ra_radians, string& ra_unit, - int& dec_index, bool& dec_radians, string& dec_unit ) + int& id_index, int& ra_index, bool& ra_radians, + string& ra_unit, int& dec_index, bool& dec_radians, + string& dec_unit ) { using namespace NS; @@ -768,7 +769,7 @@ int VOTable::table_columns( const NS::TABLE& table, ofstream& out, // Empty tables are OK. if ( odata ) { - // Three variants, TABLEDATA, BINARY and FITS. + // Four variants, TABLEDATA, BINARY, BINARY2 and FITS. const DATA::TABLEDATA_optional tdata( odata.get().TABLEDATA() ); if ( tdata ) { return data_tabledata( table, tdata.get(), out, id_index, @@ -778,11 +779,22 @@ int VOTable::table_columns( const NS::TABLE& table, ofstream& out, const DATA::BINARY_optional bdata( odata.get().BINARY() ); if ( bdata ) { - return data_binarydata( table, bdata.get(), out, id_index, + return data_binarydata( false, table, bdata.get(), out, id_index, ra_index, ra_radians, dec_index, dec_radians ); } + /* Only in 1.3 and later */ +#if NSVERS == 13 + + const DATA::BINARY2_optional bdata2( odata.get().BINARY2() ); + if ( bdata2 ) { + return data_binarydata2( true, table, bdata2.get(), out, id_index, + ra_index, ra_radians, dec_index, + dec_radians ); + } +#endif + const DATA::FITS_optional fdata( odata.get().FITS() ); if ( fdata ) { return data_fitsdata( fdata.get(), out, id_index, ra_index, @@ -834,7 +846,7 @@ int VOTable::data_tabledata( const NS::TABLE& table, const NS::TABLEDATA& tdata, // TABLEDATA consists of rows of with each cell as a element. TABLEDATA::TR_const_iterator triter( tdata.TR().begin() ); TABLEDATA::TR_const_iterator trend( tdata.TR().end() ); - int nrow = 0; + int nrow = 1; string cell; for ( ; triter != trend; ++triter ) { TR::TD_const_iterator tditer( triter->TD().begin() ); @@ -910,10 +922,33 @@ int VOTable::data_tabledata( const NS::TABLE& table, const NS::TABLEDATA& tdata, } /** - * Write a BINARY element of a table to Skycat format. RA and Dec columns - * are converted from radians to degrees if needed. + * Write a BINARY2 element of a table to Skycat format. RA and Dec + * columns are converted from radians to degrees if needed. */ -int VOTable::data_binarydata( const NS::TABLE& table, const NS::BINARY& bdata, +#if NSVERS == 13 +int VOTable::data_binarydata2( bool binary2, const NS::TABLE& table, const NS::BINARY2& bdata, + ofstream& out, int& id_index, int& ra_index, + bool& ra_radians, int& dec_index, bool& dec_radians ) +{ + using namespace NS; + + // See if we need to decode the data. Support base64 and gzip and + // native. See if this is needed by checking the encodingType. + BINARY2::STREAM_type stream( bdata.STREAM() ); + string encoding( stream.encoding() ); + STREAM::href_optional href( stream.href() ); + + return data_binarystream( binary2, table, stream, encoding, href, + out, id_index, ra_index, + ra_radians, dec_index, dec_radians ); +} +#endif + +/** + * Write a BINARY element of a table to Skycat format. RA and Dec + * columns are converted from radians to degrees if needed. + */ +int VOTable::data_binarydata( bool binary2, const NS::TABLE& table, const NS::BINARY& bdata, ofstream& out, int& id_index, int& ra_index, bool& ra_radians, int& dec_index, bool& dec_radians ) { @@ -925,6 +960,24 @@ int VOTable::data_binarydata( const NS::TABLE& table, const NS::BINARY& bdata, string encoding( stream.encoding() ); STREAM::href_optional href( stream.href() ); + return data_binarystream( binary2, table, stream, encoding, href, + out, id_index, ra_index, + ra_radians, dec_index, dec_radians ); +} + +/** + * Read a stringstream wrapping a BINARY or BINARY2 element of a table to + * Skycat format. RA and Dec columns are converted from radians to degrees if + * needed. + */ +int VOTable::data_binarystream( bool binary2, const NS::TABLE& table, + const string& stream, const string& encoding, + NS::STREAM::href_optional& href, + ofstream& out, int& id_index, int& ra_index, + bool& ra_radians, int& dec_index, bool& dec_radians ) +{ + using namespace NS; + streambuf *inbuf; stringstream *istr; HTTP http; // Keep in scope for memory management. @@ -1024,7 +1077,9 @@ int VOTable::data_binarydata( const NS::TABLE& table, const NS::BINARY& bdata, arraysizes.push_back( field_arraysize( *fiter ) ); // Check for a null attribute in the optional VALUES element. + // Not used in BINARY2, null bits are encoded for each row. FIELD::VALUES_optional values( fiter->VALUES() ); + if ( values ) { VALUES::null_optional nullv( values.get().null() ); if ( &nullv.get() != 0 ) { @@ -1051,11 +1106,35 @@ int VOTable::data_binarydata( const NS::TABLE& table, const NS::BINARY& bdata, /* Now write the rows. */ VOTableStream os( inbuf ); bool ok = true; - int row = 0; + int nrow = 1; + + // Number of bytes used for nulls in BINARY2 format. + int b2bytes = (int) (field_types.size() + 7 ) / 8; + bool *b2mask = new bool[b2bytes * 8]; + while ( ok ) { + if ( binary2 ) { + // First field is null bit array. + ok = os.readBitMask( b2bytes, b2mask ); + if ( ! ok ) { + break; + } + } for ( int i = 0; i < (int) field_types.size(); i++ ) { - ok = os.readPrint( field_types[i], arraysizes[i], havenull[i], - nullvalues[i], &out ); + if ( binary2 ) { + if ( b2mask[i] ) { + ok = os.readSkip( field_types[i], arraysizes[i] ); + out << " "; + } + else { + ok = os.readPrint( field_types[i], arraysizes[i], + havenull[i], nullvalues[i], &out ); + } + } + else { + ok = os.readPrint( field_types[i], arraysizes[i], havenull[i], + nullvalues[i], &out ); + } if ( ok ) { out << '\t'; } @@ -1064,13 +1143,14 @@ int VOTable::data_binarydata( const NS::TABLE& table, const NS::BINARY& bdata, } } if ( id_index == -1 && ok ) { - out << '\t' << row; - row++; + out << nrow << '\t'; + nrow++; } if ( ok ) out << '\n'; } delete istr; + delete[] b2mask; return 1; } @@ -1200,16 +1280,16 @@ int VOTable::data_fitsdata( const NS::FITS& fdata, ofstream& out, int& id_index, } char *s; - for ( long row = 1; row <= nrows; row++ ) { + for ( long nrow = 1; nrow <= nrows; nrow++ ) { for ( long col = 1; col <= ncols; col++ ) { if ( col == ( ra_index + 1 ) ) { - s = fits->getTableValue( row, col, rascale ); + s = fits->getTableValue( nrow, col, rascale ); } else if ( col == ( dec_index + 1 ) ) { - s = fits->getTableValue( row, col, decscale ); + s = fits->getTableValue( nrow, col, decscale ); } else { - s = fits->getTableValue( row, col, 1.0 ); + s = fits->getTableValue( nrow, col, 1.0 ); } if ( ! s ) { return 0; @@ -1221,7 +1301,7 @@ int VOTable::data_fitsdata( const NS::FITS& fdata, ofstream& out, int& id_index, } } if ( id_index == -1 ) { - out << '\t' << row; + out << '\t' << nrow; } out << '\n'; } diff --git a/applications/gaia/gaiavo/library/GaiaTAPServers.vot b/applications/gaia/gaiavo/library/GaiaTAPServers.vot new file mode 100644 index 00000000000..8a9d3040410 --- /dev/null +++ b/applications/gaia/gaiavo/library/GaiaTAPServers.vot @@ -0,0 +1,1413 @@ + + Registry Search Results + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#VMC DR2VMC DR2 - VISTA Magellanic System surveyThe VMC survey aims to obtain YJKs band photometry across the system down to Ks=20.3 at S/N=10. This sensitivity corresponds to the bottom of the red giant branch field stellar population and allows us to determine the global spatially resolved star formation history with unprecedented quality and to construct a three-dimensional map of the system. A wide-area encompassing the D25 as well as major features delineated by the distribution of stars and HI gas, will both trace the structure of the galaxies and signatures of past and present interactions. Contemporary optical and kinematic observations of comparable sensitivity will provide the community with a superior database for future studies of the system and will give us an excellent insight as to what has happened elsewhere in the Universe.WFAU, Institute for Astronomy, University of Edinburgh + ivo://wfau.roe.ac.uk/vmcDR2-dsa2014-03-05T15:21:25#Infrared, survey, galaxy, Marellanic Cloud##Survey##Research# + Data Release 2ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/vmcDR2-dsa/DirectCone?DSACAT=VMC_DR2&DSATAB=vmcSource& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://www.star.herts.ac.uk/~mcioni/vmc/
#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#VIDEO DR3VIDEO DR3 - VISTA Deep Extragalactic Observations surveyThe VIDEO survey is a 30 sq. degree, Z,Y,J,H,K survey that is specifically designed to enable exploration of the main issues in observational cosmology. It allows galaxy and cluster/structure evolution to be traced as a function of both epoch and environment from the present day out to z=4 and AGN/QSO evolution up to and into the epoch of reionization at z > 6. The multi-band nature of the survey ensures many key science drivers can be tackled using the survey alone, without recourse to data from other wavebands.WFAU, Institute for Astronomy, University of Edinburgh + ivo://wfau.roe.ac.uk/videoDR3-dsa2014-03-05T15:21:05#Observational cosmology, galaxy, cluster, evolution, infrared##Survey##Research# + Data Release 3ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/videoDR3-dsa/DirectCone?DSACAT=VIDEO_DR3&DSATAB=videoSource& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://arxiv.org/abs/1206.4263
#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#VHS DR2VHS DR2 - VISTA Hemisphere Survey Data Release 2The VHS will image the entire ~20 000 square degrees of the Southern Sky, with the exception of the areas already covered by the VIKING and VVV surveys, in J and Ks. The resulting data will be about 4 magnitudes deeper than 2MASS and DENIS. The 5000 square degrees covered by the Dark Energy Survey (DES), another imaging survey scheduled to begin in 2010 at the CTIO 4 metre Blanco telescope, will also be observed in H-band. The area around both of the Galactic Caps will be observed in Y- and H- band as well to be combined with the data from the VST ATLAS survey. The main science drivers of the VHS include: examining low mass and nearby stars, studying the merger history of the Galaxy, measuring the properties of Dark Energy through the examination of large-scale structure to a redshift of ~1, and searches for high redshift quasars.WFAU, Institute for Astronomy, University of Edinburgh + ivo://wfau.roe.ac.uk/vhsDR2-dsa2014-03-05T15:21:56#Stars,Survey,Galaxy, low mass stars, dark energy##Survey##Research# + Data Release 2ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/vhsDR2-dsa/DirectCone?DSACAT=VHS_DR2&DSATAB=vhsSource& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://www.ast.cam.ac.uk/~rgm/vhs/
#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#VIKING DR3VIKING - VISTA Kilo-degree Infrared Galaxy survey Data Release 3The VIKING survey is the VISTA counterpart to the VST KIDS survey. The KIDS survey will cover 1500 deg^2 in u,g,r,i divided in two stripes (NGP, centred on equator ; SGP, centred on Dec = -30). The matching VISTA survey will cover (almost) all of these stripes in Z,Y,J,H, Ks with ~ 400s exposures per band.WFAU, Institute for Astronomy, University of Edinburgh + ivo://wfau.roe.ac.uk/vikingDR3-dsa2013-12-17T11:24:57#Infrared, survey, galaxy, point source, KIDS##Survey##Research# + Data Release 3ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/vikingDR3-dsa/DirectCone?DSACAT=VIKING_DR3&DSATAB=vikingSource& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://www.astro-wise.org/projects/VIKING/
#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#UKIDSS DR9UKIDSS DR9 - UKIRT Infrared Deep Sky Survey Data Release 9This DSA hosts data release 9 of the UKIRT Infrared Deep Sky Survey housed at the Wide Field Astronomy Unit at the Univeristy of Edinburgh. This catalog contains WFCAM data primarily originating from four of the five UKIDSS surveys: Large Area Survey, Galactic Clusters Survey, Deep Extragalactic Survey, and Ultra Deep Survey. (see www.ukidss.org for survey descriptions)WFAU, Institute for Astronomy, University of Edinburgh + ivo://wfau.roe.ac.uk/ukidssDR9-dsa2013-12-17T12:01:59#Infrared, survey, galaxy, point source##Survey##Research# + Data Release 9ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/ukidssDR9-dsa/DirectCone?DSACAT=UKIDSS_DR9&DSATAB=lasSource& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://surveys.roe.ac.uk/wsa
#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request# + 2MASS Photometric Redshift catalogue (2MPZ)The 2MASS Photometric Redshift catalogue (2MPZ) is constructed by cross-matching 2MASS XSC, WISE and SuperCOSMOS all-sky samples and employing the artificial neural network approach (the ANNz algorithm, Collister & Lahav 2004), trained on several redshift surveys (2MRS, SDSS, 6dFGS, 2dFGRS and ZCAT). The derived photometric redshifts have errors nearly independent of distance, with an all-sky accuracy of σz = 0.015, and a very small percentage of outliers. These redshift estimates have a typical precision of 12% for all the 2MASS XSC galaxies that lack spectroscopy. The resulting 2MPZ sample contains almost 1 million galaxies with a median redshift of z=0.07. This catalogue is described in Bilicki et al. 2014, ApJS, 210, 9.WFAU, Institute for Astronomy, University of Edinburgh + ivo://wfau.roe.ac.uk/twompz-dsa2013-12-17T14:03:25#survey, Twomass, galaxy, redshift##Catalog##Research# + Data Release 1ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/twompz-dsa/DirectCone?DSACAT=TwoMPZ&DSATAB=twompzPhotoz& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://surveys.roe.ac.uk/ssa/TWOMPZ
#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request# + ATLAS DR1 - VST ATLAS SurveyThis DSA hosts data release 1 of the ATLAS Survey housed at the Wide Field Astronomy Unit at the Univeristy of Edinburgh. The initial aim of ATLAS is to survey 4500 deg2 of the Southern Sky at high galactic latitudes to comparable depths to the SDSS in the North. The VST ATLAS will be the first step towards a panoramic digital survey of the Southern Sky in the optical bands. The ATLAS will complement the proposed VISTA Hemisphere Survey in the South.WFAU, Institute for Astronomy, University of Edinburgh + ivo://wfau.roe.ac.uk/atlasDR1-dsa2013-12-05T12:08:38#survey, galaxy, point source##Survey##Research# + Data Release 1ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/atlasDR1-dsa/DirectCone?DSACAT=ATLAS_DR1&DSATAB=atlasDetection& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://astro.dur.ac.uk/Cosmology/vstatlas/
#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request# + WISE (Wide-field Infrared Survey Explorer)NASA's Wide-field Infrared Survey Explorer (WISE; Wright et al. 2010) mapped the sky at 3.4, 4.6, 12, and 22 μm (W1, W2, W3, W4) in 2010 with an angular resolution of 6.1", 6.4", 6.5", & 12.0" in the four bands. WISE achieved 5Ï? point source sensitivities better than 0.08, 0.11, 1 and 6 mJy in unconfused regions on the ecliptic in the four bands. Sensitivity improves toward the ecliptic poles due to denser coverage and lower zodiacal background.WFAU, Institute for Astronomy, University of Edinburgh#Infrared#ivo://wfau.roe.ac.uk/wise-dsa2013-05-30T16:20:40#WISE all-sky infrared##Survey##Research# + Data Release March 14, 2012ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/wise-dsa/DirectCone?DSACAT=WISE&DSATAB=wise_allskysc& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://wise2.ipac.caltech.edu/docs/release/allsky/
#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request# + Millennium Galaxy Catalogue (MGC)The Millennium Galaxy Catalogue (MGC) is a 37.5 deg2, medium-deep, B-band imaging survey obtained with the Wide Field Camera on the INT. The survey region is a long, 35 arcmin wide strip along the equator, covering from 10h 00m to 14h 45m and is fully contained within the regions of both the Two Degree Field Galaxy Redshift Survey (2dFGRS) and the Sloan Digital Sky Survey (SDSS).WFAU, Institute for Astronomy, University of Edinburgh#Optical#ivo://wfau.roe.ac.uk/mgc-dsa2013-05-30T16:20:00#MGC B-band Galaxy Survey##Survey##Research# + 1.0ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/mgc-dsa/DirectCone?DSACAT=MGC&DSATAB=mgcDetection& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://www.eso.org/~jliske/mgc/
#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request# + GALEX Release 6The Galaxy Evolution Explorer (GALEX) satellite is a NASA mission led by the California Institute of Technology to investigate how star formation in galaxies evolved from the early Universe up to the present. GALEX uses microchannel plate detectors to obtain direct images in the near-UV (NUV) and far-UV (FUV) and a grism to disperse light for low resolution spectroscopyWFAU, Institute for Astronomy, University of Edinburgh#UV#ivo://wfau.roe.ac.uk/galexgr6-dsa2013-05-30T16:19:49#UV##Survey##Research# + 6ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/galexgr6-dsa/DirectCone?DSACAT=GALEXGR6&DSATAB=photoobjall& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://galex.stsci.edu/GR6/
#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request# + Deep Near Infrared Survey of the Southern Sky (DENIS)Catalog of astrometry and photometry of detected point sources in the Far red optical (0.82-micron I-band) and near-infrared (1.25-micron J- and 2.15-micron Ks bands). ~16,700 square degrees of the southern skyWFAU, Institute for Astronomy, University of Edinburgh#Infrared#ivo://wfau.roe.ac.uk/denis-dsa2013-05-30T16:19:12#IR##Survey##Research# + 1.0ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/denis-dsa/DirectCone?DSACAT=DENIS&DSATAB=denisDR3Source& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://irsa.ipac.caltech.edu/Missions/denis.html
#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request# + SDSS DR9 - Sloan Digital Sky Survey Data Release 9This is an AstroGrid Dataset Access installation of the Sloan Digital Sky Survey (SDSS) DR9 hosted by the Wide Field Astronomy Unit (WFAU), University of Edinburgh. WFAU would like to thank John Hopkins University and the University of Chicago for permission to host the data.WFAU, Institute for Astronomy, University of Edinburgh + ivo://wfau.roe.ac.uk/sdssdr9-dsa2013-05-07T16:08:44#Stars,Survey,Galaxy##Survey##Research# + Data Release 9ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/sdssdr9-dsa/DirectCone?DSACAT=SDSS_DR9&DSATAB=PhotoObjAll& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://www.sdss.org/dr9/
#HTTP Request#vo_marsaugust onboard Phobos2, atmospheric composition of mars + VO-Paris Data Centre - IPSL + ivo://vopdc.obspm/ipsl/epn_august2012-09-07T18:00:00.00#Virtual Observatory#Planets##Archive##General#University#Research#Amateur# + 1 + + + + + + + + + + ivo://vopdc.obspm/IPSLTBD
#HTTP Request#HTTP Request#HTTP Request#HTTP Request#Web Page#GAVO DC TAPGAVO Data Center TAP serviceThe GAVO Data Center's TAP end point. The Table Access Protocol (TAP) lets you execute queries against our database tables, inspect various metadata, and upload your own data. It is thus the VO's premier way to access public data holdings. Tables exposed through this endpoint include: amanda.nucand, apo.frames, arigfh.gfh, arigfh.id, arigfh.identified, arigfh.master, arigfh.nid, arigfh.unidentified, arihip.main, basti.chemical, basti.key_points, basti.out_file, basti.physic_file, basti.program_param, basti.proprieties, basti.scenario, basti.units, browndwarfs.cat, califadr1.cubes, califadr1.fluxposv1200, califadr1.fluxposv500, califadr1.fluxv1200, califadr1.fluxv500, califadr1.objects, cars.images, cars.srccat, carsarcs.meta, danish.data, dmubin.main, fk6.fk6join, fk6.part1, fk6.part3, gcpms.data, glots.columns, glots.services, glots.tables, gums.galaxies, gums.lmc, gums.mw, gums.quasars, gums.smc, gums.sn, hiicounter.data, hipparcos.main, icecube.nucand, inflight.data, ivoa.obscore, katkat.katkat, lightmeter.measurements, lightmeter.stations, liverpool.rawframes, lspm.main, lsw.plates, maidanak.rawframes, mcextinct.exts, mlqso.cubes, mpc.mpcorb, obscode.data, ohmaser.bibrefs, ohmaser.masers, plc.data, potsdam.plates, potsdam.rawplates, ppmx.data, ppmxl.main, ppmxl.usnocorr, rave.dr3, rave.main, rr.capability, rr.interface, rr.intf_param, rr.relationship, rr.res_date, rr.res_detail, rr.res_role, rr.res_schema, rr.res_table, rr.resource, rr.stc_redshift, rr.stc_spatial, rr.stc_spectral, rr.stc_temporal, rr.subject, rr.table_column, rr.validation, sdssdr7.sources, spm4.main, supercosmos.sources, tap_schema.columns, tap_schema.examples, tap_schema.groups, tap_schema.key_columns, tap_schema.keys, tap_schema.schemas, tap_schema.tables, taptest.main, theossa.data, twomass.data, ucac3.icrscorr, ucac3.main, ucac3.ppmxlcross, ucac4.main, usnob.data, usnob.platecorrs, usnob.plates, usnob.ppmxcross, usnob.spurious, usnob.twomasscross, veronqsos.data.The GAVO DC team + ivo://org.gavo.dc/__system__/tap/run2013-01-28T11:27:33#Virtual observatory#Catalogs#ADQL# + + + + TableAccessivo://ivoa.net/std/TAP + ParamHTTP + stdhttp://dc.zah.uni-heidelberg.de/__system__/tap/run/tap + + + + http://dc.zah.uni-heidelberg.de/__system__/tap/run/info
#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#VVV DR1VVV DR1 - VISTA Variables in the Via Lactea surveyThe VVV survey will perform wide FOV multi-epoch observations of the Galaxy's bulge and part of the disk, providing the astronomical public community with a high resolution 3-D (or 4-D if you include the time dimension) map of the bulge.WFAU, Institute for Astronomy, University of Edinburgh#Infrared#ivo://wfau.roe.ac.uk/vvvDR1-dsa2012-07-17T15:36:05#Infrared, survey, Milky Way, bulge##Survey##Research# + Data Release 1ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/vvvDR1-dsa/DirectCone?DSACAT=VVV_DR1&DSATAB=vvvSource& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://mwm.astro.puc.cl/mw/index.php/Main_Page
#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#VMC DR1VMC DR1 - VISTA Magellanic System surveyThe VMC survey aims to obtain YJKs band photometry across the system down to Ks=20.3 at S/N=10. This sensitivity corresponds to the bottom of the red giant branch field stellar population and allows us to determine the global spatially resolved star formation history with unprecedented quality and to construct a three-dimensional map of the system. A wide-area encompassing the D25 as well as major features delineated by the distribution of stars and HI gas, will both trace the structure of the galaxies and signatures of past and present interactions. Contemporary optical and kinematic observations of comparable sensitivity will provide the community with a superior database for future studies of the system and will give us an excellent insight as to what has happened elsewhere in the Universe.WFAU, Institute for Astronomy, University of Edinburgh#Infrared#ivo://wfau.roe.ac.uk/vmcDR1-dsa2012-07-17T16:00:21#Infrared, survey, galaxy, Marellanic Cloud##Survey##Research# + Data Release 1ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/vmcDR1-dsa/DirectCone?DSACAT=VMC_DR1&DSATAB=vmcSource& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://www.star.herts.ac.uk/~mcioni/vmc/
#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#VIKING DR2VIKING - VISTA Kilo-degree Infrared Galaxy survey Data Release 2The VIKING survey is the VISTA counterpart to the VST KIDS survey. The KIDS survey will cover 1500 deg^2 in u,g,r,i divided in two stripes (NGP, centred on equator ; SGP, centred on Dec = -30). The matching VISTA survey will cover (almost) all of these stripes in Z,Y,J,H, Ks with ~ 400s exposures per band.WFAU, Institute for Astronomy, University of Edinburgh#Infrared#ivo://wfau.roe.ac.uk/vikingDR2-dsa2012-07-17T15:45:28#Infrared, survey, galaxy, KIDS##Survey##Research# + Data Release 2ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/vikingDR2-dsa/DirectCone?DSACAT=VIKING_DR2&DSATAB=vikingSource& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://www.astro-wise.org/projects/VIKING/
#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#VIDEO DR2VIDEO DR2 - VISTA Deep Extragalactic Observations surveyThe VIDEO survey is a 30 sq. degree, Z,Y,J,H,K survey that is specifically designed to enable exploration of the main issues in observational cosmology. It allows galaxy and cluster/structure evolution to be traced as a function of both epoch and environment from the present day out to z=4 and AGN/QSO evolution up to and into the epoch of reionization at z > 6. The multi-band nature of the survey ensures many key science drivers can be tackled using the survey alone, without recourse to data from other wavebands.WFAU, Institute for Astronomy, University of Edinburgh#Infrared#ivo://wfau.roe.ac.uk/videoDR2-dsa2012-07-17T16:13:45#Observational cosmology, galaxy, cluster, evolution, infrared##Survey##Research# + Data Release 2ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/videoDR2-dsa/DirectCone?DSACAT=VIDEO_DR2&DSATAB=videoSource& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://arxiv.org/abs/1206.4263
#HTTP Request#apisauroral planetary imaging and spectroscopyPlanetary aurorae are powerful emissions radiated from auroral regions of magnetized planets by accelerated charged particles, in a wide range of wavelengths (from radio to X-rays). The UV range in particular is adequate to measure collisionaly excited transitions of H and H2, the dominant species in the upper atmosphere of giant planets, produced by precipitating auroral particles, and benefits a good angular resolution. Auroral UV observations therefore provide a rich source of informations on planetary atmospheres and magnetospheres. They also offer a unique diagnostic to remotely probe the solar wind activity throughout the heliosphere..VO-Paris Data Centre - LESIA + ivo://vopdc.obspm/lesia/epn_apis2012-09-07T19:00:00.00#Virtual Observatory#Planets##Archive##General#University#Research#Amateur# + 1 + + + + + + + + + + ivo://vopdc.obspm/lesiaTBD
#HTTP Request#titanTemperature vertical profiles in the Titan middle atmosphereThis database displays the temperature vertical profiles in Titan's atmosphere at nine different latitudes between 100 and 500 km. These profiles were retrieved from the infrared spectra acquired by the Composite Infrared Spectrometer (CIRS) aboard the Cassini spacecraft. The retrieval method and the description of the used dataset is detailed by Vinatier et al., 2009, Analysis of Cassini/CIRS limb spectra of Titan acquired during the nominal mission. I: Hydrocarbons, nitriles and CO2 vertical mixing ratio profiles, Icarus, in press. doi:10.1016/j.icarus.2009.08.013.VO-Paris Data Centre - LESIA + ivo://vopdc.obspm/lesia/epn_titan2012-09-07T19:00:00.00#Virtual Observatory#Planets##Archive##General#University#Research#Amateur# + 1 + + + + + + + + + + ivo://vopdc.obspm/lesiaTBD
#HTTP Request#bdipBase de Donnees d'Images PlanetairesThe database of planetary images (BDIP) comes from the digitization of photographs collected and preserved by the Center for Photographic Documentation of the planets held by the IAU at the Meudon Observatory in 1961 under the the curation of J.H. Focas (IAUC, 12th General Assembly, Report 1964). A similar center was established at the Lowell Observatory in Arizona, under the responsibility of W.A. Baum. The photographs were duplicated between the two centers.VO-Paris Data Centre - LESIA + ivo://vopdc.obspm/lesia/epn_bdip2012-09-07T19:00:00.00#Virtual Observatory#Planets##Archive##General#University#Research#Amateur# + 1 + + + + + + + + + + ivo://vopdc.obspm/lesiaTBD
#HTTP Request#BASECOMThe Nançay Cometary DatabaseSince 1973, the 18-cm lines of the OH radical have been systematically observed in a number of comets with the Nançay radio telescope. This allowed an evaluation of the cometary water… production rates and their evolution with time, as well as a study of several physical processes: the excitation mechanisms of the OH radio lines, the expansion of the cometary atmospheres, their anisotropy in relation with non-gravitational forces, the Zeeman effect in relation with the cometary magnetic field. The Nançay observations of 53 cometary apparitions between 1982 and 2009 are now organized in this database.VO-Paris Data Centre - LESIA#Radio#ivo://vopdc.obspm/lesia/basecom2010-09-27T13:00:00#Virtual Observatory#Spectrum#Comets##Archive##General#University#Research#Amateur# + 1 + + + + + + + + + + ivo://vopdc.obspm/lesiahttp://www.lesia.obspm.fr/planeto/cometes/basecom/
#HTTP Request#TBDAbundance vertical profiles in the Titan middle atmosphereThis database displays the abundance vertical profiles of C2H2, C2H4, C2H6, C3H8, CH3C2H, C4H2, C6H6, HCN, HC3N and CO2 in Titan's atmosphere at nine different latitudes between 100 and 500 km.… These profiles were retrieved from the infrared spectra acquired by the Composite Infrared Spectrometer (CIRS) aboard the Cassini spacecraft. The retrieval method and the description of the used dataset is detailed by Vinatier et al., 2009, Analysis of Cassini/CIRS limb spectra of Titan acquired during the nominal mission. I: Hydrocarbons, nitriles and CO2 vertical mixing ratio profiles, Icarus, in press. doi:10.1016/j.icarus.2009.08.013.VO-Paris Data Centre - LESIA + ivo://vopdc.obspm/lesia/titan/abundance2010-09-27T13:00:00#Virtual Observatory#Planets##Archive##General#University#Research#Amateur# + 1 + + + + + + + + + + ivo://vopdc.obspm/lesiaTBD
#HTTP Request#TBDTemperature vertical profiles in the Titan middle atmosphereThis database displays the temperature vertical profiles in Titan's atmosphere at nine different latitudes between 100 and 500 km. These profiles were retrieved from the infrared spectra acquired… by the Composite Infrared Spectrometer (CIRS) aboard the Cassini spacecraft. The retrieval method and the description of the used dataset is detailed by Vinatier et al., 2009, Analysis of Cassini/CIRS limb spectra of Titan acquired during the nominal mission. I: Hydrocarbons, nitriles and CO2 vertical mixing ratio profiles, Icarus, in press. doi:10.1016/j.icarus.2009.08.013.VO-Paris Data Centre - LESIA + ivo://vopdc.obspm/lesia/titan/temperature2010-09-27T13:00:00#Virtual Observatory#Planets##Archive##General#University#Research#Amateur# + 1 + + + + + + + + + + ivo://vopdc.obspm/lesiaTBD
#HTTP Request# + HEASARC Xamin Catalog InterfaceThe HEASARC is NASA domain archive for high-energy and microwave astronomy. The Xamin interface provides access to over 600 observation and object tables. This includes observation tables for more than 30 missions and observatories and hundreds of derived object tables. Non-high energy tables are included to make it easier for users to compare information.NASA/HEASARC + ivo://nasa.heasarc/services/xamin2012-01-19T00:00:00#high energy and microwave astronomy##Catalog##Research# + + + + + + + + + + + + + http://heasarc.gsfc.nasa.gov
#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#2XMMXMM-Newton Serendipitous Source Catalogue (2XMM)XMM is the second comprehensive catalogue of serendipitous X-ray sources from the European Space Agency's (ESA) XMM-Newton observatory. The 2XMM catalogue is the largest X-ray source catalogue ever produced, containing almost twice as many discrete sources as either the ROSAT survey or pointed catalogues. 2XMM complements deeper Chandra and XMM-Newton small area surveys, probing a much larger sky area.WFAU, Institute for Astronomy, University of Edinburgh + ivo://wfau.roe.ac.uk/xmm_dsa2012-07-18T12:52:10#x-ray xray XMM##Catalog##Research# + Version 2ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/xmm-dsa/DirectCone?DSACAT=TwoXMM&DSATAB=twoxmm& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://xmmssc-www.star.le.ac.uk/Catalogue/2XMM/
#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#VHS DR1VHS DR1 - VISTA Hemisphere Survey Data Release 1The VHS will image the entire ~20 000 square degrees of the Southern Sky, with the exception of the areas already covered by the VIKING and VVV surveys, in J and Ks. The resulting data will be about 4 magnitudes deeper than 2MASS and DENIS. The 5000 square degrees covered by the Dark Energy Survey (DES), another imaging survey scheduled to begin in 2010 at the CTIO 4 metre Blanco telescope, will also be observed in H-band. The area around both of the Galactic Caps will be observed in Y- and H- band as well to be combined with the data from the VST ATLAS survey. The main science drivers of the VHS include: examining low mass and nearby stars, studying the merger history of the Galaxy, measuring the properties of Dark Energy through the examination of large-scale structure to a redshift of ~1, and searches for high redshift quasars.WFAU, Institute for Astronomy, University of Edinburgh#Infrared#ivo://wfau.roe.ac.uk/vhsDR1-dsa2012-07-17T15:37:19#Stars,Survey,Galaxy, low mass stars, dark energy##Survey##Research# + Data Release 1ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/vhsDR1-dsa/DirectCone?DSACAT=VHS_DR1&DSATAB=vhsSource& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://www.ast.cam.ac.uk/~rgm/vhs/
#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request# + UKIDSS DR2 World ReleaseWorld release UKIRT Infrared Deep Sky Survey Data Release 2 data for demonstration purposes (contains only a tiny sample of data).WFAU, Institute for Astronomy, University of Edinburgh + ivo://wfau.roe.ac.uk/ukidssWorld-dsa2010-02-15T13:56:33#Infrared, survey, galaxy, point source##Catalog##Research# + World Release DR2ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/ukidssWorld-dsa/SubmitCone?DSACAT=UKIDSS_World_Release&DSATAB=lasSource& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://surveys.roe.ac.uk/wsa/publicData.html
#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#UKIDSS DR8UKIDSS DR8 - UKIRT Infrared Deep Sky Survey Data Release 8This DSA hosts data release 8 of the UKIRT Infrared Deep Sky Survey housed at the Wide Field Astronomy Unit at the Univeristy of Edinburgh. This catalog contains WFCAM data primarily originating from four of the five UKIDSS surveys: Large Area Survey, Galactic Clusters Survey, Deep Extragalactic Survey, and Ultra Deep Survey. The Galactic Plane Survey will be available in January 2014. (see www.ukidss.org for survey descriptions)WFAU, Institute for Astronomy, University of Edinburgh#Infrared#ivo://wfau.roe.ac.uk/ukidssDR8-dsa2013-12-17T12:04:15#Infrared, survey, galaxy, point source##Survey##Research# + Data Release 8ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/ukidssDR8-dsa/DirectCone?DSACAT=UKIDSS_DR8&DSATAB=lasSource& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://surveys.roe.ac.uk/wsa
#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#UKIDSS DR7UKIDSS DR7 - UKIRT Infrared Deep Sky Survey Data Release 7This DSA hosts data release 7 of the UKIRT Infrared Deep Sky Survey housed at the Wide Field Astronomy Unit at the Univeristy of Edinburgh. This catalog contains WFCAM data primarily originating from three of the five UKIDSS surveys: Large Area Survey, Galactic Clusters Survey, Deep Extragalactic Survey. The Galactic Plane Survey will be available in march 2012. (see www.ukidss.org for survey descriptions)WFAU, Institute for Astronomy, University of Edinburgh#Infrared#ivo://wfau.roe.ac.uk/ukidssDR7-dsa2012-07-18T12:47:40#Infrared, survey, galaxy, point source##Survey##Research# + Data Release 7ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/ukidssDR7-dsa/DirectCone?DSACAT=UKIDSS_DR7&DSATAB=lasSource& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://surveys.roe.ac.uk/wsa
#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#UKIDSS DR6UKIDSS DR6 - UKIRT Infrared Deep Sky Survey Data Release 6This DSA hosts data release 6 of the UKIRT Infrared Deep Sky Survey housed at the Wide Field Astronomy Unit at the Univeristy of Edinburgh. This catalog contains WFCAM data primarily originating from four of the five UKIDSS surveys: Large Area Survey, Galactic Clusters Survey, Deep Extragalactic Survey and the Galactic Plane Survey. (see www.ukidss.org for survey descriptions)WFAU, Institute for Astronomy, University of Edinburgh#Infrared#ivo://wfau.roe.ac.uk/ukidssDR6-dsa2012-07-18T12:46:08#Infrared, survey, galaxy, point source##Survey##Research# + Data Release 6ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/ukidssDR6-dsa/DirectCone?DSACAT=UKIDSS_DR6&DSATAB=lasSource& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://surveys.roe.ac.uk/wsa
#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#UKIDSS DR5UKIDSS DR5 - UKIRT Infrared Deep Sky Survey Data Release 5This DSA hosts data release 5 of the UKIRT Infrared Deep Sky Survey housed at the Wide Field Astronomy Unit at the Univeristy of Edinburgh. This catalog contains WFCAM data primarily originating from four of the five UKIDSS surveys: Large Area Survey, Galactic Clusters Survey, Deep Extragalactic Survey and the Ultra Deep Survey. (see www.ukidss.org for survey descriptions)WFAU, Institute for Astronomy, University of Edinburgh#Infrared#ivo://wfau.roe.ac.uk/ukidssDR5-dsa2012-07-18T12:43:17#Infrared, survey, galaxy, point source##Survey##Research# + Data Release 5ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/ukidssDR5-dsa/DirectCone?DSACAT=UKIDSS_DR5&DSATAB=lasSource& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://surveys.roe.ac.uk/wsa
#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#UKIDSS DR4UKIDSS DR4 - UKIRT Infrared Deep Sky Survey Data Release 4This DSA hosts data release 4 of the UKIRT Infrared Deep Sky Survey housed at the Wide Field Astronomy Unit at the Univeristy of Edinburgh. This catalog contains WFCAM data primarily originating from four of the five UKIDSS surveys: Large Area Survey, Galactic Clusters Survey, Deep Extragalactic Survey and the Ultra Deep Survey. The data for the Galactic Plane Survey will not be available until April 22, 2010. (see www.ukidss.org for survey descriptions)WFAU, Institute for Astronomy, University of Edinburgh#Infrared#ivo://wfau.roe.ac.uk/ukidssDR4-dsa2012-07-18T12:42:31#Infrared, survey, galaxy, point source##Survey##Research# + Data Release 4ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/ukidssDR4-dsa/DirectCone?DSACAT=UKIDSS_DR4&DSATAB=lasSource& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://surveys.roe.ac.uk/wsa
#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#UKIDSS DR3UKIDSS DR3 - UKIRT Infrared Deep Sky Survey Data Release 3This DSA hosts data release 3 of the UKIRT Infrared Deep Sky Survey housed at the Wide Field Astronomy Unit at the Univeristy of Edinburgh. This catalog contains WFCAM data primarily originating from the five UKIDSS surveys: Large Area Survey, Galactic Plane Survey, Galactic Clusters Survey, Deep Extragalactic Survey and the Ultra Deep Survey (see the www.ukidss.org for survey descriptions).WFAU, Institute for Astronomy, University of Edinburgh#Infrared#ivo://wfau.roe.ac.uk/ukidssDR3-dsa2012-07-18T12:41:51#Infrared, survey, galaxy, point source##Survey##Research# + Data Release 3ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/ukidssDR3-dsa/DirectCone?DSACAT=UKIDSS_DR3&DSATAB=lasSource& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://surveys.roe.ac.uk/wsa
#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#UKIDSS DR2UKIDSS DR2 - UKIRT Infrared Deep Sky Survey Data Release 2This DSA hosts data release 2 of the UKIRT Infrared Deep Sky Survey housed at the Wide Field Astronomy Unit at the Univeristy of Edinburgh. This catalog contains WFCAM data primarily originating from the five UKIDSS surveys: Large Area Survey, Galactic Plane Survey, Galactic Clusters Survey, Deep Extragalactic Survey and the Ultra Deep Survey (see the www.ukidss.org for survey descriptions).WFAU, Institute for Astronomy, University of Edinburgh#Infrared#ivo://wfau.roe.ac.uk/ukidssDR2-dsa2012-07-18T12:41:11#Infrared, survey, galaxy, point source##Survey##Research# + Data Release 2ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/ukidssDR2-dsa/DirectCone?DSACAT=UKIDSS_DR2&DSATAB=lasSource& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://surveys.roe.ac.uk/wsa
#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#UKIDSS DR1UKIDSS DR1 - UKIRT Infrared Deep Sky Survey Data Release 1This DSA hosts data release 1 of the UKIRT Infrared Deep Sky Survey housed at the Wide Field Astronomy Unit at the Univeristy of Edinburgh. This catalog contains WFCAM data primarily originating from the five UKIDSS surveys: Large Area Survey, Galactic Plane Survey, Galactic Clusters Survey, Deep Extragalactic Survey and the Ultra Deep Survey (see the www.ukidss.org for survey descriptions).WFAU, Institute for Astronomy, University of Edinburgh#Infrared#ivo://wfau.roe.ac.uk/ukidssDR1-dsa2012-07-18T12:40:27#Infrared, survey, galaxy, point source##Survey##Research# + Data Release 1ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/ukidssDR1-dsa/DirectCone?DSACAT=UKIDSS_DR1&DSATAB=lasSource& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://surveys.roe.ac.uk/wsa
#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#2MASSTwo Micron All Sky Survey (2MASS)The Two Micron All Sky Survey (2MASS) will provide a uniform survey of the entire sky at three near-infrared wavebands: J(lambdaeff = 1.25 micrometers), H(lambdaeff = 1.65 micrometers), and Ks(lambdaeff = 2.16 micrometers). A major goal of the survey is to probe large scale structures in the Milky Way and in the Local Universe, exploiting the relatively high transparency of the interstellar medium in the near-infrared, and the high near-infrared luminosities of evolved low- and intermediate-mass stars.Home page at http://pegasus.phast.umass.edu/WFAU, Institute for Astronomy, University of Edinburgh#Infrared#ivo://wfau.roe.ac.uk/twomass-dsa2012-08-02T15:31:26#Infrared all-sky survey##Catalog##Research# + Version 1ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/twomass-dsa/DirectCone?DSACAT=TWOMASS&DSATAB=twomass_psc& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://www.ipac.caltech.edu/2mass/
#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#SuperCOSMOSSuperCOSMOS Science Archive (SSA)The SuperCOSMOS data held in the SSA primarily originate from scans of Palomar and UK Schmidt blue, red and near-IR southern sky surveys. The ESO Schmidt R (dec < -17.5) and Palomar POSS-I E (dec > -17.5) surveys have also been scanned and provide a 1st epoch red measurement. Further details on the surveys, the scanning process and the raw parameters extracted can be found on the further information link. The SSA is housed in a relational database running on Microsoft SQL Server 2000. Data are stored in tables which are inter-linked via reference ID numbers. In addition to the astronomical object catalogues these tables also contain information on the plates that were scanned, survey field centres and calibration coefficients. Most user science queries will only need to access the SOURCE table or to a lesser extent the DETECTION table.WFAU, Institute for Astronomy, University of Edinburgh#Optical#ivo://wfau.roe.ac.uk/ssa-dsa2012-07-19T11:53:55#Digitised photographic optical all-sky photometric astrometric survey##Catalog##Research# + Version 1ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/ssa-dsa/DirectCone?DSACAT=SSA&DSATAB=Detection& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://surveys.roe.ac.uk/ssa
#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#SDSS DR8SDSS DR8 - Sloan Digital Sky Survey Data Release 8This is an AstroGrid Dataset Access installation of the Sloan Digital Sky Survey (SDSS) DR8 hosted by the Wide Field Astronomy Unit (WFAU), University of Edinburgh. WFAU would like to thank John Hopkins University and the University of Chicago for permission to host the data.WFAU, Institute for Astronomy, University of Edinburgh#Optical#ivo://wfau.roe.ac.uk/sdssdr8-dsa2012-07-18T12:37:33#Stars,Survey,Galaxy##Survey##Research# + Data Release 8ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/sdssdr8-dsa/DirectCone?DSACAT=SDSS_DR8&DSATAB=PhotoObjAll& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://www.sdss.org/dr8/
#Catalog#Catalog#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#SDSS DR7SDSS DR7 - Sloan Digital Sky Survey Data Release 7This is an AstroGrid Dataset Access installation of the Sloan Digital Sky Survey (SDSS) DR7 hosted by the Wide Field Astronomy Unit (WFAU), University of Edinburgh. WFAU would like to thank John Hopkins University and the University of Chicago for permission to host the data.WFAU, Institute for Astronomy, University of Edinburgh#Optical#ivo://wfau.roe.ac.uk/sdssdr7-dsa2012-07-18T12:36:49#Stars,Survey,Galaxy##Survey##Research# + Data Release 7ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/sdssdr7-dsa/DirectCone?DSACAT=SDSS_DR7&DSATAB=Galaxy& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://www.sdss.org/dr7/
#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#SDSS DR6SDSS DR6 SEGUE - Sloan Digital Sky Survey Data Release 6This is an AstroGrid Dataset Access installation of the Sloan Digital Sky Survey (SDSS) DR6 SEGUE hosted by the Wide Field Astronomy Unit (WFAU), University of Edinburgh. WFAU would like to thank John Hopkins University and the University of Chicago for permission to host the data. This database does not include the entire DR6 release, only the SEGUE portion.WFAU, Institute for Astronomy, University of Edinburgh#Optical#ivo://wfau.roe.ac.uk/sdssdr6-dsa2012-07-18T12:36:37#Stars,Survey,Galaxy##Survey##Research# + Data Release 6ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/sdssdr6-dsa/DirectCone?DSACAT=SDSS_DR5&DSATAB=PhotoObjAll& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://www.sdss.org/dr6/
#Catalog#Catalog#Catalog#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#SDSS DR5SDSS DR5 - Sloan Digital Sky Survey Data Release 5This is an AstroGrid Dataset Access installation of the Sloan Digital Sky Survey (SDSS) DR5 hosted by the Wide Field Astronomy Unit (WFAU), University of Edinburgh. WFAU would like to thank John Hopkins University and the University of Chicago for permission to host the data.WFAU, Institute for Astronomy, University of Edinburgh#Optical#ivo://wfau.roe.ac.uk/sdssdr5-dsa2012-07-18T12:35:04#Stars,Survey,Galaxy##Survey##Research# + Data Release 5ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/sdssdr5-dsa/DirectCone?DSACAT=SDSS_DR5&DSATAB=SpecObj& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://www.sdss.org/dr5/
#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#SDSS DR3SDSS DR3 - Sloan Digital Sky Survey Data Release 3This is an AstroGrid Dataset Access installation of the Sloan Digital Sky Survey (SDSS) DR3 hosted by the Wide Field Astronomy Unit (WFAU), University of Edinburgh. WFAU would like to thank John Hopkins University and the University of Chicago for permission to host the data.WFAU, Institute for Astronomy, University of Edinburgh#Optical#ivo://wfau.roe.ac.uk/sdssdr3-dsa2012-07-18T12:34:44#Stars,Survey,Galaxy##Survey##Research# + Data Release 3ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/sdssdr3-dsa/DirectCone?DSACAT=SDSS_DR3&DSATAB=PhotoObjAll& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://www.sdss.org/dr3/
#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#ROSATRontgen Satellite Archive (ROSAT)The Rontgen Satellite Archive is an implementation of the ROSAT All-Sky Survey Bright Source Catalogue (RASS-BSC, revision 1RXS) and the ROSAT All-Sky Survey Faint Source Catalogue (RASS-FSC, revision 1RXS). The RASS-BSC is derived from the all-sky survey performed during the first half year of the ROSAT mission in 1990/91. 18,811 sources are catalogued, with a limiting ROSAT PSPC countrate of 0.05 cts/s in the 0.1-2.4 keV energy band. The sources have a detection likelihood of at least 15 and contain at least 15 source photons. At a brightness limit of 0.1 cts/s (8,547 sources) the catalogue represents a sky coverage of 92%. The typical positional accuracy is 30 arcsec. The RASS-FSC is derived from the all-sky survey performed during the ROSAT mission in the energy band 0.1- 2.4 keV. 105,924 sources are catalogued and represent the faint extension to the RASS bright source catalogue. The sources have a detection likelihood of at least 7 and contain at least 6 source photons. (The likelihood of source detection is defined as L =-ln (1-P) , with P = probability of source detection).WFAU, Institute for Astronomy, University of Edinburgh#X-ray#ivo://wfau.roe.ac.uk/rosat-dsa2012-07-18T12:34:21#ROSAT xray x-ray sources faint bright##Catalog##Research# + revision 1RXSConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/rosat-dsa/DirectCone?DSACAT=ROSAT&DSATAB=rosat_bsc& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://www.mpe.mpg.de/xray/wave/rosat/index.php?lang=en
#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request# + Personal SuperCOSMOS Science Archive (SSA)Small subset of the SuperCOSMOS Science Archive, useful for testing queries. The SuperCOSMOS data held in the SSA primarily originate from scans of Palomar and UK Schmidt blue, red and near-IR southern sky surveys. The ESO Schmidt R (dec < -17.5) and Palomar POSS-I E (dec > -17.5) surveys have also been scanned and provide a 1st epoch red measurement. Further details on the surveys, the scanning process and the raw parameters extracted can be found on the further information link. The SSA is housed in a relational database running on Microsoft SQL Server 2000. Data are stored in tables which are inter-linked via reference ID numbers. In addition to the astronomical object catalogues these tables also contain information on the plates that were scanned, survey field centres and calibration coefficients. Most user science queries will only need to access the SOURCE table or to a lesser extent the DETECTION table.WFAU, Institute for Astronomy, University of Edinburgh#Optical#ivo://wfau.roe.ac.uk/pssa-dsa2011-05-09T11:33:35#Digitised photographic Schmidt field test photometry astrometry##Catalog##Research# + Version 1ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/pssa-dsa/DirectCone?DSACAT=SSA&DSATAB=Detection& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://thoth.roe.ac.uk/ssa/
#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#IRASInfrared Astronomical Satellite Archive (IRAS)The Infrared Astronomical Satellite Archive is an implementation of the IRAS catalogue of Point Sources, Version 2.0 (IPAC 1986). This is a catalogue of some 250,000 well-confirmed infrared point sources observed by the Infrared Astronomical Satellite, i.e., sources with angular extents less than approximately 0.5, 0.5, 1.0, and 2.0 arcmin in the in-scan direction at 12, 25, 60, and 100 microns, respectively.WFAU, Institute for Astronomy, University of Edinburgh#Infrared#ivo://wfau.roe.ac.uk/iras-dsa2012-07-18T12:34:02#Infrared point-source survey##Catalog##Research# + Version 2.0 (IPAC 1986)ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/iras-dsa/DirectCone?DSACAT=IRAS&DSATAB=iras_psc& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://irsa.ipac.caltech.edu/Missions/iras.html
#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#GLIMPSEGLIMPSE (Galactic Legacy Infrared Mid-Plane Survey Extraordinaire)The GLIMPSE (Galactic Legacy Infrared Mid-Plane Survey Extraordinaire) Archive is an implementation of the GLIMPSE Highly Reliable Catalogue (GLMC, Intermediate revision; dated 9th April 2005) and the GLIMPSE More Complete Archive (GLMA, Intermediate revision; dated 9th April 2005). This implementation uses the same default values as specified by GLIMPSE.WFAU, Institute for Astronomy, University of Edinburgh#Infrared#ivo://wfau.roe.ac.uk/glimpse-dsa2012-07-18T12:33:44#Galactic Legacy Infrared Mid-Plane Survey GLIMPSE##Catalog##Research# + Intermediate revision; dated 9th April 2005ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/glimpse-dsa/DirectCone?DSACAT=GLIMPSE&DSATAB=glimpse_hrc_inter& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://www.astro.wisc.edu/sirtf/
#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#FIRSTFIRST Survey Catalogue (03Apr11 Version)FIRST (Faint Images of the Radio Sky at Twenty-cm) is a project designed to produce the radio equivalent of the Palomar Observatory Sky Survey over 10,000 square degrees of the North and South Galactic Caps. The catalogue covers a total of about 9033 square degrees of sky (8422 square degrees in the north Galactic cap and 611 square degrees in the south Galactic cap.)WFAU, Institute for Astronomy, University of Edinburgh#Radio#ivo://wfau.roe.ac.uk/first-dsa2012-07-18T12:33:30#Faint Images of the Radio Sky at Twenty-cm FIRST##Catalog##Research# + 03Apr11 VersionConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/first-dsa/DirectCone?DSACAT=FIRST&DSATAB=firstSource& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://sundog.stsci.edu/first/catalogs/readme.html
#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#AstroDAbisAstroDAbis Notation ServiceThe AstroDAbis service database stores user notations of celestial objects found in VO enabled datasets around the world.WFAU, Institute for Astronomy, University of Edinburgh + ivo://wfau.roe.ac.uk/astrodabis-dsa2012-07-18T12:33:22#AstroDAbis, notation##Other##Research# + Version 1 + + + + + + + + + + ivo://wfau.roe.ac.ukhttp://astrodabis.roe.ac.uk/astrodabis-abd
#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#6dF DR36dF Galaxy Survey Data Release 3The 6dF Galaxy Survey (6dFGS) aims to measure the redshifts of around 150 000 galaxies, and the peculiar velocities of a 15 000-member subsample, over almost the entire southern sky. The table called Spectra contains the redshifts and qualities of all the observations. When complete, it will be the largest redshift survey of the nearby Universe, reaching out to about z ~ 0.15, and more than an order of magnitude larger than any peculiar velocity survey to date. The targets are all galaxies brighter than K tot = 12.75 in the 2MASS Extended Source Catalog (XSC), supplemented by 2MASS and SuperCOSMOS galaxies that complete the sample to limits of (H, J , r F, bJ) = (13.05, 13.75, 15.6, 16.75). This is the Data Release 3 version.WFAU, Institute for Astronomy, University of Edinburgh#Optical#ivo://wfau.roe.ac.uk/6dfdr3-dsa2012-07-18T12:22:27#6dF survey galaxy galaxies redshift redshifts 2MASS##Catalog##Research# + Data Release 3ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/6dfdr3-dsa/DirectCone?DSACAT=SixdF&DSATAB=twomass& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://www-wfau.roe.ac.uk/6dfgs/
#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#Catalog#HTTP Request#Custom Service#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#HTTP Request#6dF DR26dF Galaxy Survey Data Release 2The 6dF Galaxy Survey (6dFGS) aims to measure the redshifts of around 150 000 galaxies, and the peculiar velocities of a 15 000-member subsample, over almost the entire southern sky. The table called Spectra contains the redshifts and qualities of all the observations. When complete, it will be the largest redshift survey of the nearby Universe, reaching out to about z ~ 0.15, and more than an order of magnitude larger than any peculiar velocity survey to date. The targets are all galaxies brighter than K tot = 12.75 in the 2MASS Extended Source Catalog (XSC), supplemented by 2MASS and SuperCOSMOS galaxies that complete the sample to limits of (H, J , r F, bJ) = (13.05, 13.75, 15.6, 16.75).WFAU, Institute for Astronomy, University of Edinburgh#Optical#ivo://wfau.roe.ac.uk/6df-dsa2012-07-18T12:22:20#6dF survey galaxy galaxies redshift redshifts 2MASS##Catalog##Research# + Data Release 2ConeSearchivo://ivoa.net/std/ConeSearch + ParamHTTP + stdhttp://wfaudata.roe.ac.uk/6df-dsa/DirectCone?DSACAT=SixdF&DSATAB=twomass& + 1.5000002000000ivo://wfau.roe.ac.ukhttp://www-wfau.roe.ac.uk/6dfgs/
+ + diff --git a/applications/gaia/gaiavo/library/GaiaVOCat.tcl b/applications/gaia/gaiavo/library/GaiaVOCat.tcl index f2e135fd605..8f6e3646c4c 100644 --- a/applications/gaia/gaiavo/library/GaiaVOCat.tcl +++ b/applications/gaia/gaiavo/library/GaiaVOCat.tcl @@ -310,14 +310,17 @@ itcl::class gaiavo::GaiaVOCat { # Called when the user has selected columns to show. public method set_show_cols {cols} { - set show [$w_.cat showcols] - if { "$show" == {} } { - set show [$itk_component(results) get_headings] - } - if { "$show" != "$cols" } { - $w_.cat showcols $cols - cat::CatalogInfo::save {} $w_ 0 + if { [$w_.cat open] } { + set show [$w_.cat showcols] + if { "$show" == {} } { + set show [$itk_component(results) get_headings] + } + if { "$show" != "$cols" } { + $w_.cat showcols $cols + cat::CatalogInfo::save {} $w_ 0 + } } + configure -show_cols $cols } # Clear the table listing. @@ -523,6 +526,52 @@ itcl::class gaiavo::GaiaVOCat { add_help_button vo "About VO services..." {Help on VO in GAIA} } + # Extract an access URL from the given row, given the names of the values + # in headers. Tricky as we have two possible names access_url and + # accessURL from the two registry types. + public proc getAccessURL {headers row} { + + # Nasty external knowledge required as to what kind of registry the row + # came from, so try all known handlers. + foreach handler $reghandlers_ { + set accessurl [$handler get_access_url $headers $row] + if { $accessurl != {} } { + return $accessurl + } + } + return {} + } + + # Extract a name for TAP service from a list of headers and the associated + # data row. + public proc getName {headers row} { + + # Nasty external knowledge required as to what kind of registry the row + # came from, so try all known handlers. + foreach handler $reghandlers_ { + set name [$handler get_name $headers $row] + if { $name != {} } { + return $name + } + } + return {} + } + + # Extract the IVOA identifier for the service from a list of headers + # and the associated data row. + public proc getIdentifier {headers row} { + + # Nasty external knowledge required as to what kind of registry the row + # came from, so try all known handlers. + foreach handler $reghandlers_ { + set id [$handler get_identifier $headers $row] + if { $id != {} } { + return $id + } + } + return {} + } + # Check for a file ~/.skycat/proxies, once each session, and use it to # initialize environment variables for a proxy server. public proc check_proxies {} { @@ -561,6 +610,12 @@ itcl::class gaiavo::GaiaVOCat { itk_option define -help_file help_file Help_File {} itk_option define -help_label help_label Help_Label "On Window..." + # The shortname of the service. + itk_option define -shortname shortname ShortName {} + + # The URL for the service. + itk_option define -accessURL accessURL AccessURL {} + # Protected variables: (available to instance) # -------------------- @@ -584,4 +639,9 @@ itcl::class gaiavo::GaiaVOCat { # Flag: set to 1 after we checked for a proxy server. protected common checked_proxies_ 0 + + # Handlers for different registry types. + protected common regtap_ [::gaiavo::GaiaVORegTapQuery::instance] + protected common regv1_ [::gaiavo::GaiaVORegV1Query::instance] + protected common reghandlers_ "$regtap_ $regv1_" } diff --git a/applications/gaia/gaiavo/library/GaiaVOCatCone.tcl b/applications/gaia/gaiavo/library/GaiaVOCatCone.tcl index e7ed49e1678..e597a12c45a 100644 --- a/applications/gaia/gaiavo/library/GaiaVOCatCone.tcl +++ b/applications/gaia/gaiavo/library/GaiaVOCatCone.tcl @@ -201,29 +201,6 @@ itcl::class gaiavo::GaiaVOCatCone { # Do nothing. } - # Extract the accessURL for the Cone Search service from a list of headers - # and the associated data row. - public proc getAccessURL {headers row} { - eval lassign "$row" $headers - if { [info exists accessURL] } { - return $accessURL - } - return {} - } - - # Extract a name for Cone Search service from a list of headers - # and the associated data row. - public proc getName {headers row} { - eval lassign "$row" $headers - if { [info exists shortName] && $shortName != {} } { - return $shortName - } - if { [info exists title] } { - return $title - } - return {} - } - # Plot the RA and Dec positions on the image using the defined symbols. public method plot {} { @@ -438,12 +415,6 @@ itcl::class gaiavo::GaiaVOCatCone { # Configuration options: (public variables) # ---------------------- - # The shortname of the service. - itk_option define -shortname shortname ShortName {} - - # The accessURL for the Cone Search server. - itk_option define -accessURL accessURL AccessURL {} - # Instance of GAIA to display the catalogue. itk_option define -gaia gaia Gaia {} { set rtdctrl_ [$itk_option(-gaia) get_image] diff --git a/applications/gaia/gaiavo/library/GaiaVOCatRegistry.tcl b/applications/gaia/gaiavo/library/GaiaVOCatRegistry.tcl index dde357576d5..b84cb692d93 100644 --- a/applications/gaia/gaiavo/library/GaiaVOCatRegistry.tcl +++ b/applications/gaia/gaiavo/library/GaiaVOCatRegistry.tcl @@ -170,6 +170,7 @@ itcl::class gaiavo::GaiaVOCatRegistry { -feedbackcommand [code $this set_feedback] \ -command [code $this query_done] \ -query_cmd [code $this query] \ + -show_cols_cmd [code $this set_show_cols] \ -service $itk_option(-service) } pack $itk_component(registry) -side top -fill x @@ -190,7 +191,7 @@ itcl::class gaiavo::GaiaVOCatRegistry { } else { # Need headers and selected row. set headings [$itk_component(results) get_headings] - eval $itk_option(-activate_cmd) "\$headings" "\$args" + eval $itk_option(-activate_cmd) \$headings "$args" } } } @@ -207,7 +208,7 @@ itcl::class gaiavo::GaiaVOCatRegistry { set headings [$w_.cat headings] set result {} foreach row [$w_.cat content] { - eval lassign \$row $headings + set identifier [$query_component_ get_identifier "$headings" "$row"] if { ! [$itk_option(-blacklist) blacklisted $identifier] } { lappend result $row } @@ -217,6 +218,18 @@ itcl::class gaiavo::GaiaVOCatRegistry { $itk_component(results) config -info $info_ } + # Provide access to query_component_ specialisations for different + # registry types. + public method get_identifier {headings row} { + return [$query_component_ get_identifier "$headings" "$row"] + } + public method get_access_url {headings row} { + return [$query_component_ get_access_url "$headings" "$row"] + } + public method get_name {headings row} { + return [$query_component_ get_name "$headings" "$row"] + } + # Add more help if this is just a simple registry query. protected method add_help_menu_ {} { if { $itk_option(-help_file) == {} } { @@ -231,7 +244,7 @@ itcl::class gaiavo::GaiaVOCatRegistry { # The type of operation, whole or row. itk_option define -whole_operation whole_operation Whole_Operation 1 - # The type of services to query for - SSAP, SIAP, ConeSearch. + # The type of services to query for - SSAP, SIAP, ConeSearch, TAP. itk_option define -service service Service SIAP # GaiaVOBlacklist instance that manages the blacklist for the services. diff --git a/applications/gaia/gaiavo/library/GaiaVOCatSIAP.tcl b/applications/gaia/gaiavo/library/GaiaVOCatSIAP.tcl index 71ba7491626..2c16d9df509 100644 --- a/applications/gaia/gaiavo/library/GaiaVOCatSIAP.tcl +++ b/applications/gaia/gaiavo/library/GaiaVOCatSIAP.tcl @@ -239,48 +239,9 @@ itcl::class gaiavo::GaiaVOCatSIAP { } } - # Extract the accessURL for the SIAP service from a list of headers - # and the associated data row. - public proc getAccessURL {headers row} { - eval lassign "$row" $headers - if { [info exists accessURL] } { - return $accessURL - } - return {} - } - - # Extract the IVOA identifier for the SIAP service from a list of headers - # and the associated data row. - public proc getIdentifier {headers row} { - eval lassign "$row" $headers - if { [info exists identifier] } { - return $identifier - } - return {} - } - - # Extract a name for SIAP service from a list of headers - # and the associated data row. - public proc getName {headers row} { - eval lassign "$row" $headers - if { [info exists shortName] && $shortName != {} } { - return $shortName - } - if { [info exists title] } { - return $title - } - return {} - } - # Configuration options: (public variables) # ---------------------- - # The shortname of the service. - itk_option define -shortname shortname ShortName {} - - # The accessURL for the SIAP server. - itk_option define -accessURL accessURL AccessURL {} - # The identifier for the SIAP server. itk_option define -identifier identifier Identifier {} diff --git a/applications/gaia/gaiavo/library/GaiaVOCats.tcl b/applications/gaia/gaiavo/library/GaiaVOCats.tcl index 250b557d1ac..12c6ee029b8 100644 --- a/applications/gaia/gaiavo/library/GaiaVOCats.tcl +++ b/applications/gaia/gaiavo/library/GaiaVOCats.tcl @@ -31,7 +31,7 @@ # Performs the given method on this object. # Copyright: -# Copyright (C) 2008-2009 Science and Technology Facilities Council +# Copyright (C) 2008-2014 Science and Technology Facilities Council # All Rights Reserved. # Licence: @@ -384,12 +384,16 @@ itcl::class gaiavo::GaiaVOCats { # removal). protected method remove_current_ {text} { after 0 [list $itk_component(progressbar) config -text $text] - $itk_component(notebook) delete $current_ - $itk_component(bookmenu) delete $current_ - $itk_component(bookmenu) update_menubutton - incr current_ -1 - incr npages_ -1 - incr ncolumn_ -1 + + # Seems to fail with some visibility timer, so handle that ungracefully. + catch { + $itk_component(notebook) delete $current_ + $itk_component(bookmenu) delete $current_ + $itk_component(bookmenu) update_menubutton + incr current_ -1 + incr npages_ -1 + incr ncolumn_ -1 + } } # Start the queries. diff --git a/applications/gaia/gaiavo/library/GaiaVOCatsSIAP.tcl b/applications/gaia/gaiavo/library/GaiaVOCatsSIAP.tcl index 01deac8a710..f10aadd4153 100644 --- a/applications/gaia/gaiavo/library/GaiaVOCatsSIAP.tcl +++ b/applications/gaia/gaiavo/library/GaiaVOCatsSIAP.tcl @@ -242,6 +242,10 @@ itcl::class gaiavo::GaiaVOCatsSIAP { # Use specialised warning dialog that offers to blacklist the current # server. protected method warning_dialog_ {message} { + + # Truncate message, these can be very long. + set message [string range $message 0 200] + set choice [choice_dialog "$message" "OK Blacklist" "OK" $w_] if { $choice != "OK" } { $itk_option(-blacklist) blacklist $ids_($current_) @@ -251,6 +255,9 @@ itcl::class gaiavo::GaiaVOCatsSIAP { # Use specialised error dialog that offers to blacklist the current # server. protected method error_dialog_ {message} { + # Truncate message, these can be very long. + set message [string range $message 0 200] + set choice [choice_dialog "$message" "OK Blacklist" "OK" $w_] if { $choice != "OK" } { $itk_option(-blacklist) blacklist $ids_($current_) @@ -264,7 +271,9 @@ itcl::class gaiavo::GaiaVOCatsSIAP { set headings [$w_.cat headings] set result {} foreach row [$w_.cat content] { - eval lassign \$row $headings + set identifier [$query_component_ get_identifier "$headings" "$row"] + set accessURL [$query_component_ get_access_url "$headings" "$row"] + set title [$query_component_ get_name "$headings" "$row"] if { ! [$itk_option(-blacklist) blacklisted $identifier] && $accessURL != {} } { lappend result $accessURL $title $identifier } diff --git a/applications/gaia/gaiavo/library/GaiaVORegTapQuery.tcl b/applications/gaia/gaiavo/library/GaiaVORegTapQuery.tcl new file mode 100644 index 00000000000..ba4a4325ef3 --- /dev/null +++ b/applications/gaia/gaiavo/library/GaiaVORegTapQuery.tcl @@ -0,0 +1,256 @@ +#+ +# Name: +# GaiaVORegTapQuery + +# Type of Module: +# [incr Tcl] class + +# Purpose: +# Class of utility methods for making RegTAP queries. + +# Description: +# Provides a number of methods that can be used to construct +# AQDL queries for making RegTAP queries. The methods are meant +# to cover the standard cases, i.e. TAP services, Registries, +# SIA servers etc. + +# Invocations: +# +# GaiaVORegTapQuery object_name [configuration options] +# +# This creates an instance of a GaiaTAPQuery object. The return is +# the name of the object. +# +# object_name configure -configuration_options value +# +# Applies any of the configuration options (after the instance has +# been created). +# +# object_name method arguments +# +# Performs the given method on this object. + +# Copyright: +# Copyright (C) 2014 Science and Technology Facilities Council +# All Rights Reserved. + +# Licence: +# This program 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. +# +# 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 Street,Fifth Floor, Boston, MA +# 02110-1301, USA + +# Authors: +# PWD: Peter Draper (JAC, Durham University) +# {enter_new_authors_here} + +# History: +# 04-AUG-2014 (PWD): +# Original version. Based on RegTapRegistryQuery.java from STARJAVA and +# the RegTAP example queries. +# {enter_further_changes_here} + +#- + +#. + +itcl::class gaiavo::GaiaVORegTapQuery { + + # Singleton entry point: + # ---------------------- + proc instance {} { + if { $instance_ == {} } { + set instance_ [GaiaVORegTapQuery ::\#auto] + } + return $instance_ + } + + # Inheritances: + # ------------- + + # Nothing + + # Constructor: + # ------------ + constructor {args} { + # Nothing to do, just a holder for static methods. + } + + # Destructor: + # ----------- + destructor { + } + + # Methods: + # -------- + + # Return the service type. + public method get_type {} { + return "RegTAP" + } + + # Get ADQL for list of TAP servers. + public method get_taps_query {{substring {}}} { + return [get_servers ivo://ivoa.net/std/tap $substring] + } + + # Get ADQL for list of conesearch servers. + public method get_cones_query {{substring {}}} { + return [get_servers ivo://ivoa.net/std/ConeSearch $substring] + } + + # Get ADQL to get list of SIA servers, qualified by some optional string + # that should be in a descriptive content element. + public method get_sias_query {{substring {}}} { + return [get_servers ivo://ivoa.net/std/sia $substring] + } + + # Get ADQL to get list of registries. + public method get_registries_query {} { + set query {} + append query "SELECT access_url " + append query "FROM rr.interface " + append query "NATURAL JOIN rr.capability " + append query "NATURAL JOIN rr.res_detail " + append query "WHERE standard_id='ivo://ivoa.net/std/tap' " + append query "AND intf_type='vs:paramhttp' " + append query "AND detail_xpath='/capability/dataModel/@ivo-id' " + append query "AND 1=ivo_nocasematch(detail_value, 'ivo://ivoa.net/std/regtap#1.0)'" + return $query + } + + + # Get ADQL to get list of servers with the given standard_id, qualified by + # some optional string that should be in a descriptive content element. + # XXX only apply subtring to some elements. + public method get_servers_query {standard_id {substring {}}} { + set query {} + append query "SELECT ivoid, short_name, res_title, reference_url, " + append query "intf_index, access_url, standard_id, cap_type, cap_description, " + append query "std_version, res_subjects " + append query "FROM rr.resource AS res " + append query "NATURAL JOIN rr.interface " + append query "NATURAL JOIN rr.capability " + append query "NATURAL LEFT OUTER JOIN " + append query "(SELECT ivoid, ivo_string_agg(res_subject, ', ') AS res_subjects FROM rr.res_subject GROUP BY ivoid) AS sbj " + append query "WHERE " + append query "standard_id='${standard_id}' AND " + append query "intf_type='vs:paramhttp'" + if { $substring != {} } { + append query " AND " + append query "((" + append query "1=ivo_nocasematch(short_name, '%${substring}%') OR " + append query "1=ivo_hasword(res_title, '${substring}') OR " + append query "1=ivo_hasword(res_subjects, '${substring}') OR " + append query "1=ivo_nocasematch(ivoid, '%${substring}%') OR " + append query "1=ivo_hasword(res_description, '${substring}') " + append query "))" + } + return $query + } + + # Get the default registry endpoints. Returns a list of pairs of values, + # a symbolic name followed by the endpoint. + public method get_registries {} { + return [::array get registries_] + } + + # Add a new registry to the default list. Not peristent. + public method add_registry {shortname url} { + set registries_($shortname) $url + } + + # Get the "default" registry. + public method default_registry {} { + return [list GAVO_AIP $registries_(GAVO_AIP)] + } + + # Get the standard id for a service type shortname. + public method get_standard_id {name} { + return $standardIDs_($name) + } + + # Get the default columns to show. + public method default_columns {} { + return "$default_columns_" + } + + # Extract the access url from a row of values. The headers are the + # names of the associated columns. + public method get_access_url {headers row} { + eval lassign \$row $headers + if { [info exists access_url] } { + return $access_url + } + return {} + } + + # Extract a name for a service from a row of values. The headers are the + # names of the associated columns. + public method get_name {headers row} { + eval lassign \$row $headers + if { [info exists short_name] && $short_name != {} } { + return $short_name + } + if { [info exists res_title] } { + return $res_title + } + return {} + } + + # Extract the IVOA identifier for the service from a list of headers + # and the associated data row. + public method get_identifier {headers row} { + eval lassign \$row $headers + if { [info exists ivoid] } { + return $ivoid + } + return {} + } + + # Configuration options: (public variables) + # ---------------------- + + # Common variables: (shared by all instances) + # ----------------- + + # The instance of this class. + protected common instance_ {} + + # Known RegTAP servers. Needed to boot this process. + protected common registries_ + + # TAP endpoint for GAVO registry hosted at AIP. + set registries_(GAVO_AIP) "http://gavo.aip.de/__system__/tap/run/tap" + + # TAP endpoint for GAVO registry currently hosted at ARI Heidelberg + set registries_(GAVO_ARI) "http://dc.zah.uni-heidelberg.de/__system__/tap/run/tap" + + # Mapping of short service names to their standard ids. Yes these differ + # in case from RI1.0... + protected common standardIDs_ + set standardIDs_(SIAP) "ivo://ivoa.net/std/sia" + set standardIDs_(SSAP) "ivo://ivoa.net/std/ssa" + set standardIDs_(CONE) "ivo://ivoa.net/std/conesearch" + set standardIDs_(TAP) "ivo://ivoa.net/std/tap" + + # Default columns to show in table views. + protected common default_columns_ "short_name res_title" + + # Useful columns. + protected common columns_ \ + "ivoid short_name res_title reference_url intf_index access_url standard_id \ +cap_type cap_description std_version res_subjects" + +# End of class definition. +} diff --git a/applications/gaia/gaiavo/library/GaiaVORegV1Query.tcl b/applications/gaia/gaiavo/library/GaiaVORegV1Query.tcl new file mode 100644 index 00000000000..e6769b4f2f7 --- /dev/null +++ b/applications/gaia/gaiavo/library/GaiaVORegV1Query.tcl @@ -0,0 +1,186 @@ +#+ +# Name: +# GaiaVORegV1Query + +# Type of Module: +# [incr Tcl] class + +# Purpose: +# Class defining utilities methods for RI1.0. + +# Description: +# Provides a number of methods that describe the registries +# interface version 1.0. + +# Invocations: +# +# GaiaVORegV1Query object_name [configuration options] +# +# This creates an instance of a GaiaTAPQuery object. The return is +# the name of the object. +# +# object_name configure -configuration_options value +# +# Applies any of the configuration options (after the instance has +# been created). +# +# object_name method arguments +# +# Performs the given method on this object. + +# Copyright: +# Copyright (C) 2014 Science and Technology Facilities Council +# All Rights Reserved. + +# Licence: +# This program 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. +# +# 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 Street,Fifth Floor, Boston, MA +# 02110-1301, USA + +# Authors: +# PWD: Peter Draper (JAC, Durham University) +# {enter_new_authors_here} + +# History: +# 04-AUG-2014 (PWD): +# Original version. +# {enter_further_changes_here} + +#- + +#. + +itcl::class gaiavo::GaiaVORegV1Query { + + # Singleton entry point: + # ---------------------- + proc instance {} { + if { $instance_ == {} } { + set instance_ [GaiaVORegV1Query ::\#auto] + } + return $instance_ + } + + # Inheritances: + # ------------- + + # Nothing + + # Constructor: + # ------------ + constructor {args} { + # Nothing to do, just a holder for static methods. + } + + # Destructor: + # ----------- + destructor { + } + + # Methods: + # -------- + + # Return the service type. + public method get_type {} { + return "RegV1" + } + + # Get the default registry endpoints. Returns a list of pairs of values, + # a symbolic name followed by the endpoint. + public method get_registries {} { + return [::array get registries_] + } + + # Add a new registry to the default list. Not peristent. + public method add_registry {shortname url} { + set registries_($shortname) $url + } + + # Get the "default" registry. + public method default_registry {} { + return [list AstroGrid $registries_(AstroGrid)] + } + + # Get the standard id for a service type shortname. + public method get_standard_id {name} { + return $standardIDs_($name) + } + + # Get the default columns to show. + public method default_columns {} { + return "$default_columns_" + } + + # Extract the access url from a row of values. The headers are the + # names of the associated columns. + public method get_access_url {headers row} { + eval lassign \$row $headers + if { [info exists accessURL] } { + return $accessURL + } + return {} + } + + # Extract a name for a service from a row of values. The headers are the + # names of the associated columns. + public method get_name {headers row} { + eval lassign \$row $headers + if { [info exists shortName] && $shortName != {} } { + return $shortName + } + if { [info exists title] } { + return $title + } + return {} + } + + # Extract the IVOA identifier for the service from a list of headers + # and the associated data row. + public method get_identifier {headers row} { + eval lassign \$row $headers + if { [info exists identifier] } { + return $identifier + } + return {} + } + + # Configuration options: (public variables) + # ---------------------- + + + # Common variables: (shared by all instances) + # ----------------- + + # The instance of this class. + protected common instance_ {} + + # Known RegV1 servers. Needed to boot this process. + protected common registries_ + set registries_(NVO) "http://nvo.stsci.edu/vor10/ristandardservice.asmx" + set registries_(AstroGrid) \ + "http://registry.astrogrid.org/astrogrid-registry/services/RegistryQueryv1_0" + + # Mapping of short service names to their standard ids. Yes these differ + # in case from RegTAP. + protected common standardIDs_ + set standardIDs_(SIAP) "ivo://ivoa.net/std/SIA" + set standardIDs_(SSAP) "ivo://ivoa.net/std/SSA" + set standardIDs_(CONE) "ivo://ivoa.net/std/ConeSearch" + set standardIDs_(TAP) "ivo://ivoa.net/std/TAP" + + # Default columns to show in table views. + protected common default_columns_ "shortName title" + +# End of class definition. +} diff --git a/applications/gaia/gaiavo/library/GaiaVORegistrySearch.tcl b/applications/gaia/gaiavo/library/GaiaVORegistrySearch.tcl index abe07218d69..d688de5e17c 100644 --- a/applications/gaia/gaiavo/library/GaiaVORegistrySearch.tcl +++ b/applications/gaia/gaiavo/library/GaiaVORegistrySearch.tcl @@ -9,13 +9,19 @@ # Class for querying a VO registry. # Description: -# This class defines the access methods for querying the NVO -# registry and astrogrid registries. +# This class defines the access methods for querying VO registries. # -# The basic query to a service type (like sia:SimpleImageAccess) can be -# refined by adding a ADQL where clause that looks for a specified +# There are two types of registry, the old V1.0 type, that use a SOAP +# query interface and the newer RegTAP, that use TAP (ADQL) queries. +# RegTAP is expected to supercede V1.0. +# +# The basic query to a 1.0 service type (like sia:SimpleImageAccess) can +# be refined by adding a ADQL where clause that looks for a specified # substring in one of the known columns (these must match the meta-data # definitions for a VOResource). +# +# In TAP there is a similar mechanism, that gives greater freedom to +# control the query. That isn't necessarily exposed (yet). # Invocations: # @@ -34,7 +40,7 @@ # Performs the given method on this object. # Copyright: -# Copyright (C) 2008-2009 Science and Technology Facilities Council +# Copyright (C) 2008-2014 Science and Technology Facilities Council # All Rights Reserved. # Licence: @@ -85,25 +91,39 @@ itcl::class gaiavo::GaiaVORegistrySearch { set tempcats_ [gaia::GaiaTempName \#auto -prefix GaiaTempReg \ -exists 0 -type ".TAB"] - # Display the registry. Offer two symbolic types. NVO and AstroGrid. + # User selects the registry type and registry. + itk_component add regframe { + ::frame $w_.regframe + } set lwidth 10 set vwidth 50 itk_component add registry { - LabelMenu $w_.registry \ + LabelMenu $itk_component(regframe).registry \ -text "Registry:" \ -labelwidth $lwidth \ -valuewidth $vwidth } - pack $itk_component(registry) -side top -fill x -ipadx 1m -ipady 1m - add_short_help $itk_component(registry) {VO Registry} + pack $itk_component(registry) -side left -fill x -ipadx 1m -ipady 1m + add_short_help $itk_component(registry) {VO registry} - foreach {name value} [array get registries_] { - $itk_component(registry) add \ - -command [code $this set_registry_ $name] \ - -label $name \ - -value $name + itk_component add regtype { + LabelMenu $itk_component(regframe).regtype \ + -labelwidth 0 \ + -valuewidth 6 } - $itk_component(registry) configure -value $itk_option(-registry) + pack $itk_component(regtype) -side left -fill x -ipadx 1m -ipady 1m + add_short_help $itk_component(regtype) {VO registry type} + + pack $itk_component(regframe) -side top -fill x -ipadx 1m -ipady 1m + + foreach type "RI1.0 RegTAP" { + $itk_component(regtype) add \ + -command [code $this set_registry_type_ $type] \ + -label $type \ + -value $type + } + $itk_component(regtype) configure -value "RegTAP" + set_registry_type_ "RegTAP" # Display the type of service. This is fixed. itk_component add service { @@ -169,22 +189,37 @@ itcl::class gaiavo::GaiaVORegistrySearch { eval $itk_option(-feedbackcommand) on } - # Establish object to run the query scripts. - if { $querytask_ == {} } { - set querytask_ [gaia::GaiaForeignExec \#auto \ + # Establish objects to run the query scripts. + if { $queryregtask_ == {} } { + set queryregtask_ [gaia::GaiaForeignExec \#auto \ -application $::gaia_dir/queryreg \ -notify [code $this query_done_]] } + if { $querytaptask_ == {} } { + set querytaptask_ [gaia::GaiaForeignExec \#auto \ + -application $::gaia_dir/querytap \ + -notify [code $this query_done_]] + } set votable_ [$tempcats_ get_typed_name ".vot"] set interrupted_ 0 if { $itk_option(-column) != {} && $itk_option(-substring) != {} } { - $querytask_ runwith [get_registry_] [get_service_] \ - "$itk_option(-column)" "$itk_option(-substring)" "$votable_" + if { $itk_option(-registry_type) == "RI1.0" } { + $queryregtask_ runwith [get_registry_] [get_service_] \ + "$itk_option(-column)" "$itk_option(-substring)" "$votable_" + } else { + set query [$regtap_ get_servers_query [get_service_] "$itk_option(-substring)"] + $querytaptask_ runwith [get_registry_] "$query" "$votable_" + } + } else { - $querytask_ runwith [get_registry_] [get_service_] \ - "" "" "$votable_" + if { $itk_option(-registry_type) == "RI1.0" } { + $queryregtask_ runwith [get_registry_] [get_service_] "" "" "$votable_" + } else { + set query [$regtap_ get_servers_query [get_service_] {}] + $querytaptask_ runwith [get_registry_] "$query" "$votable_" + } } } @@ -224,13 +259,13 @@ itcl::class gaiavo::GaiaVORegistrySearch { } # Set the registry. - protected method set_registry_ {registry} { - configure -registry $registry + protected method set_registry_ {name url} { + configure -registry [list $name $url] } # Get the registry endpoint. protected method get_registry_ {} { - return $registries_($itk_option(-registry)) + return [lindex $itk_option(-registry) 1] } # Set the service. @@ -240,7 +275,7 @@ itcl::class gaiavo::GaiaVORegistrySearch { # Translate a service type to its full description or standard ID. protected method get_service_ {} { - return $standardIDs_($itk_option(-service)) + return [$reghandler_ get_standard_id $itk_option(-service)] } # Save the result of a query to an external VOTable. @@ -253,7 +288,7 @@ itcl::class gaiavo::GaiaVORegistrySearch { # Read the query directly from an existing file. public method read_query {filename} { - # Convert to a TST file so we can open it up as usual. + # Convert to a TST file so we can open it up as usual. set vot [gaiavotable::open $filename] # Check the STATUS return. @@ -266,6 +301,32 @@ itcl::class gaiavo::GaiaVORegistrySearch { # This is the current VOTable now. set votable_ $filename + + # Wart: seems that registries do not only return resources with the + # expected capability class, so apply a retrospective filter. Esp. + # bad for TAP services. Shouldn't be a large response so just eat the + # file process into the same name. + set fp [::open $tempname] + set data [::read $fp] + ::close $fp + set fp [::open $tempname "w"] + set pattern [get_service_] + set ok 1 + foreach line [split $data "\n"] { + if { $ok } { + # Just passthrough header section. + if { [string first "--" $line] == 0 } { + set ok 0 + } + puts $fp $line + } else { + if { [string first $pattern $line] != -1 } { + puts $fp $line + } + } + } + ::close $fp + } else { set status 0 set tempname \ @@ -278,13 +339,68 @@ itcl::class gaiavo::GaiaVORegistrySearch { } } + # Change the registry type. + protected method set_registry_type_ {type} { + + # If changed we want to change the columns. + set change_cols 0 + if { $type != $itk_option(-registry_type) } { + set change_cols 1 + } + configure -registry_type $type + + # Set the handler. + if { $type == "RI1.0" } { + set reghandler_ $regv1_ + } else { + set reghandler_ $regtap_ + } + + # Clear any existing registries. + $itk_component(registry) clear + + foreach {name value} [$reghandler_ get_registries] { + $itk_component(registry) add \ + -command [code $this set_registry_ $name $value] \ + -label $name \ + -value $value + } + $itk_component(registry) configure \ + -value [lindex [$reghandler_ default_registry] 1] + eval set_registry_ [$reghandler_ default_registry] + + # Change default columns. + if { $itk_option(-show_cols_cmd) != {} } { + eval $itk_option(-show_cols_cmd) {[$reghandler_ default_columns]} + } + } + + # Get the identifier from a catalogue row with the associated headings. + # Uses the current registry type to locate the column name. + public method get_identifier {headings row} { + return [$reghandler_ get_identifier "$headings" "$row"] + } + + # Get the access URL from a catalogue row with the associated headings. + # Uses the current registry type to locate the column name. + public method get_access_url {headings row} { + return [$reghandler_ get_access_url "$headings" "$row"] + } + + # Get the name/title from a catalogue row with the associated headings. + # Uses the current registry type to locate the column name. + public method get_name {headings row} { + return [$reghandler_ get_name "$headings" "$row"] + } + # Configuration options: (public variables) # ---------------------- + + # Current registry and type. + itk_option define -registry registry Registry {} + itk_option define -registry_type registry_type Registry_Type {} - # The type of VO registry to query, NVO or AstroGrid. - itk_option define -registry registry Registry "NVO" - - # The type of query, SIAP, SSAP or CONE. + # The type of query, SIAP, SSAP, CONE or TAP. itk_option define -service service Service "SIAP" # Command to execute when a list of servers is accepted. @@ -298,6 +414,10 @@ itcl::class gaiavo::GaiaVORegistrySearch { # the substring entry. itk_option define -query_cmd query_cmd Query_Cmd {} + # Command to execute when the default columns to show in the results + # should change. This is necessary when switching between the two types. + itk_option define -show_cols_cmd show_cols_cmd Show_Cols_Cmd {} + # Name of a column to qualify query. itk_option define -column column Column {title} @@ -314,35 +434,28 @@ itcl::class gaiavo::GaiaVORegistrySearch { protected variable votable_ {} # Task controlling queries. - protected variable querytask_ {} + protected variable queryregtask_ {} + protected variable querytaptask_ {} # Set true when a query is being interrupted. protected variable interrupted_ 0 + # Current handler for different registry types. + protected variable reghandler_ [::gaiavo::GaiaVORegTapQuery::instance] + # Common variables: (shared by all instances) # ----------------- - # The known registries. - protected common registries_ - set registries_(NVO) "http://nvo.stsci.edu/vor10/ristandardservice.asmx" - set registries_(AstroGrid) \ - "http://registry.astrogrid.org/astrogrid-registry/services/RegistryQueryv1_0" - # Mapping for short to full names of services. protected common services_ set services_(SIAP) "SimpleImageAccess" set services_(SSAP) "SimpleSpectralAccess" set services_(CONE) "ConeSearch" + set services_(TAP) "TableAccess" - # Mapping of short service names to their standard ids. - protected common standardIDs_ - set standardIDs_(SIAP) "ivo://ivoa.net/std/SIA" - set standardIDs_(SSAP) "ivo://ivoa.net/std/SSA" - set standardIDs_(CONE) "ivo://ivoa.net/std/ConeSearch" - - # Possible columns for adding a predicate. - protected common columns_ "title shortName" - + # Handlers for different registry types. + protected common regtap_ [::gaiavo::GaiaVORegTapQuery::instance] + protected common regv1_ [::gaiavo::GaiaVORegV1Query::instance] # End of class definition. } diff --git a/applications/gaia/gaiavo/library/GaiaVOSIAPSearchs.tcl b/applications/gaia/gaiavo/library/GaiaVOSIAPSearchs.tcl index 7d30c24fdc6..fa707fc7c1f 100644 --- a/applications/gaia/gaiavo/library/GaiaVOSIAPSearchs.tcl +++ b/applications/gaia/gaiavo/library/GaiaVOSIAPSearchs.tcl @@ -426,15 +426,39 @@ itcl::class gaiavo::GaiaVOSIAPSearchs { return [list $ra $dec $radius] } + # Realise the registry dialog, we need this for service functions as well + # as when we want to change the list of SIAP servers, so use local method + # rather than utils. XXX clearly this should all be refactored so thst + # registry is a model and we just have various views. + protected method create_registry_ { withdraw } { + if { [winfo exists $w_.voregistry] } { + $w_.voregistry config \ + -catalog [$itk_option(-astrocat) longname] \ + -service SIAP \ + -activate_cmd [code $this changed_registry_] \ + -blacklist $itk_option(-blacklist) + } else { + GaiaVOCatRegistry $w_.voregistry \ + -catalog [$itk_option(-astrocat) longname] \ + -service SIAP \ + -activate_cmd [code $this changed_registry_] \ + -blacklist $itk_option(-blacklist) + # Wait for realisation to complete... + tkwait visibility $w_.voregistry + } + + if { ! $withdraw } { + utilRaiseWindow $w_.voregistry + } else { + wm withdraw $w_.voregistry + } + } + + # Activate the registry dialog. protected method registry_query_ {} { blt::busy hold [winfo toplevel $w_] - utilReUseWidget GaiaVOCatRegistry $w_.voregistry \ - -catalog [$itk_option(-astrocat) longname] \ - -service SIAP \ - -show_cols {shortName title} \ - -activate_cmd [code $this changed_registry_] \ - -blacklist $itk_option(-blacklist) + create_registry_ 0 } # Registry has been changed and maybe accepted. @@ -443,6 +467,22 @@ itcl::class gaiavo::GaiaVOSIAPSearchs { $itk_option(-astrocat) open [$w_.voregistry cget -catalog] } + # Provide access to GaiaVOCatRegistry specialisations for different + # registry types. + public method get_identifier {headings row} { + create_registry_ 1 + return [$w_.voregistry get_identifier "$headings" "$row"] + } + public method get_access_url {headings row} { + create_registry_ 1 + return [$w_.voregistry get_access_url "$headings" "$row"] + } + public method get_name {headings row} { + create_registry_ 1 + return [$w_.voregistry get_name "$headings" "$row"] + } + + # Configuration options: (public variables) # ---------------------- diff --git a/applications/gaia/gaiavo/library/GaiaVOTAP.tcl b/applications/gaia/gaiavo/library/GaiaVOTAP.tcl new file mode 100644 index 00000000000..019811a2191 --- /dev/null +++ b/applications/gaia/gaiavo/library/GaiaVOTAP.tcl @@ -0,0 +1,421 @@ +#+ +# Name: +# GaiaVOTAP + +# Type of Module: +# [incr Tcl] class + +# Purpose: +# Query a TAP service. + +# Description: +# Extends the GaiaVOCat class to query a given TAP service. +# XXX what kind of results are we expecting, simple catalogue? +# Links to images/cubes etc? + +# Invocations: +# +# GaiaVOTAP object_name [configuration options] +# +# This creates an instance of a GaiaVOTAP object. The return is +# the name of the object. +# +# object_name configure -configuration_options value +# +# Applies any of the configuration options (after the instance has +# been created). +# +# object_name method arguments +# +# Performs the given method on this object. + +# Copyright: +# Copyright (C) 2014 Science and Technology Facilities Council +# All Rights Reserved. + +# Licence: +# This program 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. +# +# 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 Street,Fifth Floor, Boston, MA +# 02110-1301, USA + +# Authors: +# PWD: Peter Draper (JAC, Durham University) +# {enter_new_authors_here} + +# History: +# 28-MAR-2014 (PWD): +# Original version. +# {enter_further_changes_here} + +#- + +#. + +itk::usual GaiaVOTAP {} + +itcl::class gaiavo::GaiaVOTAP { + + # Inheritances: + # ------------- + inherit gaiavo::GaiaVOCat + + # Constructor: + # ------------ + constructor {args} { + eval itk_initialize $args + } + + # Destructor: + # ----------- + destructor { + } + + # Methods: + # -------- + + # Add additional menu items. + public method init {} { + GaiaVOCat::init + + # Override title. + wm title $w_ "Query TAP service" + + set m [add_menubutton Options "Options menu"] + + # Change the plot symbols. + add_menuitem $m command "Set plot symbols..." \ + {Set the symbol (color, size, etc.) to use to plot objects} \ + -command [code $this set_plot_symbols] + + # Add menus for selecting simple plot symbols. + add_plot_menus_ + + # Plot symbols button. + itk_component add plot { + button $itk_component(buttons).plot \ + -text "Plot" \ + -command [code $this plot] + } + pack $itk_component(plot) -side left -before $itk_component(open) -expand 1 -pady 2m + add_short_help $itk_component(plot) {Plot positions over image} + + # Loose the "Open" button. + pack forget $itk_component(open) + + # Set names for the canvas tags used for all symbols. This defined + # in the imgplot command. + set tag_ $w_.cat + set object_tag_ $tag_.objects + set label_tag_ $tag_.labels + + # Add bindings for symbols. + $canvas_ bind $object_tag_ <1> [code $this select_symbol current 0] + $canvas_ bind $object_tag_ \ + [code $this select_symbol current 1] + $canvas_ bind $object_tag_ \ + [code $this select_symbol current 1] + $canvas_ bind $object_tag_ "$canvas_ config -cursor tcross" + $canvas_ bind $object_tag_ "$draw_ reset_cursor" + + # Button release selects symbols for selected rows. + bind $itk_component(results).listbox \ + [code $this select_result_row] + } + + # Add the component that will control the query. + protected method add_query_component_ {} { + + itk_component add tap { + gaiavo::GaiaVOTAPQuery $w_.tap \ + -accessURL $itk_option(-accessURL) \ + -shortname $itk_option(-shortname) \ + -feedbackcommand [code $this set_feedback] \ + -astrocat [code $w_.cat] \ + -command [code $this query_done] \ + -gaiactrl [$itk_option(-gaia) get_image] + } + pack $itk_component(tap) -side top -fill x -expand 1 + add_short_help $itk_component(tap) \ + {Controls for querying the TAP service} + + set query_component_ $itk_component(tap) + } + + # New catalogue, set default plot symbol. + public method query_done {status result} { + GaiaVOCat::query_done $status $result + set_default_plot_symbol_ + } + + # Open a service, "args" is a list of values from a row of the current + # table. + protected method open_service_ {args} { + # Do nothing. + } + + # Plot the RA and Dec positions on the image using the defined symbols. + public method plot {} { + + # Clear any existing positions. + clear_plot + + # Create an AST FrameSet to describe the coordinates. + set att {} + set system [$w_.cat system] + if { $system != {} } { + append att "System=$system," + } + set epoch [$w_.cat epoch] + if { $epoch != {} } { + append att "Epoch=$epoch," + } + set equinox [$w_.cat equinox] + if { $equinox != {} } { + append att "Equinox=$equinox," + } + + # Fallback to standard. + if { $equinox == {} && $att == {} } { + append att "System=FK5,Equinox=$equinox_" + } + + # Create the AST FrameSet. + set astref [gaiautils::astskyframeset $att] + + # Do the plot. + if {[catch {$w_.cat imgplot $rtdimage_ $info_ $astref $headings_} msg]} { + error_dialog $msg + } + } + + # Clear the plot of any existing symbols. + public method clear_plot {} { + catch {$canvas_ delete $tag_} + } + + # Set the catalogue plotting symbol to the default. + protected method set_default_plot_symbol_ {} { + if { $type_ == {} } { + set type_ circle + } + if { $colour_ == {} } { + set colour_ red + } + if { $size_ == {} } { + set size_ 3 + } + set_simple_symbol_ + } + + # Set the catalogue plotting symbol to that of the markers menu. + protected method set_simple_symbol_ {} { + set symbol [list {} [list $type_ $colour_ {} {} {} {}] [list $size_ {}]] + $w_.cat symbol $symbol + plot + } + + # Pop up a dialog to set the plot symbols to use for this catalogue. + public method set_plot_symbols {} { + set columns $headings_ + if {[llength $columns] == 0} { + info_dialog \ + "Please make a query first so that the column names are known" $w_ + return + } + utilReUseWidget cat::SymbolConfig $w_.symconf \ + -catalog $itk_option(-catalog) \ + -astrocat [code $w_.cat] \ + -columns $columns \ + -command [code $this plot] + } + + # Add the menu items for selecting simple plot symbols. + protected method add_plot_menus_ {} { + set m [add_menubutton Markers "Plot symbol markers"] + + # Add the menus + foreach {label name} {Type type Size size Colour colour} { + $m add cascade -label $label -menu [menu $m.$name] + } + + # Add short help texts for menu items + add_menu_short_help $m Type {Set the plot symbol shape} + add_menu_short_help $m Size {Set the plot symbol size (pixels)} + add_menu_short_help $m Colour {Set the plot symbol colour} + + # Add the known types. + foreach {name} $symbol_types_ { + $m.type add radiobutton \ + -value $name \ + -bitmap $name \ + -variable [scope type_] \ + -command [code $this set_simple_symbol_] + } + + # Size menu + foreach i {3 5 7 9 11 15 21 31} { + $m.size add radiobutton \ + -value $i \ + -label $i \ + -variable [scope size_] \ + -command [code $this set_simple_symbol_] + } + + # Colour menu + foreach i $colours_ { + $m.colour add radiobutton \ + -value $i \ + -command [code $this set_simple_symbol_] \ + -variable [scope colour_] \ + -background $i + } + } + + # Select a symbol, given the canvas id and optional row number + # in the table listing. If $toggle is 0, deselect all other symbols + # first, otherwise toggle the selection of the items given by $id. + public method select_symbol {id toggle {rownum -1}} { + set tag [lindex [$canvas_ gettags $id] 0] + + if {$rownum < 0} { + set rownum [get_table_row $id] + if {$rownum < 0} { + return + } + } + + if {$toggle} { + if {[$draw_ item_has_tag $tag $w_.selected]} { + deselect_symbol $tag + $itk_component(results) deselect_row $rownum + return + } + } else { + deselect_symbol $w_.selected + } + + if {"$rownum" >= 0} { + $itk_component(results) select_row $rownum [expr !$toggle] + $itk_component(results) select_result_row + } + + foreach i [$canvas_ find withtag $tag] { + set width [$canvas_ itemcget $i -width] + $canvas_ itemconfig $i -width [expr $width+2] + } + $canvas_ addtag $w_.selected withtag $tag + $canvas_ raise $tag $rtdimage_ + } + + # Return the table row index corresponding the given symbol canvas id. + # Note: The imgplot subcommand adds a canvas tag "row#$rownum" that we can + # use here. Also: cat$id is first tag in the tag list for each object. + public method get_table_row {id} { + + set tags [$canvas_ gettags $id] + # Look for row#tag (but only if not sorted!) + if {[llength [$w_.cat sortcols]] == 0} { + foreach tag $tags { + if {[scan $tag "row#%d" rownum] == 1} { + return $rownum + } + } + } + + # Search for $id in query results (slow way). + set tag [lindex $tags 0] + set rownum -1 + foreach row [$itk_component(results) get_contents] { + incr rownum + set id [lindex $row [$w_.cat id_col]] + if { "cat$id" == "$tag" } { + return $rownum + } + } + + # Not found. + return -1 + } + + # Deselect the given symbol, given its canvas tag or id. + public method deselect_symbol {tag} { + foreach i [$canvas_ find withtag $tag] { + set width [$canvas_ itemcget $i -width] + $canvas_ itemconfig $i -width [expr $width-2] + } + $canvas_ dtag $tag $w_.selected + } + + # Called when a row in the table is selected. + protected method select_result_row {} { + $itk_component(results) select_result_row + + # Clear symbol selection + deselect_symbol $w_.selected + + # Select symbols matching selected rows + foreach row [$itk_component(results) get_selected_with_rownum] { + lassign $row rownum row + set id [lindex $row [$w_.cat id_col]] + if {"$id" == ""} { + continue + } + select_symbol cat$id 1 $rownum + } + } + + # Configuration options: (public variables) + # ---------------------- + + # Instance of GAIA to display the catalogue. + itk_option define -gaia gaia Gaia {} { + set rtdctrl_ [$itk_option(-gaia) get_image] + set rtdimage_ [$rtdctrl_ get_image] + set canvas_ [$rtdctrl_ get_canvas] + set draw_ [$rtdctrl_ component draw] + } + + # Protected variables: (available to instance) + # -------------------- + + # Various elements from the GAIA instance. + protected variable rtdctrl_ {} + protected variable rtdimage_ {} + protected variable canvas_ {} + protected variable draw_ {} + + # Equinox for VO catalogues. Really ICRS but J2000 (=FK5/J2000). + protected variable equinox_ "J2000" + + # Various tags associated with the positions when plotted. These + # are defined by imgplot method. + protected variable tag_ {} + protected variable object_tag_ {} + protected variable label_tag_ {} + + # Simple symbol values. + protected variable type_ {} + protected variable colour_ {} + protected variable size_ {} + + # Common variables: (shared by all instances) + # ----------------- + + protected common symbol_types_ \ + {circle square cross triangle diamond} + + protected common colours_ {white grey90 grey80 grey70 grey60 grey50 + grey40 grey30 grey20 grey10 black red green blue cyan magenta yellow} + +} diff --git a/applications/gaia/gaiavo/library/GaiaVOTAPQuery.tcl b/applications/gaia/gaiavo/library/GaiaVOTAPQuery.tcl new file mode 100644 index 00000000000..359c0a0bd12 --- /dev/null +++ b/applications/gaia/gaiavo/library/GaiaVOTAPQuery.tcl @@ -0,0 +1,335 @@ +#+ +# Name: +# GaiaVOTAPQuery + +# Type of Module: +# [incr Tcl] class + +# Purpose: +# Class for querying a VO TAP service. + +# Description: +# Provides controls for constructing and doing a query of a TAP version +# 1 service. The service is defined by an URL representing the service +# resource root. XXX just using /sync for testing... + +# Invocations: +# +# GaiaVOTAPQuery object_name [configuration options] +# +# This creates an instance of a GaiaTAPQuery object. The return is +# the name of the object. +# +# object_name configure -configuration_options value +# +# Applies any of the configuration options (after the instance has +# been created). +# +# object_name method arguments +# +# Performs the given method on this object. + +# Copyright: +# Copyright (C) 2014 Science and Technology Facilities Council +# All Rights Reserved. + +# Licence: +# This program 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. +# +# 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 Street,Fifth Floor, Boston, MA +# 02110-1301, USA + +# Authors: +# PWD: Peter Draper (JAC, Durham University) +# {enter_new_authors_here} + +# History: +# 28-MAR-2014 (PWD): +# Original version. +# {enter_further_changes_here} + +#- + +#. + +itk::usual GaiaVOTAPQuery {} + +itcl::class gaiavo::GaiaVOTAPQuery { + + # Inheritances: + # ------------- + inherit util::FrameWidget + + # Constructor: + # ------------ + constructor {args} { + + # Evaluate any options. + eval itk_initialize $args + + # Handler for temporary files. + set tempcats_ [gaia::GaiaTempName \#auto -prefix GaiaTempTAP \ + -exists 0 -type ".TAB"] + + # Display the TAP resource name and/or resource URL. + set lwidth 10 + set vwidth 50 + if { $itk_option(-shortname) != {} } { + set name "$itk_option(-shortname) ($itk_option(-accessURL))" + } else { + set name $itk_option(-accessURL) + } + + itk_component add actionframe { + frame $w_.actionframe + } + pack $itk_component(actionframe) -side top -fill x -ipadx 1m -ipady 1m + + itk_component add servicename { + LabelValue $itk_component(actionframe).servicename \ + -text "Service:" \ + -labelwidth $lwidth \ + -valuewidth $vwidth \ + -value $itk_option(-shortname) + } + pack $itk_component(servicename) -side top -fill x -expand 1 + add_short_help $itk_component(servicename) "The TAP service name" + + itk_component add serviceurl { + LabelValue $itk_component(actionframe).serviceurl \ + -text " " \ + -labelwidth $lwidth \ + -valuewidth $vwidth \ + -value $itk_option(-accessURL) + } + pack $itk_component(serviceurl) -side top -fill x -expand 1 + add_short_help $itk_component(serviceurl) "The TAP service endpoint" + + # Additional query for discovering information about the tables + # on offer. + itk_component add queryservice { + button $itk_component(actionframe).queryservice \ + -text "Tables..." \ + -command [code $this query_tables_] + } + pack $itk_component(queryservice) -side right -fill none -expand 0 -ipadx 1m + add_short_help $itk_component(queryservice) \ + {Query the service for information about the tables available} + + # Get the ADQL query. + itk_component add adqlframe { + iwidgets::scrolledtext $w_.adql \ + -labeltext "ADQL Query" \ + -wrap none \ + -vscrollmode static \ + -hscrollmode dynamic + } + + pack $itk_component(adqlframe) -side top -fill x -ipadx 1m -ipady 1m + add_short_help $itk_component(adqlframe) {ADQL query, press Query button to activate} + } + + # Destructor: + # ----------- + destructor { + $tempcats_ clear + } + + # Methods: + # -------- + + # Complete interface. + public method init {} { + FrameWidget::init + } + + # Do the query as a background job. + public method query {} { + + # Query starts, so might want to do something. + if { $itk_option(-feedbackcommand) != {} } { + eval $itk_option(-feedbackcommand) on + } + + # Establish object to run the query script. + if { $querytask_ == {} } { + set querytask_ [gaia::GaiaForeignExec \#auto \ + -application $::gaia_dir/querytap \ + -notify [code $this query_done_]] + } + set votable_ [$tempcats_ get_typed_name ".vot"] + set interrupted_ 0 + set query [$itk_component(adqlframe) get 1.0 end] + $querytask_ runwith $itk_option(-accessURL) $query $votable_ + } + + # Interrupt the query. + public method interrupt {} { + if { $querytask_ != {} } { + set interrupted_ 1 + catch {$querytask_ delete_now} + set querytask_ {} + } + if { $itk_option(-feedbackcommand) != {} } { + eval $itk_option(-feedbackcommand) off + } + } + + # Called when the query completes. + protected method query_done_ {} { + + # Immediate notification we're finished. + if { $itk_option(-feedbackcommand) != {} } { + eval $itk_option(-feedbackcommand) off + } + + if { $interrupted_ } { + info_dialog "Query interrupted" + return + } + + # Check file exists. + if { ! [::file exists $votable_] } { + warning_dialog "Failed to query TAP service" + return + } + + # Convert to TST and do the command to display etc. + read_query $votable_ + } + + # Save the result of a query to an external VOTable. + public method save_query {filename} { + if { $votable_ != {} && [::file exists $votable_] } { + ::file copy -force $votable_ $filename + } + } + + # Read the query directly from an existing file. + public method read_query {filename} { + + # Convert to a TST file so we can open it up as usual. + if { [catch {set vot [gaiavotable::open $filename]} msg] } { + set status 0 + set tempname "$msg ($filename)" + } else { + + # Check the STATUS return. + lassign [gaiavotable::info $vot "QUERY_STATUS"] query_status errmsg + if { $query_status != "ERROR" } { + set status 1 + set tempname [$tempcats_ get_name] + set tst [gaiavotable::save $vot 0 $tempname] + gaiavotable::close $vot + + # This is the current VOTable now. + set votable_ $filename + + } else { + set status 0 + set tempname "Query returned an error ($query_status: $errmsg)" + } + } + + # Do the user command (always done as something may be waiting + # for the query to complete, tempname may be an error message). + if { $itk_option(-command) != {} } { + eval $itk_option(-command) \$status \$tempname + } + } + + # Query the TAP service about the tables that it provides and display some + # of the metadata. Only done once, as should be fixed for an accessURL. + protected method query_tables_ {} { + if { $tables_doc_ == {} } { + set query "$itk_option(-accessURL)/tables" + if { $querytaptask_ == {} } { + set querytaptask_ [gaia::GaiaForeignExec \#auto \ + -application $::gaia_dir/querytapthings \ + -preprocess [code $this query_tables_output_] \ + -notify [code $this query_tables_done_]] + } + + blt::busy hold $w_ + set tables_doc_ {} + $querytaptask_ runwith $itk_option(-accessURL) "tables" + } else { + # Just make sure the results window can be viewed. + utilRaiseWindow $w_.tableset + } + } + + # Handle output from query_tables task. + protected method query_tables_output_ {msg} { + append tables_doc_ $msg + } + + # Query table completed, so pass on result to viewer. + protected method query_tables_done_ {} { + blt::busy release $w_ + if { $tables_doc_ != {} } { + utilReUseWidget gaiavo::GaiaVOTableSet $w_.tableset -xml $tables_doc_ + ::update idletasks + $w_.tableset update + } + } + + # Configuration options: (public variables) + # ---------------------- + + # The shortname of the service. + itk_option define -shortname shortname ShortName {} + + # The TAP resource URL. + itk_option define -accessURL accessURL AccessURL {} + + # Command to execute when a list of images is accepted. The command + # will be trailed by a status flag (1 for OK) and either a filename + # or an error message. + itk_option define -command command Command {} + + # Command to execute when batch jobs starts and stops. + itk_option define -feedbackcommand feedbackcommand FeedBackCommand {} + + # An astrocat instance for handling the result as a TST. + itk_option define -astrocat astrocat AstroCat {} + + # GaiaImageCtrl instance. + itk_option define -gaiactrl gaiactrl GaiaCtrl {} + + # Protected variables: (available to instance) + # -------------------- + + # Temporary files. + protected variable tempcats_ {} + + # Name of the VOTable from query. + protected variable votable_ {} + + # Task controlling querys. + protected variable querytask_ {} + + # Set true when a query is being interrupted. + protected variable interrupted_ 0 + + # Task to query the TAP service about it's tables. + protected variable querytaptask_ {} + + # Output from querytaptask_, an XML document. + protected variable tables_doc_ {} + + # Common variables: (shared by all instances) + # ----------------- + +# End of class definition. +} diff --git a/applications/gaia/gaiavo/library/GaiaVOTableSet.tcl b/applications/gaia/gaiavo/library/GaiaVOTableSet.tcl new file mode 100755 index 00000000000..9467b8bcea8 --- /dev/null +++ b/applications/gaia/gaiavo/library/GaiaVOTableSet.tcl @@ -0,0 +1,421 @@ +#+ +# Name: +# GaiaVOTableSet + +# Type of Module: +# [incr Tk] class + +# Purpose: +# Viewer for VODataService XML documents. + +# Description: +# Displays a VODataService XML document as a series of tables +# found within a element. These are associated with +# various schema, but we just offer all 's that are found. +# Tables have the interesting properties of name, plus +# units and ucd, utypes etc. + +# Invocations: +# +# GaiaVOTableSet object_name [configuration options] +# +# This creates an instance of a GaiaVOTableSet object. The return is +# the name of the object. +# +# object_name configure -configuration_options value +# +# Applies any of the configuration options (after the instance has +# been created). +# +# object_name method arguments +# +# Performs the given method on this object. + +# Configuration options: +# See itk_option define statements. + +# Methods: +# See method definitions below. + +# Inheritance: +# TopLevelWidget + +# Copyright: +# Copyright (C) 2014 Science and Technology Research Council. +# All Rights Reserved. + +# Licence: +# This program 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. +# +# 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 Street,Fifth Floor, Boston, MA +# 02110-1301, USA + +# Authors: +# PWD: Peter Draper (STARLINK - Durham University) +# {enter_new_authors_here} + +# History: +# 07-AUG-2014 (PWD): +# Original version. +# {enter_further_changes_here} + +#- + +#. + +itk::usual GaiaVOTableSet {} + +itcl::class gaiavo::GaiaVOTableSet { + + # Inheritances: + # ------------- + inherit util::TopLevelWidget + + # Constructor: + # ------------ + constructor {args} { + + # Evaluate any options. + eval itk_initialize $args + + # Add a short help window. + make_short_help + + # Add menubar. + add_menubar + + # File menu. + set m [add_menubutton File] + + add_menuitem $m command "Close" \ + {Close this window} \ + -command [code $this close] + + } + + # Destructor: + # ----------- + destructor { + + } + + # Methods: + # -------- + + # Complete interface construction. + public method init {} { + + # Help menu. + add_help_menu_ + + # Add the table for displaying all the tables. + itk_component add tables { + TableList $w_.tables \ + -title "Tables" \ + -hscroll 1 \ + -selectmode $selectmode_ \ + -exportselection $exportselection_ \ + -headings {name description} \ + -height 5 \ + -width 80 + } + add_short_help $itk_component(tables) {Tables available} + + # Set table binding edit the entries. + bind $itk_component(tables).listbox <1> [code $this view_selected_] + bind $itk_component(tables).listbox <> \ + [code $this view_selected_] + + # Add the table for displaying the current table. + itk_component add table { + TableList $w_.table \ + -title "Current table" \ + -hscroll 1 \ + -selectmode $selectmode_ \ + -exportselection $exportselection_ \ + -headings {column description datatype units ucd utype} \ + -height 15 \ + -width 80 + } + add_short_help $itk_component(table) \ + {Columns and descriptions in the current table} + + # Add frames for holding table action buttons. + itk_component add actionbar { + frame $w_.actionbar + } + + # Close window. + itk_component add close { + button $itk_component(actionbar).close \ + -text "Close" \ + -command [code $this close] + } + pack $itk_component(close) -side left -expand 1 -pady 2m + add_short_help $itk_component(close) {Close window} + + # Pack all widgets into place. + pack $itk_component(tables) -side top -fill both -expand 1 + pack $itk_component(table) -side top -fill both -expand 1 + pack $itk_component(actionbar) -side top -fill x -pady 3 -padx 3 + + } + + # Add and populate the help menu. Has the VO overview by default + # plus an additional topic defined by help_file and help_label. + protected method add_help_menu_ {} { + if { $itk_option(-help_file) != {} && $itk_option(-help_label) != {} } { + add_help_button $itk_option(-help_file) $itk_option(-help_label) \ + {Help on this window...} + } + add_help_button vo "About VO services..." {Help on VO in GAIA} + } + + # Close this window. + public method close {} { + wm withdraw $w_ + } + + # Return number of rows. + public method total_rows {main} { + if { $main } { + return [$itk_component(tables) total_rows] + } else { + return [$itk_component(table) total_rows] + } + } + + # Return contents of table. + public method get_contents {main} { + if { $main } { + return [$itk_component(tables) get_contents] + } else { + return [$itk_component(table) get_contents] + } + } + + # Return selected contents of table. Only one row allowed. + public method get_selected {main} { + if { $main } { + return [lindex [$itk_component(tables) get_selected] 0] + } else { + return [lindex [$itk_component(table) get_selected] 0] + } + } + + # Set the contents of the table. + public method set_contents { main rows } { + if { $main } { + $itk_component(tables) append_rows $rows + } else { + $itk_component(table) append_rows $rows + } + } + + # Append a new row to the table. Call new_info when completed. + public method append_row {main row} { + if { $main } { + $itk_component(tables) append_row $row + } else { + $itk_component(table) append_row $row + } + } + public method new_info {main} { + if { $main } { + $itk_component(tables) new_info + } else { + $itk_component(table) new_info + } + } + + # Select the row with the given id. + public method select_row {main id} { + if { $main } { + $itk_component(tables) search id $id + } else { + $itk_component(table) search id $id + } + } + + # Clear the tables. + public method clear_table {main} { + if { $main } { + $itk_component(tables) clear + } else { + $itk_component(table) clear + } + } + public method clear_tables {} { + $itk_component(tables) clear + $itk_component(table) clear + } + + # Write a copy of the table to an ordinary file. + public method write_to_file {} { + set w [FileSelect .\#auto -title "Write positions to file"] + if {[$w activate]} { + set filename [$w get] + if { [file exists $filename] } { + if { ! [ confirm_dialog \ + "$filename exists - do you want to overwrite?"] } { + destroy $w + return + } + } + save_positions $filename + } + destroy $w + } + + # Write table contents to a named file. + public method save_positions {filename} { + set fid [::open $filename w] + set nrows [$itk_component(table) total_rows] + set contents [$itk_component(table) get_contents] + for { set i 0 } { $i < $nrows } { incr i } { + puts $fid [lindex $contents $i] + } + ::close $fid + } + + # XML handling. + + # Parse the document after updating the XML. + public method update {} { + clear_tables + if { $itk_option(-xml) != {} } { + parse_doc_ + } + } + + # Parse the XML into lists of tables and the table's columns. + protected method parse_doc_ {} { + if { [ catch { set doc [dom parse $itk_option(-xml)] } msg ] } { + error_dialog $msg + return + } + + # Now find all the
s. + set root [$doc documentElement] + + # Don't do this, some responses are not correct, but still usable. + #if { ! [string match -nocase "*tableset" [$root nodeName]] } { + # error_dialog "root of document not a tableset: [$root nodeName]" + # return + #} + set tables [$root selectNodes "//table"] + + # Gather names and descriptions. + set info {} + array unset tablelist_ + foreach table $tables { + set name [get_node_text_ $table "name"] + + # We require a name. + if { $name != {} } { + set desc [get_node_text_ $table "description"] + set desc [clean_ $desc] + lappend info [list $name $desc] + + # Keep indexed list of table nodes so we can pick out content as + # needed. + set tablelist_($name) $table + } + } + + set_contents 1 $info + new_info 1 + + # Select first row. + $itk_component(tables) select_row 1 + ::update idletasks + view_selected_ + } + + # View the properties of the selected table. + protected method view_selected_ {} { + set selected [get_selected 1] + set name [lindex $selected 0] + if { [info exists tablelist_($name)] } { + parse_table_ $name + } + } + + # Extract and view the properties of the given table. + protected method parse_table_ {name} { + clear_table 0 + + set table $tablelist_($name) + + # Get all the columns and create rows describing each. + set info {} + set columns [$table selectNode "column"] + foreach column $columns { + catch { + set name [get_node_text_ $column "name"] + set desc [get_node_text_ $column "description"] + set desc [clean_ $desc] + set datatype [get_node_text_ $column "dataType"] + set units [get_node_text_ $column "unit"] + set ucd [get_node_text_ $column "ucd"] + set utype [get_node_text_ $column "utype"] + + lappend info [list $name $desc $datatype $units $ucd $utype] + } + } + set_contents 0 $info + new_info 0 + } + + # Get all text from a named child. + protected method get_node_text_ {parent name} { + set node [$parent selectNode $name] + if { $node != {} } { + return [$node text] + } + return {} + } + + + # Clean a string, removing funny characters and trimming. + protected method clean_ {str} { + regsub -all {[^\w\d\s\.]} $str {} str + return [string trim $str] + } + + + # Configuration options + # ===================== + + # The XML document. Use update if changed after creation. + itk_option define -xml xml Xml {} + + # Define a help file and label for the Help menu. + itk_option define -help_file help_file Help_File {} + itk_option define -help_label help_label Help_Label "On Window..." + + # Protected variables: (available to instance) + # -------------------- + + # Table elements of the XML document, indexed by the table name. + protected variable tablelist_ + + # Table configuration. + protected variable selectmode_ browse + protected variable exportselection_ 0 + + # Common variables: (shared by all instances) + # ----------------- + +# End of class definition. +} diff --git a/applications/gaia/gaiavo/library/RegistryResults_vot3.xsl b/applications/gaia/gaiavo/library/RegistryResults_vot3.xsl index 8c74109c686..8156f4024b0 100644 --- a/applications/gaia/gaiavo/library/RegistryResults_vot3.xsl +++ b/applications/gaia/gaiavo/library/RegistryResults_vot3.xsl @@ -1,33 +1,30 @@ - - - - - + + + + + + + - Registry Search Results
- @@ -38,23 +35,18 @@ - - - - + + - - - - - + - + +
@@ -63,216 +55,141 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - # - - - - # - - - - - - - - - - - - - - - - - + + + + + + + + + + + + # + + + + # + + + + + + + + + + + + + + + + + + - - - - # - - - - Searchable - - - - - - Publishing - - Registry# - - - - - - - Catalog - - - Images - - - Spectra - - - Registry - - - - - - - - - - - HTTP Request - - - Web Page - - - Custom Service - - - - - - Custom Service - - - # - - - - Data Collection# - - - Organisation# - - - VO Support# - - - Generic Resource - - # - - + + + + + + + + + diff --git a/applications/gaia/scripts/Makefile.am b/applications/gaia/scripts/Makefile.am index db6b9476c76..a66ed63b227 100644 --- a/applications/gaia/scripts/Makefile.am +++ b/applications/gaia/scripts/Makefile.am @@ -7,7 +7,7 @@ SCRIPTS_GAIA = displaycat displaypolcat gaiacmap.sh gaiacut \ gaia_standalone.csh gaiawcs2tab pix2wcs \ tabbedgaia.sh wcs2pix zoomcutandflip connect_to_gaia.tcl \ querysiap ftpget querycone queryreg querynedobject \ - querynedcone + querynedcone querytap querytapthings ## Edit the main startup scripts so that they set the LD_LIBRARY_PATH ## to include the installation libdir. diff --git a/applications/gaia/scripts/querycone b/applications/gaia/scripts/querycone index d435024b5e6..58868d1de03 100755 --- a/applications/gaia/scripts/querycone +++ b/applications/gaia/scripts/querycone @@ -91,7 +91,7 @@ proc get {query outfile} { set fid [::open $outfile w] # Download the response. - if { [catch {set response [::http::geturl $query] } msg] } { + if { [catch {set response [::http::geturl $query -strict 0] } msg] } { # Failed, so delete file and exit with an error. catch { diff --git a/applications/gaia/scripts/querynedcone b/applications/gaia/scripts/querynedcone index 9c74f418673..957f1b589fa 100755 --- a/applications/gaia/scripts/querynedcone +++ b/applications/gaia/scripts/querynedcone @@ -80,7 +80,7 @@ if { [info exists ::env(http_proxy)] } { proc get {query} { # Download the response. - if { [catch {set response [::http::geturl $query] } msg] } { + if { [catch {set response [::http::geturl $query -strict 0] } msg] } { # Failed. puts stderr "$msg" diff --git a/applications/gaia/scripts/querynedobject b/applications/gaia/scripts/querynedobject index 55e4c1b2d87..a5aea9cd010 100755 --- a/applications/gaia/scripts/querynedobject +++ b/applications/gaia/scripts/querynedobject @@ -78,7 +78,7 @@ if { [info exists ::env(http_proxy)] } { proc get {query} { # Download the response. - if { [catch {set response [::http::geturl $query] } msg] } { + if { [catch {set response [::http::geturl $query -strict 0] } msg] } { # Failed. puts stderr "$msg" diff --git a/applications/gaia/scripts/queryreg b/applications/gaia/scripts/queryreg index 3e1e4399fe0..a9c0ea2b4eb 100755 --- a/applications/gaia/scripts/queryreg +++ b/applications/gaia/scripts/queryreg @@ -134,7 +134,7 @@ set where "\ - + diff --git a/applications/gaia/scripts/querysiap b/applications/gaia/scripts/querysiap index 63395776f39..f95e7ad0788 100755 --- a/applications/gaia/scripts/querysiap +++ b/applications/gaia/scripts/querysiap @@ -89,7 +89,7 @@ proc get {query outfile} { set fid [::open $outfile w] # Download the response. - if { [catch {set response [::http::geturl $query] } msg] } { + if { [catch {set response [::http::geturl $query -strict 0] } msg] } { # Failed, so delete file and exit with an error. catch { diff --git a/applications/gaia/scripts/querytap b/applications/gaia/scripts/querytap new file mode 100755 index 00000000000..91d0e2b826b --- /dev/null +++ b/applications/gaia/scripts/querytap @@ -0,0 +1,121 @@ +#!/bin/sh +# The next line is executed by /bin/sh, but not Tcl \ +exec $GAIA_DIR/gaiavo_tcl $0 ${1+"$@"} +#+ +# Name: +# querytap + +# Purpose: +# Query a TAP service synchronously. + +# Usage: +# querytap endpoint "adql-query" outfile + +# Description: +# Queries a TAP service using the given ADQL expression. Currently +# we do this synchronously so the result is a VOTable catalogue +# containing the result. + +# Authors: +# Peter W. Draper (PWD): + +# Copyright: +# Copyright (C) 2014 Science and Technology Facilties Council. +# All Rights Reserved. + +# Licence: +# This program 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. +# +# 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 Street,Fifth Floor, Boston, MA +# 02110-1301, USA + +# History: +# 28-MAR-2014 (PWD): +# Original version. +#- +#. + +package require uri + +# Check the command-line arguments. +if { $argc == 3 } { + set endpoint [lindex $argv 0] + set adql [lindex $argv 1] + set outfile [lindex $argv 2] +} else { + puts stderr {Usage: querytap endpoint adql outfile} + exit 1 +} + +# Open the output file, just a test. +if { [catch "::open $outfile w" fid] } { + puts stderr "Failed to open output file: $outfile" + exit 1 +} +::close $fid + +# Establish the standard proxy define using http_proxy. +#cat::ProxyDialog::check_proxies $::env(HOME)/.skycat/proxies +set proxy {} +set port {} +if { [info exists ::env(http_proxy)] } { + if { [scan $::env(http_proxy) {http://%[^:/]:%d} proxy port] != 2 } { + scan $::env(http_proxy) {http://%[^:/]} proxy + } +} +::http::config -proxyhost $proxy +::http::config -proxyport $port + +# Proc to do the query. Needed as can be recursive if redirected. +proc get {endpoint query outfile} { + + # Open the result file. + set fid [::open $outfile w] + + # Download the response. + if { [catch {set response [::http::geturl $endpoint -query $query -strict 0] } msg] } { + + # Failed, so delete file and exit with an error. + catch { + ::close $fid + ::file delete $outfile + } + puts stderr "$msg" + return 1 + } + + # Check for a moved response and handle the re-direct. + if { [::http::ncode $response] == 302 || [::http::ncode $response] == 303 } { + array set meta [eval set $response\(meta\)] + set location $meta(Location) + puts "Redirected to: $newquery" + catch {::close $fid} + get $location $query $outfile + return + } + + # Get content and copy to the file. + puts $fid [::http::data $response] + + catch {::close $fid} + return 0 +} + +# Construct a query suitable for POSTing to the service. +set query [::http::formatQuery REQUEST doQuery LANG ADQL QUERY "$adql"] + +# Do it. +if { [get "${endpoint}/sync" "$query" $outfile] == 1 } { + exit 1 +} +exit diff --git a/applications/gaia/scripts/querytapthings b/applications/gaia/scripts/querytapthings new file mode 100755 index 00000000000..34c795e5af6 --- /dev/null +++ b/applications/gaia/scripts/querytapthings @@ -0,0 +1,137 @@ +#!/bin/sh +# The next line is executed by /bin/sh, but not Tcl \ +exec $GAIA_DIR/gaiavo_tcl $0 ${1+"$@"} +#+ +# Name: +# querytapthings + +# Purpose: +# Query a TAP service about some capability of the end point + +# Usage: +# querytapthings endpoint thing [outfile] + +# Description: +# Queries a TAP service using given thing as a qualifier for the +# given endpoint. The result is usually some VOResource that +# describes the thing, that a list of tables or capabilities. +# If no output file is given the result is sent to standard output. + +# Authors: +# Peter W. Draper (PWD): + +# Copyright: +# Copyright (C) 2014 Science and Technology Facilties Council. +# All Rights Reserved. + +# Licence: +# This program 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. +# +# 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 Street,Fifth Floor, Boston, MA +# 02110-1301, USA + +# History: +# 07-AUG-2014 (PWD): +# Original version. +#- +#. + +package require uri + +# Check the command-line arguments. +set outfile {} +if { $argc >= 2 } { + set endpoint [lindex $argv 0] + set thing [lindex $argv 1] + if { $argc == 3 } { + set outfile [lindex $argv 2] + } +} else { + puts stderr {Usage: querytapthing endpoint thing [outfile]} + exit 1 +} + +# Open the output file, just a test. +if { $outfile != {} } { + if { [catch "::open $outfile w" fid] } { + puts stderr "Failed to open output file: $outfile" + exit 1 + } + ::close $fid +} + +# Establish the standard proxy define using http_proxy. +#cat::ProxyDialog::check_proxies $::env(HOME)/.skycat/proxies +set proxy {} +set port {} +if { [info exists ::env(http_proxy)] } { + if { [scan $::env(http_proxy) {http://%[^:/]:%d} proxy port] != 2 } { + scan $::env(http_proxy) {http://%[^:/]} proxy + } +} +::http::config -proxyhost $proxy +::http::config -proxyport $port + +# Proc to do the query. Needed as can be recursive if redirected. +proc get {query outfile} { + + # Open the result file, if given. + if { $outfile != {} } { + set fid [::open $outfile w] + } else { + set fid stdout + } + + # Download the response. + if { [catch {set response [::http::geturl $query -strict 0] } msg] } { + + # Failed, so delete file and exit with an error. + if { $outfile != {} } { + catch { + ::close $fid + ::file delete $outfile + } + } + puts stderr "$msg" + return 1 + } + + # Check for a moved response and handle the re-direct. + if { [::http::ncode $response] == 302 || [::http::ncode $response] == 303 } { + array set meta [eval set $response\(meta\)] + set location $meta(Location) + puts "Redirected to: $newquery" + if { $outfile != {} } { + catch {::close $fid} + } + get $location $query $outfile + return + } + + # Get content and copy to the output stream. + puts $fid [::http::data $response] + + if { $outfile != {} } { + catch {::close $fid} + } + return 0 +} + +# Construct URL suitable for a GET from the service. +set url "${endpoint}/${thing}" + +# Do it. +if { [get "${url}" $outfile] == 1 } { + exit 1 +} +exit