00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036 #include "config.h"
00037
00038 #include <cstdio>
00039
00040 #include <sstream>
00041 #include <string>
00042
00043
00044
00045 #include "BaseType.h"
00046 #include "Byte.h"
00047 #include "Int16.h"
00048 #include "UInt16.h"
00049 #include "Int32.h"
00050 #include "UInt32.h"
00051 #include "Float32.h"
00052 #include "Float64.h"
00053 #include "Str.h"
00054 #include "Url.h"
00055 #include "Array.h"
00056 #include "Structure.h"
00057 #include "Sequence.h"
00058 #include "Grid.h"
00059
00060 #include "InternalErr.h"
00061
00062 #include "util.h"
00063 #include "escaping.h"
00064
00065 #include "debug.h"
00066
00067 using namespace std;
00068
00069 namespace libdap {
00070
00071
00072
00079 void
00080 BaseType::_duplicate(const BaseType &bt)
00081 {
00082 DBG(cerr << "BaseType::_duplicate: " << bt._name << " send_p: "
00083 << bt._send_p << endl);
00084 _name = bt._name;
00085 _type = bt._type;
00086 _dataset = bt._dataset;
00087 _read_p = bt._read_p;
00088 _send_p = bt._send_p;
00089 d_in_selection = bt.d_in_selection;
00090 _synthesized_p = bt._synthesized_p;
00091
00092 d_parent = bt.d_parent;
00093
00094 d_attr = bt.d_attr;
00095 }
00096
00097
00098
00110 BaseType::BaseType(const string &n, const Type &t)
00111 : _name(n), _type(t), _dataset(""), _read_p(false), _send_p(false),
00112 d_in_selection(false), _synthesized_p(false), d_parent(0)
00113 {}
00114
00128 BaseType::BaseType(const string &n, const string &d, const Type &t)
00129 : _name(n), _type(t), _dataset(d), _read_p(false), _send_p(false),
00130 d_in_selection(false), _synthesized_p(false), d_parent(0)
00131 {}
00132
00134 BaseType::BaseType(const BaseType ©_from) : DapObj()
00135 {
00136 _duplicate(copy_from);
00137 }
00138
00139 BaseType::~BaseType()
00140 {
00141 DBG(cerr << "Entering ~BaseType (" << this << ")" << endl);
00142 DBG(cerr << "Exiting ~BaseType" << endl);
00143 }
00144
00145 BaseType &
00146 BaseType::operator=(const BaseType &rhs)
00147 {
00148 if (this == &rhs)
00149 return *this;
00150
00151 _duplicate(rhs);
00152
00153 return *this;
00154 }
00155
00160 string
00161 BaseType::toString()
00162 {
00163 ostringstream oss;
00164 oss << "BaseType (" << this << "):" << endl
00165 << " _name: " << _name << endl
00166 << " _type: " << type_name() << endl
00167 << " _dataset: " << _dataset << endl
00168 << " _read_p: " << _read_p << endl
00169 << " _send_p: " << _send_p << endl
00170 << " _synthesized_p: " << _synthesized_p << endl
00171 << " d_parent: " << d_parent << endl
00172 << " d_attr: " << hex << &d_attr << dec << endl;
00173
00174 return oss.str();
00175 }
00176
00185 void
00186 BaseType::dump(ostream &strm) const
00187 {
00188 strm << DapIndent::LMarg << "BaseType::dump - ("
00189 << (void *)this << ")" << endl ;
00190 DapIndent::Indent() ;
00191
00192 strm << DapIndent::LMarg << "name: " << _name << endl ;
00193 strm << DapIndent::LMarg << "type: " << type_name() << endl ;
00194 strm << DapIndent::LMarg << "dataset: " << _dataset << endl ;
00195 strm << DapIndent::LMarg << "read_p: " << _read_p << endl ;
00196 strm << DapIndent::LMarg << "send_p: " << _send_p << endl ;
00197 strm << DapIndent::LMarg << "synthesized_p: " << _synthesized_p << endl ;
00198 strm << DapIndent::LMarg << "parent: " << (void *)d_parent << endl ;
00199 strm << DapIndent::LMarg << "attributes: " << endl ;
00200 DapIndent::Indent() ;
00201 d_attr.dump(strm) ;
00202 DapIndent::UnIndent() ;
00203
00204 DapIndent::UnIndent() ;
00205 }
00206
00209 string
00210 BaseType::name() const
00211 {
00212 return _name;
00213 }
00214
00216 void
00217 BaseType::set_name(const string &n)
00218 {
00219 string name = n;
00220 _name = www2id(name);
00221 }
00222
00230 string
00231 BaseType::dataset() const
00232 {
00233 return _dataset;
00234 }
00235
00237 Type
00238 BaseType::type() const
00239 {
00240 return _type;
00241 }
00242
00244 void
00245 BaseType::set_type(const Type &t)
00246 {
00247 _type = t;
00248 }
00249
00251 string
00252 BaseType::type_name() const
00253 {
00254 switch (_type) {
00255 case dods_null_c:
00256 return string("Null");
00257 case dods_byte_c:
00258 return string("Byte");
00259 case dods_int16_c:
00260 return string("Int16");
00261 case dods_uint16_c:
00262 return string("UInt16");
00263 case dods_int32_c:
00264 return string("Int32");
00265 case dods_uint32_c:
00266 return string("UInt32");
00267 case dods_float32_c:
00268 return string("Float32");
00269 case dods_float64_c:
00270 return string("Float64");
00271 case dods_str_c:
00272 return string("String");
00273 case dods_url_c:
00274 return string("Url");
00275 case dods_array_c:
00276 return string("Array");
00277 case dods_structure_c:
00278 return string("Structure");
00279 case dods_sequence_c:
00280 return string("Sequence");
00281 case dods_grid_c:
00282 return string("Grid");
00283 default:
00284 cerr << "BaseType::type_name: Undefined type" << endl;
00285 return string("");
00286 }
00287 }
00288
00294 bool
00295 BaseType::is_simple_type()
00296 {
00297 switch (type()) {
00298 case dods_null_c:
00299 case dods_byte_c:
00300 case dods_int16_c:
00301 case dods_uint16_c:
00302 case dods_int32_c:
00303 case dods_uint32_c:
00304 case dods_float32_c:
00305 case dods_float64_c:
00306 case dods_str_c:
00307 case dods_url_c:
00308 return true;
00309
00310 case dods_array_c:
00311 case dods_structure_c:
00312 case dods_sequence_c:
00313 case dods_grid_c:
00314 return false;
00315 }
00316
00317 return false;
00318 }
00319
00323 bool
00324 BaseType::is_vector_type()
00325 {
00326 switch (type()) {
00327 case dods_null_c:
00328 case dods_byte_c:
00329 case dods_int16_c:
00330 case dods_uint16_c:
00331 case dods_int32_c:
00332 case dods_uint32_c:
00333 case dods_float32_c:
00334 case dods_float64_c:
00335 case dods_str_c:
00336 case dods_url_c:
00337 return false;
00338
00339 case dods_array_c:
00340 return true;
00341
00342 case dods_structure_c:
00343 case dods_sequence_c:
00344 case dods_grid_c:
00345 return false;
00346 }
00347
00348 return false;
00349 }
00350
00355 bool
00356 BaseType::is_constructor_type()
00357 {
00358 switch (type()) {
00359 case dods_null_c:
00360 case dods_byte_c:
00361 case dods_int16_c:
00362 case dods_uint16_c:
00363 case dods_int32_c:
00364 case dods_uint32_c:
00365 case dods_float32_c:
00366 case dods_float64_c:
00367 case dods_str_c:
00368 case dods_url_c:
00369 case dods_array_c:
00370 return false;
00371
00372 case dods_structure_c:
00373 case dods_sequence_c:
00374 case dods_grid_c:
00375 return true;
00376 }
00377
00378 return false;
00379 }
00380
00406 int
00407 BaseType::element_count(bool)
00408 {
00409 return 1;
00410 }
00411
00415 bool
00416 BaseType::synthesized_p()
00417 {
00418 return _synthesized_p;
00419 }
00420
00426 void
00427 BaseType::set_synthesized_p(bool state)
00428 {
00429 _synthesized_p = state;
00430 }
00431
00432
00433
00434
00443 bool
00444 BaseType::read_p()
00445 {
00446 return _read_p;
00447 }
00448
00482 void
00483 BaseType::set_read_p(bool state)
00484 {
00485 if (! _synthesized_p) {
00486 DBG(cerr << "Changing read_p state of " << name() << " to "
00487 << state << endl);
00488 _read_p = state;
00489 }
00490 }
00491
00502 bool
00503 BaseType::send_p()
00504 {
00505 return _send_p;
00506 }
00507
00516 void
00517 BaseType::set_send_p(bool state)
00518 {
00519 DBG(cerr << "Calling BaseType::set_send_p() for: " << this->name()
00520 << endl);
00521 _send_p = state;
00522 }
00523
00524
00530 AttrTable &
00531 BaseType::get_attr_table()
00532 {
00533 return d_attr;
00534 }
00535
00538 void
00539 BaseType::set_attr_table(const AttrTable &at)
00540 {
00541 d_attr = at;
00542 }
00543
00570 void
00571 BaseType::transfer_attributes(AttrTable *at_container)
00572 {
00573 AttrTable *at = at_container->get_attr_table(name());
00574
00575 DBG(cerr << "In BaseType::transfer_attributes; processing " << name() << endl);
00576
00577 if (at) {
00578 at->set_is_global_attribute(false);
00579 DBG(cerr << "Processing AttrTable: " << at->get_name() << endl);
00580
00581 AttrTable::Attr_iter at_p = at->attr_begin();
00582 while (at_p != at->attr_end()) {
00583 DBG(cerr << "About to append " << endl);
00584 DBG(cerr << "attr name,type:" << at->get_name(at_p) << ", " << at->get_type(at_p) << endl);
00585
00586 if (at->get_attr_type(at_p) == Attr_container)
00587 get_attr_table().append_container(new AttrTable(*at->get_attr_table(at_p)),
00588 at->get_name(at_p));
00589 else
00590 get_attr_table().append_attr(at->get_name(at_p),
00591 at->get_type(at_p), at->get_attr_vector(at_p));
00592
00593 at_p++;
00594 }
00595 }
00596 }
00597
00609 bool
00610 BaseType::is_in_selection()
00611 {
00612 return d_in_selection;
00613 }
00614
00624 void
00625 BaseType::set_in_selection(bool state)
00626 {
00627 d_in_selection = state;
00628 }
00629
00630
00637 void
00638 BaseType::set_parent(BaseType *parent)
00639 {
00640 if (!dynamic_cast<Constructor *>(parent)
00641 && !dynamic_cast<Vector *>(parent))
00642 throw InternalErr("Call to set_parent with incorrect variable type.");
00643
00644 d_parent = parent;
00645 }
00646
00647
00648
00654 BaseType *
00655 BaseType::get_parent()
00656 {
00657 return d_parent;
00658 }
00659
00660
00661 BaseType *
00662 BaseType::var(const string &, bool , btp_stack *)
00663 {
00664 return static_cast<BaseType *>(0);
00665 }
00666
00683 BaseType *
00684 BaseType::var(const string &, btp_stack &)
00685 {
00686 return static_cast<BaseType *>(0);
00687 }
00688
00718 void
00719 BaseType::add_var(BaseType *, Part)
00720 {
00721 throw InternalErr(__FILE__, __LINE__, "BaseType::add_var unimplemented");
00722 }
00723
00789 bool
00790 BaseType::read()
00791 {
00792 if (_read_p)
00793 return false;
00794
00795 throw InternalErr("Unimplemented BaseType::read() method called.");
00796 }
00797
00798 void
00799 BaseType::intern_data(ConstraintEvaluator &, DDS &dds)
00800 {
00801 dds.timeout_on();
00802 DBG(cerr << "BaseType::intern_data: " << name() << endl);
00803 if (!read_p())
00804 read();
00805
00806 dds.timeout_off();
00807 }
00808
00809 #if FILE_METHODS
00810
00852 void
00853 BaseType::print_decl(FILE *out, string space, bool print_semi,
00854 bool constraint_info, bool constrained)
00855 {
00856
00857
00858 if (constrained && !send_p())
00859 return;
00860
00861 fprintf(out, "%s%s %s", space.c_str(), type_name().c_str(),
00862 id2www(_name).c_str()) ;
00863
00864 if (constraint_info) {
00865 if (send_p())
00866 fprintf(out, ": Send True") ;
00867 else
00868 fprintf(out, ": Send False") ;
00869 }
00870
00871 if (print_semi)
00872 fprintf(out, ";\n") ;
00873 }
00874 #endif
00875
00918 void
00919 BaseType::print_decl(ostream &out, string space, bool print_semi,
00920 bool constraint_info, bool constrained)
00921 {
00922
00923
00924 if (constrained && !send_p())
00925 return;
00926
00927 out << space << type_name() << " " << id2www(_name) ;
00928
00929 if (constraint_info) {
00930 if (send_p())
00931 out << ": Send True" ;
00932 else
00933 out << ": Send False" ;
00934 }
00935
00936 if (print_semi)
00937 out << ";\n" ;
00938 }
00939
00940 #if FILE_METHODS
00941
00947 void
00948 BaseType::print_xml(FILE *out, string space, bool constrained)
00949 {
00950 if (constrained && !send_p())
00951 return;
00952
00953 fprintf(out, "%s<%s", space.c_str(), type_name().c_str());
00954 if (!_name.empty())
00955 fprintf(out, " name=\"%s\"", id2xml(_name).c_str());
00956
00957 if (get_attr_table().get_size() > 0) {
00958 fprintf(out, ">\n");
00959 get_attr_table().print_xml(out, space + " ", constrained);
00960
00961 fprintf(out, "%s</%s>\n", space.c_str(), type_name().c_str());
00962 }
00963 else {
00964 fprintf(out, "/>\n");
00965 }
00966 }
00967 #endif
00968
00975 void
00976 BaseType::print_xml(ostream &out, string space, bool constrained)
00977 {
00978 if (constrained && !send_p())
00979 return;
00980
00981 out << space << "<" << type_name() ;
00982 if (!_name.empty())
00983 out << " name=\"" << id2xml(_name) << "\"" ;
00984
00985 if (get_attr_table().get_size() > 0) {
00986 out << ">\n" ;
00987 get_attr_table().print_xml(out, space + " ", constrained);
00988
00989 out << space << "</" << type_name() << ">\n" ;
00990 }
00991 else {
00992 out << "/>\n" ;
00993 }
00994 }
00995
00996
00997
00998
00999
01000
01001
01002
01003
01004
01005
01006
01035 bool
01036 BaseType::check_semantics(string &msg, bool)
01037 {
01038 bool sem = (_type != dods_null_c && _name.length());
01039
01040 if (!sem)
01041 msg = "Every variable must have both a name and a type\n";
01042
01043 return sem;
01044 }
01045
01080 bool
01081 BaseType::ops(BaseType *, int)
01082 {
01083
01084
01085
01086
01087 throw InternalErr(__FILE__, __LINE__, "Unimplemented operator.");
01088 }
01089
01090 }