libdap++ Updated for version 3.8.2
|
00001 // -*- mode: c++; c-basic-offset:4 -*- 00002 00003 // This file is part of libdap, A C++ implementation of the OPeNDAP Data 00004 // Access Protocol. 00005 00006 // Copyright (c) 2002,2003 OPeNDAP, Inc. 00007 // Author: James Gallagher <jgallagher@opendap.org> 00008 // 00009 // This library is free software; you can redistribute it and/or 00010 // modify it under the terms of the GNU Lesser General Public 00011 // License as published by the Free Software Foundation; either 00012 // version 2.1 of the License, or (at your option) any later version. 00013 // 00014 // This library is distributed in the hope that it will be useful, 00015 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00016 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00017 // Lesser General Public License for more details. 00018 // 00019 // You should have received a copy of the GNU Lesser General Public 00020 // License along with this library; if not, write to the Free Software 00021 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 00022 // 00023 // You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112. 00024 00025 // (c) COPYRIGHT URI/MIT 1994-1999 00026 // Please read the full copyright statement in the file COPYRIGHT_URI. 00027 // 00028 // Authors: 00029 // jhrg,jimg James Gallagher <jgallagher@gso.uri.edu> 00030 00031 // Provide access to the DDS. This class is used to parse DDS text files, to 00032 // produce a printed representation of the in-memory variable table, and to 00033 // update the table on a per-variable basis. 00034 // 00035 // jhrg 9/8/94 00036 00037 #ifndef _dds_h 00038 #define _dds_h 1 00039 00040 #include <cstdio> 00041 #include <iostream> 00042 #include <string> 00043 #include <vector> 00044 00045 #ifndef _basetype_h 00046 #include "BaseType.h" 00047 #endif 00048 00049 #ifndef _constructor_h 00050 #include "Constructor.h" 00051 #endif 00052 00053 #ifndef base_type_factory_h 00054 #include "BaseTypeFactory.h" 00055 #endif 00056 00057 #ifndef _das_h 00058 #include "DAS.h" 00059 #endif 00060 00061 #ifndef A_DapObj_h 00062 #include "DapObj.h" 00063 #endif 00064 00065 using std::cout; 00066 00067 namespace libdap 00068 { 00069 00172 class DDS : public DapObj 00173 { 00174 private: 00175 BaseTypeFactory *d_factory; 00176 00177 string name; // The dataset name 00178 string _filename; // File name (or other OS identifier) for 00179 string _container_name; // name of container structure 00180 Structure *d_container; // current container for container name 00181 // dataset or part of dataset. 00182 00183 // These are used on the client-side and correspond to the version of the 00184 // response. The client_dap_major/minor fields hold information sent from 00185 // a client describing what it would like. 00186 00187 int d_dap_major; // The protocol major version number 00188 int d_dap_minor; // ... and minor version number 00189 00190 // These hold the major and minor versions of DAP that the client sent in 00191 // the XDAP-Accept header. If the header is not sent, these default to 2.0 00192 int d_client_dap_major; 00193 int d_client_dap_minor; 00194 00195 string d_request_xml_base; 00196 00197 AttrTable d_attr; // Global attributes. 00198 00199 vector<BaseType *> vars; // Variables at the top level 00200 #if 0 00201 bool is_global_attr(string name); 00202 void add_global_attribute(AttrTable::entry *entry); 00203 #endif 00204 BaseType *find_hdf4_dimension_attribute_home(AttrTable::entry *source); 00205 00206 int d_timeout; // alarm time in seconds. If greater than 00207 // zero, raise the alarm signal if more than 00208 // d_timeout seconds are spent reading data. 00209 friend class DDSTest; 00210 00211 protected: 00212 void duplicate(const DDS &dds); 00213 BaseType *leaf_match(const string &name, BaseType::btp_stack *s = 0); 00214 BaseType *exact_match(const string &name, BaseType::btp_stack *s = 0); 00215 #if 0 00216 void transfer_attr(DAS *das, const AttrTable::entry *ep, BaseType *btp, 00217 const string &suffix = ""); 00218 void transfer_attr_table(DAS *das, AttrTable *at, BaseType *btp, 00219 const string &suffix = ""); 00220 void transfer_attr_table(DAS *das, AttrTable *at, Constructor *c, 00221 const string &suffix = ""); 00222 #endif 00223 virtual AttrTable *find_matching_container(AttrTable::entry *source, 00224 BaseType **dest_variable); 00225 00226 public: 00227 typedef std::vector<BaseType *>::const_iterator Vars_citer ; 00228 typedef std::vector<BaseType *>::iterator Vars_iter ; 00229 typedef std::vector<BaseType *>::reverse_iterator Vars_riter ; 00230 00231 DDS(BaseTypeFactory *factory, const string &n = ""); 00232 DDS(const DDS &dds); 00233 00234 virtual ~DDS(); 00235 00236 DDS & operator=(const DDS &rhs); 00237 00238 virtual void transfer_attributes(DAS *das); 00239 00240 string get_dataset_name() const; 00241 void set_dataset_name(const string &n); 00242 00247 BaseTypeFactory *get_factory() const 00248 { 00249 return d_factory; 00250 } 00251 00258 BaseTypeFactory *set_factory(BaseTypeFactory *factory) 00259 { 00260 BaseTypeFactory *t = d_factory; 00261 d_factory = factory; 00262 return t; 00263 } 00264 00265 virtual AttrTable &get_attr_table(); 00266 00267 string filename(); 00268 void filename(const string &fn); 00269 00271 int get_dap_major() const { return d_dap_major; } 00273 int get_dap_minor() const { return d_dap_minor; } 00274 00276 void set_dap_major(int p) { d_dap_major = p; } 00278 void set_dap_minor(int p) { d_dap_minor = p; } 00279 00280 void set_dap_version(const string &version_string); 00281 00283 int get_client_dap_major() const { return d_client_dap_major; } 00285 int get_client_dap_minor() const { return d_client_dap_minor; } 00286 00288 void set_client_dap_major(int p) { d_client_dap_major = p; } 00290 void set_client_dap_minor(int p) { d_client_dap_minor = p; } 00291 00292 void set_client_dap_version(const string &version_string); 00293 00295 string get_request_xml_base() const { return d_request_xml_base; } 00296 00298 void set_request_xml_base(const string &xb) { d_request_xml_base = xb; } 00299 00300 string container_name() ; 00301 void container_name( const string &cn ) ; 00302 Structure *container() ; 00303 00304 void add_var(BaseType *bt); 00305 00307 void del_var(const string &n); 00308 00309 BaseType *var(const string &n, BaseType::btp_stack &s); 00310 BaseType *var(const string &n, BaseType::btp_stack *s = 0); 00311 int num_var(); 00312 00314 Vars_iter var_begin(); 00316 Vars_riter var_rbegin(); 00318 Vars_iter var_end(); 00320 Vars_riter var_rend(); 00322 Vars_iter get_vars_iter(int i); 00324 BaseType *get_var_index(int i); 00326 void del_var(Vars_iter i); 00328 void del_var(Vars_iter i1, Vars_iter i2); 00329 00330 void timeout_on(); 00331 void timeout_off(); 00332 void set_timeout(int t); 00333 int get_timeout(); 00334 00335 void parse(string fname); 00336 void parse(int fd); 00337 void parse(FILE *in = stdin); 00338 //#if FILE_METHODS 00339 void print(FILE *out); 00340 //#endif 00341 void print(ostream &out); 00342 //#if FILE_METHODS 00343 void print_constrained(FILE *out); 00344 //#endif 00345 void print_constrained(ostream &out); 00346 //#if FILE_METHODS 00347 void print_xml(FILE *out, bool constrained, const string &blob); 00348 //#endif 00349 void print_xml(ostream &out, bool constrained, const string &blob); 00350 00351 void mark_all(bool state); 00352 bool mark(const string &name, bool state); 00353 bool check_semantics(bool all = false); 00354 00355 void tag_nested_sequences(); 00356 00357 virtual void dump(ostream &strm) const ; 00358 }; 00359 00360 } // namespace libdap 00361 00362 #endif // _dds_h