RenamedArrayWrapper.h

Go to the documentation of this file.

// This file is part of the "NcML Module" project, a BES module designed
// to allow NcML files to be used to be used as a wrapper to add
// AIS to existing datasets of any format.
//
// Copyright (c) 2009 OPeNDAP, Inc.
// Author: Michael Johnson  <m.johnson@opendap.org>
//
// For more information, please also see the main website: http://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
//
// Please see the files COPYING and COPYRIGHT for more information on the GLPL.
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
#ifndef __NCML_MODULE__RENAMED_ARRAY_WRAPPER_H__
#define __NCML_MODULE__RENAMED_ARRAY_WRAPPER_H__

#include "config.h"
#include <Array.h>
#include <vector>
using std::vector;
using std::string;
using namespace libdap;

namespace libdap
{
  class DDS;
  class Marshaller;
  class UnMarshaller;
}

namespace ncml_module
{
  class RenamedArrayWrapper : public libdap::Array
  {
  public:
    RenamedArrayWrapper();
    RenamedArrayWrapper(const RenamedArrayWrapper& proto);

    RenamedArrayWrapper(libdap::Array* toBeWrapped);

    virtual ~RenamedArrayWrapper();

    virtual RenamedArrayWrapper* ptr_duplicate();
    RenamedArrayWrapper& operator=(const RenamedArrayWrapper& rhs);

    // OVERRIDES OF ALL VIRTUALS!

    virtual void add_constraint(Dim_iter i, int start, int stride, int stop);
    virtual void reset_constraint();

    virtual void clear_constraint();

    virtual string toString();
    virtual string toString() const;
    virtual void dump(ostream &strm) const ;

    // Don't need to override this, it does what we want.
    // virtual void set_name(const string &n);

    virtual bool is_simple_type() const;
    virtual bool is_vector_type() const;
    virtual bool is_constructor_type() const;

    virtual bool synthesized_p();
    virtual void set_synthesized_p(bool state);

    virtual int element_count(bool leaves = false);

    virtual bool read_p();
    virtual void set_read_p(bool state);

    virtual bool send_p();
    virtual void set_send_p(bool state);

    virtual libdap::AttrTable& get_attr_table();
    virtual void set_attr_table(const libdap::AttrTable &at);

    virtual bool is_in_selection();
    virtual void set_in_selection(bool state);

    virtual void set_parent(BaseType *parent);
    virtual BaseType *get_parent() const;

    virtual BaseType *var(const string &name = "", bool exact_match = true,
        btp_stack *s = 0);
    virtual BaseType *var(const string &name, btp_stack &s);
    virtual void add_var(BaseType *bt, Part part = nil);

    virtual bool read();
    virtual bool check_semantics(string &msg, bool all = false);
    virtual bool ops(BaseType *b, int op);

#if FILE_METHODS // from BaseType.h, whether we include FILE* methods
    virtual void print_decl(FILE *out, string space = "    ",
        bool print_semi = true,
        bool constraint_info = false,
        bool constrained = false);
    virtual void print_xml(FILE *out, string space = "    ",
            bool constrained = false);
    virtual void print_val(FILE *out, string space = "",
            bool print_decl_p = true);
#endif // FILE_METHODS

    virtual void print_decl(ostream &out, string space = "    ",
        bool print_semi = true,
        bool constraint_info = false,
        bool constrained = false);
    virtual void print_xml(ostream &out, string space = "    ",
        bool constrained = false);
    virtual void print_val(ostream &out, string space = "",
        bool print_decl_p = true);


    virtual unsigned int width(bool constrained = false);
    virtual unsigned int buf2val(void **val);
    virtual unsigned int val2buf(void *val, bool reuse = false);

    virtual void intern_data(ConstraintEvaluator &eval, DDS &dds);
    virtual bool serialize(ConstraintEvaluator &eval, DDS &dds,
        Marshaller &m, bool ce_eval = true);
    virtual bool deserialize(UnMarshaller &um, DDS *dds, bool reuse = false);

    virtual bool set_value(dods_byte *val, int sz);
    virtual bool set_value(vector<dods_byte> &val, int sz);
    virtual bool set_value(dods_int16 *val, int sz);
    virtual bool set_value(vector<dods_int16> &val, int sz);
    virtual bool set_value(dods_uint16 *val, int sz);
    virtual bool set_value(vector<dods_uint16> &val, int sz);
    virtual bool set_value(dods_int32 *val, int sz);
    virtual bool set_value(vector<dods_int32> &val, int sz);
    virtual bool set_value(dods_uint32 *val, int sz);
    virtual bool set_value(vector<dods_uint32> &val, int sz);
    virtual bool set_value(dods_float32 *val, int sz);
    virtual bool set_value(vector<dods_float32> &val, int sz);
    virtual bool set_value(dods_float64 *val, int sz);
    virtual bool set_value(vector<dods_float64> &val, int sz);
    virtual bool set_value(string *val, int sz);
    virtual bool set_value(vector<string> &val, int sz);

    virtual void value(dods_byte *b) const;
    virtual void value(dods_int16 *b) const;
    virtual void value(dods_uint16 *b) const;
    virtual void value(dods_int32 *b) const;
    virtual void value(dods_uint32 *b) const;
    virtual void value(dods_float32 *b) const;
    virtual void value(dods_float64 *b) const;
    virtual void value(vector<string> &b) const;
    virtual void *value();

  private: // Private methods

    void copyLocalRepFrom(const RenamedArrayWrapper& proto);

    void destroy();

    void withNewName();

    void withOrgName();

    void syncConstraints() const { const_cast<RenamedArrayWrapper*>(this)->syncConstraints(); }
    void syncConstraints();

  private: // Data rep

    libdap::Array* _pArray;
    string _orgName; // the original, underlying name of the array, cached.
  };

}

#endif /* __NCML_MODULE__RENAMED_ARRAY_WRAPPER_H__ */