BaseType.cc

 
// -*- mode: c++; c-basic-offset:4 -*-
 
// This file is part of libdap, A C++ implementation of the OPeNDAP Data
// Access Protocol.
 
// Copyright (c) 2002,2003 OPeNDAP, Inc.
// Author: James Gallagher <jgallagher@opendap.org>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
 
// (c) COPYRIGHT URI/MIT 1994-1999
// Please read the full copyright statement in the file COPYRIGHT_URI.
//
// Authors:
//      jhrg,jimg       James Gallagher <jgallagher@gso.uri.edu>
 
// Implementation for BaseType.
//
// jhrg 9/6/94
 
#include "config.h"
 
#include <cstdio>  // for stdin and stdout
 
#include <sstream>
#include <string>
 
//#define DODS_DEBUG
 
#include "BaseType.h"
#include "Byte.h"
#include "Int16.h"
#include "UInt16.h"
#include "Int32.h"
#include "UInt32.h"
#include "Float32.h"
#include "Float64.h"
#include "Str.h"
#include "Url.h"
#include "Array.h"
#include "Structure.h"
#include "Sequence.h"
#include "Grid.h"
 
#include "D4Attributes.h"
#include "DMR.h"
#include "XMLWriter.h"
#include "D4BaseTypeFactory.h"
 
#include "InternalErr.h"
 
#include "util.h"
#include "escaping.h"
#include "DapIndent.h"
 
#include "debug.h"
 
using namespace std;
 
namespace libdap {
 
// Protected copy mfunc
 
void
BaseType::m_duplicate(const BaseType &bt)
{
    DBG(cerr << "In BaseType::m_duplicate for " << bt.name() << endl);
 
    d_name = bt.d_name;
    d_type = bt.d_type;
    d_dataset = bt.d_dataset;
    d_is_read = bt.d_is_read; // added, reza
    d_is_send = bt.d_is_send; // added, reza
    d_in_selection = bt.d_in_selection;
    d_is_synthesized = bt.d_is_synthesized; // 5/11/2001 jhrg
 
    d_parent = bt.d_parent; // copy pointers 6/4/2001 jhrg
 
    d_attr = bt.d_attr;  // Deep copy.
 
    if (bt.d_attributes)
        d_attributes = new D4Attributes(*bt.d_attributes); // deep copy
    else
        d_attributes = 0; // init to null if not used.
 
    d_is_dap4 = bt.d_is_dap4;
 
    DBG(cerr << "Exiting BaseType::m_duplicate for " << bt.name() << endl);
}
 
// Public mfuncs
 
BaseType::BaseType(const string &n, const Type &t, bool is_dap4)
: d_name(n), d_type(t), d_dataset(""), d_is_read(false), d_is_send(false),
  d_parent(0), d_attributes(0), d_is_dap4(is_dap4),
  d_in_selection(false), d_is_synthesized(false)
{}
 
BaseType::BaseType(const string &n, const string &d, const Type &t, bool is_dap4)
: d_name(n), d_type(t), d_dataset(d), d_is_read(false), d_is_send(false),
  d_parent(0), d_attributes(0), d_is_dap4(is_dap4),
  d_in_selection(false), d_is_synthesized(false)
{}
 
BaseType::BaseType(const BaseType &copy_from) : DapObj()
{
    DBG(cerr << "In BaseTpe::copy_ctor for " << copy_from.name() << endl);
    m_duplicate(copy_from);
}
 
BaseType::~BaseType()
{
    DBG2(cerr << "Entering ~BaseType (" << this << ")" << endl);
 
    if (d_attributes)
        delete d_attributes;
 
    DBG2(cerr << "Exiting ~BaseType" << endl);
}
 
BaseType &
BaseType::operator=(const BaseType &rhs)
{
    if (this == &rhs)
        return *this;
    m_duplicate(rhs);
    return *this;
}
 
string BaseType::toString()
{
    ostringstream oss;
    oss << "BaseType (" << this << "):" << endl
        << "          _name: " << name() << endl
        << "          _type: " << type_name() << endl
        << "          _dataset: " << d_dataset << endl
        << "          _read_p: " << d_is_read << endl
        << "          _send_p: " << d_is_send << endl
        << "          _synthesized_p: " << d_is_synthesized << endl
        << "          d_parent: " << d_parent << endl
        << "          d_attr: " << hex << &d_attr << dec << endl;
 
    return oss.str();
}
 
void
BaseType::transform_to_dap4(D4Group */*root*/, Constructor *container)
{
    BaseType *dest = ptr_duplicate();
    // If it's already a DAP4 object then we can just return it!
    if(!is_dap4()){
        dest->attributes()->transform_to_dap4(get_attr_table());
        dest->set_is_dap4(true);
    }
    container->add_var_nocopy(dest);
}
 
 
std::vector<BaseType *> *
BaseType::transform_to_dap2(AttrTable *)
{
    BaseType *dest = this->ptr_duplicate();
    // convert the d4 attributes to a dap2 attribute table.
    // HK-403. jhrg 6/17/19
#if 0
    AttrTable *attrs = this->attributes()->get_AttrTable(name());
    dest->set_attr_table(*attrs);
#else
    if (dest->get_attr_table().get_size() == 0) {
        attributes()->transform_attrs_to_dap2(&dest->get_attr_table());
        dest->get_attr_table().set_name(name());
    }
#endif
 
    dest->set_is_dap4(false);
 
    vector<BaseType *> *result =  new vector<BaseType *>();
    result->push_back(dest);
    return result;
}
 
 
void
BaseType::dump(ostream &strm) const
{
    strm << DapIndent::LMarg << "BaseType::dump - ("
        << (void *)this << ")" << endl ;
    DapIndent::Indent() ;
 
    strm << DapIndent::LMarg << "name: " << name() << endl ;
    strm << DapIndent::LMarg << "type: " << type_name() << endl ;
    strm << DapIndent::LMarg << "dataset: " << d_dataset << endl ;
    strm << DapIndent::LMarg << "read_p: " << d_is_read << endl ;
    strm << DapIndent::LMarg << "send_p: " << d_is_send << endl ;
    strm << DapIndent::LMarg << "synthesized_p: " << d_is_synthesized << endl ;
    strm << DapIndent::LMarg << "parent: " << (void *)d_parent << endl ;
    strm << DapIndent::LMarg << "attributes: " << endl ;
    DapIndent::Indent() ;
 
    if (d_attributes)
        d_attributes->dump(strm);
    else
        d_attr.dump(strm) ;
 
    DapIndent::UnIndent() ;
 
    DapIndent::UnIndent() ;
}
 
string
BaseType::name() const
{
    return d_name;
}
 
string
BaseType::FQN() const
{
    if (get_parent() == 0)
        return name();
    else if (get_parent()->type() == dods_group_c)
        return get_parent()->FQN() + name();
    else
        return get_parent()->FQN() + "." + name();
}
 
void
BaseType::set_name(const string &n)
{
    string name = n;
    d_name = www2id(name); // www2id writes into its param.
}
 
string
BaseType::dataset() const
{
    return d_dataset;
}
 
Type
BaseType::type() const
{
    return d_type;
}
 
void
BaseType::set_type(const Type &t)
{
    d_type = t;
}
 
string
BaseType::type_name() const
{
    if (is_dap4())
        return libdap::D4type_name(d_type);
    else
        return libdap::D2type_name(d_type);
}
 
bool
BaseType::is_simple_type() const
{
    return libdap::is_simple_type(type());
}
 
bool
BaseType::is_vector_type() const
{
    return libdap::is_vector_type(type());
}
 
bool
BaseType::is_constructor_type() const
{
    return libdap::is_constructor_type(type());
}
 
int
BaseType::element_count(bool)
{
    return 1;
}
 
bool
BaseType::synthesized_p()
{
    return d_is_synthesized;
}
 
void
BaseType::set_synthesized_p(bool state)
{
    d_is_synthesized = state;
}
 
// Return the state of d_is_read (true if the value of the variable has been
// read (and is in memory) false otherwise).
 
bool
BaseType::read_p()
{
    return d_is_read;
}
 
void
BaseType::set_read_p(bool state)
{
    // The this comment is/was wrong!
    // The is_synthesized property was not being used and the more I thought
    // about how this was coded, the more this code below seemed like a bad idea.
    // Once the property was set, the read_p property could not be changed.
    // That seems a little silly. Also, I think I need to use this is_synthesized
    // property for some of the server function code I'm working on for Raytheon,
    // and I'd like to be able to control the read_p property! jhrg 3/9/15
 
    // What's true: The is_synthesized property is used by
    // 'projection functions' in the freeform handler. It might be better
    // to modify the FFtypes to support this behavior, but for now I'm returning
    // the library to its old behavior. That this change (setting is_read
    // of the value of is_syn...) broke the FF handler was not detected
    // because the FF tests were not being run due to an error in the FF
    // bes-testsuite Makefile.am). jhrg 9/9/15
 
#if 1
    if (!d_is_synthesized) {
        d_is_read = state;
    }
#else
    d_is_read = state;
#endif
}
 
bool
BaseType::send_p()
{
    return d_is_send;
}
 
void
BaseType::set_send_p(bool state)
{
    DBG2(cerr << "Calling BaseType::set_send_p() for: " << this->name()
        << endl);
    d_is_send = state;
}
 
 
AttrTable &
BaseType::get_attr_table()
{
    return d_attr;
}
 
void
BaseType::set_attr_table(const AttrTable &at)
{
    d_attr = at;
}
 
D4Attributes *
BaseType::attributes()
{
    if (!d_attributes) d_attributes = new D4Attributes();
    return d_attributes;
}
 
void
BaseType::set_attributes(D4Attributes *attrs)
{
    d_attributes = new D4Attributes(*attrs);
}
 
void
BaseType::set_attributes_nocopy(D4Attributes *attrs)
{
    d_attributes = attrs;
}
 
void BaseType::transfer_attributes(AttrTable *at_container) {
 
    DBG(cerr << __func__ << "() -  BEGIN name:'" << name() << "'" << endl);
 
    AttrTable *at = at_container->get_attr_table(name());
    DBG(cerr << __func__ << "() - at: "<< (void *) at << endl);
 
 
    if (at) {
        at->set_is_global_attribute(false);
        DBG(cerr << __func__ << "() - Processing AttrTable: " << at->get_name() << endl);
 
        AttrTable::Attr_iter at_p = at->attr_begin();
        while (at_p != at->attr_end()) {
            DBG(cerr << __func__ << "() -  Attribute '" << at->get_name(at_p) << "' is type: " << at->get_type(at_p) << endl);
            if (at->get_attr_type(at_p) == Attr_container){
                // An attribute container may actually represent a child member variable. When
                // that's the case we don't want to add the container to the parent type, but
                // rather let any child of BaseType deal with those containers in the child's
                // overridden transfer_attributes() method.
                // We capitalize on the magic of the BaseType API and utilize the var() method
                // to check for a child variable of the same name and, if one exists, we'll skip
                // this AttrTable and let a child constructor class like Grid or Constructor
                // deal with it.
                BaseType *bt = var(at->get_name(at_p),true);
                if(bt==0){
                    DBG(cerr << __func__ << "() - Adding container '" << at->get_name(at_p) << endl);
                    get_attr_table().append_container(new AttrTable(*at->get_attr_table(at_p)), at->get_name(at_p));
                }
                else {
                    DBG(cerr << __func__ << "() - Found child var: '"<< bt->type_name()<< " " << bt->name() << " (address:" << (void *) bt << ")" << endl);
                    DBG(cerr << __func__ << "() -  Skipping container '" << at->get_name(at_p) << endl);
                }
            }
            else {
                DBG(cerr << __func__ << "() - Adding Attribute '" << at->get_name(at_p) << endl);
                get_attr_table().append_attr(at->get_name(at_p), at->get_type(at_p), at->get_attr_vector(at_p));
            }
            at_p++;
        }
    }
    else {
        DBG(cerr << __func__ << "() - Unable to locate AttrTable '" << name() << "'  SKIPPING" << endl);
 
    }
}
 
bool
BaseType::is_in_selection()
{
    return d_in_selection;
}
 
void
BaseType::set_in_selection(bool state)
{
    d_in_selection = state;
}
 
// Protected method.
void
BaseType::set_parent(BaseType *parent)
{
    if (!dynamic_cast<Constructor *>(parent)
        && !dynamic_cast<Vector *>(parent)
        && parent != 0)
        throw InternalErr("Call to set_parent with incorrect variable type.");
 
    d_parent = parent;
}
 
// Public method.
 
BaseType *
BaseType::get_parent() const
{
    return d_parent;
}
 
// Documented in the header file.
BaseType *
BaseType::var(const string &/*name*/, bool /*exact_match*/, btp_stack */*s*/)
{
    return static_cast<BaseType *>(0);
}
 
BaseType *
BaseType::var(const string &, btp_stack &)
{
    return static_cast<BaseType *>(0);
}
 
void
BaseType::add_var(BaseType *, Part)
{
    throw InternalErr(__FILE__, __LINE__, "BaseType::add_var unimplemented");
}
 
void
BaseType::add_var_nocopy(BaseType *, Part)
{
    throw InternalErr(__FILE__, __LINE__, "BaseType::add_var_nocopy unimplemented");
}
 
bool
BaseType::read()
{
    if (d_is_read)
        return true;
 
    throw InternalErr("Unimplemented BaseType::read() method called for the variable named: " + name());
}
 
void
BaseType::intern_data(ConstraintEvaluator &, DDS &/*dds*/)
{
#if USE_LOCAL_TIMEOUT_SCHEME
    dds.timeout_on();
#endif
    DBG2(cerr << "BaseType::intern_data: " << name() << endl);
    if (!read_p())
        read();          // read() throws Error and InternalErr
#if USE_LOCAL_TIMEOUT_SCHEME
    dds.timeout_off();
#endif
}
 
void
BaseType::intern_data(/*Crc32 &checksum, DMR &, ConstraintEvaluator &*/)
{
    if (!read_p())
        read();          // read() throws Error and InternalErr
#if 0
    compute_checksum(checksum);
#endif
}
 
bool
BaseType::serialize(ConstraintEvaluator &, DDS &,  Marshaller &, bool)
{
    throw InternalErr(__FILE__, __LINE__, "The DAP2 serialize() method has not been implemented for " + type_name());
}
 
bool
BaseType::deserialize(UnMarshaller &, DDS *, bool)
{
    throw InternalErr(__FILE__, __LINE__, "The DAP2 deserialize() method has not been implemented for " + type_name());
}
 
void
BaseType::serialize(D4StreamMarshaller &, DMR &, /*ConstraintEvaluator &,*/ bool)
{
    throw InternalErr(__FILE__, __LINE__, "The DAP4 serialize() method has not been implemented for " + type_name());
}
 
void
BaseType::deserialize(D4StreamUnMarshaller &, DMR &)
{
    throw InternalErr(__FILE__, __LINE__, "The DAP4 deserialize() method has not been implemented for " + type_name());
}
 
void
BaseType::print_decl(FILE *out, string space, bool print_semi,
    bool constraint_info, bool constrained)
{
    ostringstream oss;
    print_decl(oss, space, print_semi, constraint_info, constrained);
    fwrite(oss.str().data(), sizeof(char), oss.str().length(), out);
}
 
void
BaseType::print_decl(ostream &out, string space, bool print_semi,
    bool constraint_info, bool constrained)
{
    // if printing the constrained declaration, exit if this variable was not
    // selected.
    if (constrained && !send_p())
        return;
 
    out << space << type_name() << " " << id2www(name()) ;
 
    if (constraint_info) {
        if (send_p())
            out << ": Send True" ;
        else
            out << ": Send False" ;
    }
 
    if (print_semi)
        out << ";\n" ;
}
 
void
BaseType::print_val(FILE *out, string space, bool print_decl_p)
{
    ostringstream oss;
    print_val(oss, space, print_decl_p);
    fwrite(oss.str().data(), sizeof(char), oss.str().length(), out);
}
 
void
BaseType::print_xml(FILE *out, string space, bool constrained)
{
    XMLWriter xml(space);
    print_xml_writer(xml, constrained);
    fwrite(xml.get_doc(), sizeof(char), xml.get_doc_size(), out);
}
 
void
BaseType::print_xml(ostream &out, string space, bool constrained)
{
    XMLWriter xml(space);
    print_xml_writer(xml, constrained);
    out << xml.get_doc();
}
 
void
BaseType::print_xml_writer(XMLWriter &xml, bool constrained)
{
    if (constrained && !send_p())
        return;
 
    if (xmlTextWriterStartElement(xml.get_writer(), (const xmlChar*)type_name().c_str()) < 0)
        throw InternalErr(__FILE__, __LINE__, "Could not write " + type_name() + " element");
 
    if (!name().empty())
        if (xmlTextWriterWriteAttribute(xml.get_writer(), (const xmlChar*) "name", (const xmlChar*)name().c_str()) < 0)
            throw InternalErr(__FILE__, __LINE__, "Could not write attribute for name");
 
    if (is_dap4())
        attributes()->print_dap4(xml);
 
    if (!is_dap4() && get_attr_table().get_size() > 0)
        get_attr_table().print_xml_writer(xml);
 
    if (xmlTextWriterEndElement(xml.get_writer()) < 0)
        throw InternalErr(__FILE__, __LINE__, "Could not end " + type_name() + " element");
}
 
void
BaseType::print_dap4(XMLWriter &xml, bool constrained)
{
    print_xml_writer(xml, constrained);
}
 
// Compares the object's current state with the semantics of a particular
// type. This will typically be defined in ctor classes (which have
// complicated semantics). For BaseType, an object is semantically correct if
// it has both a non-null name and type.
//
// NB: This is not the same as an invariant -- during the parse objects exist
// but have no name. Also, the bool ALL defaults to false for BaseType. It is
// used by children of CtorType.
//
// Returns: true if the object is semantically correct, false otherwise.
 
bool
BaseType::check_semantics(string &msg, bool)
{
    bool sem = (d_type != dods_null_c && name().length());
 
    if (!sem)
        msg = "Every variable must have both a name and a type\n";
 
    return sem;
}
 
bool
BaseType::ops(BaseType *, int)
{
    // Even though ops is a public method, it can never be called because
    // they will never have a BaseType object since this class is abstract,
    // however any of the child classes could by mistake call BaseType::ops
    // so this is an internal error. Jose Garcia
    throw InternalErr(__FILE__, __LINE__, "Unimplemented operator.");
}
 
bool
BaseType::d4_ops(BaseType *, int)
{
    throw InternalErr(__FILE__, __LINE__, "Unimplemented operator.");
}
 
unsigned int
BaseType::width(bool /* constrained */) const
{
    throw InternalErr(__FILE__, __LINE__, "not implemented");
}
 
} // namespace libdap