NCMLArray.h

// 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__NCMLARRAY_H__
#define __NCML_MODULE__NCMLARRAY_H__
 
#include <libdap/dods-datatypes.h>
#include <libdap/Array.h>
#include <libdap/BaseType.h>
#include <libdap/Vector.h>
#include <memory>
// #include "MyBaseTypeFactory.h"
#include "NCMLBaseArray.h"
#include "NCMLDebug.h"
#include "Shape.h"
#include <sstream>
#include <string>
#include <typeinfo>
#include <vector>
 
using libdap::Array;
using libdap::dods_byte;
using libdap::dods_int16;
using libdap::dods_uint16;
using libdap::dods_int32;
using libdap::dods_uint32;
using libdap::dods_float32;
using libdap::dods_float64;
 
namespace ncml_module {
class Shape;

template<typename T>
class NCMLArray: public NCMLBaseArray {
public:
    // Class methods
 
public:
    // Instance methods
    NCMLArray() :
        NCMLBaseArray(""), _allValues(0)
    {
    }
 
    explicit NCMLArray(const string& name) :
        NCMLBaseArray(name), _allValues(0)
    {
    }
 
    explicit NCMLArray(const NCMLArray<T>& proto) :
        NCMLBaseArray(proto), _allValues(0)
    {
        copyLocalRepFrom(proto);
    }

    virtual ~NCMLArray()
    {
        destroy(); // helper
    }
 
    NCMLArray<T>&
    operator=(const NCMLArray<T>& rhs)
    {
        if (&rhs == this) {
            return *this;
        }
 
        // Call the super assignment
        NCMLBaseArray::operator=(rhs);
 
        // Copy local private rep
        copyLocalRepFrom(rhs);
 
        return *this;
    }

    virtual NCMLArray<T>* ptr_duplicate()
    {
        return new NCMLArray(*this);
    }

    virtual void copyDataFrom(libdap::Array& from)
    {
        // We both better have a valid template class.
        VALID_PTR(from.var());
 
        // clear out any current local values
        destroy();
 
        // OK, now that we have it, we need to copy the attribute table and the prototype variable
        set_attr_table(from.get_attr_table());
        // switched to add_var_ncopy() to avoid memory leak. jhrg 8/3/18
        add_var_nocopy(from.var()->ptr_duplicate()); // This may leak memory. Fixed.
 
        // add all the dimensions
        Array::Dim_iter endIt = from.dim_end();
        Array::Dim_iter it;
        for (it = from.dim_begin(); it != endIt; ++it) {
            Array::dimension& dim = *it;
            append_dim(dim.size, dim.name);
        }
 
        // Finally, copy the data.
        // Initialize with size() values so the storage and size of _allValues is correct.
        _allValues = new std::vector<T>(from.length());
        NCML_ASSERT(_allValues->size() == static_cast<unsigned int>(from.length()));
 
        // Copy the values in from._buf into our cache!
        T* pFirst = &((*_allValues)[0]);
        from.buf2val(reinterpret_cast<void**>(&pFirst));
    }
 
    virtual bool isDataCached() const
    {
        return _allValues;
    }

    // We have to override these to make a copy in this subclass as well since constraints added before read().
    // TODO Consider instead allowing add_constraint() in Array to be virtual so we can catch it and cache at that point rather than
    // all the time!!
 
    // Helper macros to avoid a bunch of cut & paste
 
#define NCMLARRAY_CHECK_ARRAY_TYPE_THEN_CALL_SUPER(arrayValue, sz)  \
  if (typeid(arrayValue) != typeid(T*)) \
  { \
    THROW_NCML_INTERNAL_ERROR("NCMLArray<T>::set_value(): got wrong type of value array, doesn't match type T!"); \
  } \
  bool ret = Vector::set_value((arrayValue), (sz)); \
  cacheSuperclassStateIfNeeded(); \
  return ret;
 
#define NCMLARRAY_CHECK_VECTOR_TYPE_THEN_CALL_SUPER(vecValue, sz) \
  if (typeid(vecValue) != typeid(vector<T>&)) \
  { \
    THROW_NCML_INTERNAL_ERROR("NCMLArray<T>::setValue(): got wrong type of value vector, doesn't match type T!"); \
  } \
  bool ret = Vector::set_value((vecValue), (sz)); \
  cacheSuperclassStateIfNeeded(); \
  return ret;
 
    virtual bool set_value(dods_byte *val, int sz)
    {
        NCMLARRAY_CHECK_ARRAY_TYPE_THEN_CALL_SUPER(val, sz);
    }
 
    virtual bool set_value(vector<dods_byte> &val, int sz)
    {
        NCMLARRAY_CHECK_VECTOR_TYPE_THEN_CALL_SUPER(val, sz);
    }
 
    virtual bool set_value(dods_int16 *val, int sz)
    {
        NCMLARRAY_CHECK_ARRAY_TYPE_THEN_CALL_SUPER(val, sz);
    }
 
    virtual bool set_value(vector<dods_int16> &val, int sz)
    {
        NCMLARRAY_CHECK_VECTOR_TYPE_THEN_CALL_SUPER(val, sz);
    }
 
    virtual bool set_value(dods_uint16 *val, int sz)
    {
        NCMLARRAY_CHECK_ARRAY_TYPE_THEN_CALL_SUPER(val, sz);
    }
 
    virtual bool set_value(vector<dods_uint16> &val, int sz)
    {
        NCMLARRAY_CHECK_VECTOR_TYPE_THEN_CALL_SUPER(val, sz);
    }
 
    virtual bool set_value(dods_int32 *val, int sz)
    {
        NCMLARRAY_CHECK_ARRAY_TYPE_THEN_CALL_SUPER(val, sz);
    }
 
    virtual bool set_value(vector<dods_int32> &val, int sz)
    {
        NCMLARRAY_CHECK_VECTOR_TYPE_THEN_CALL_SUPER(val, sz);
    }
 
    virtual bool set_value(dods_uint32 *val, int sz)
    {
        NCMLARRAY_CHECK_ARRAY_TYPE_THEN_CALL_SUPER(val, sz);
    }
 
    virtual bool set_value(vector<dods_uint32> &val, int sz)
    {
        NCMLARRAY_CHECK_VECTOR_TYPE_THEN_CALL_SUPER(val, sz);
    }
 
    virtual bool set_value(dods_float32 *val, int sz)
    {
        NCMLARRAY_CHECK_ARRAY_TYPE_THEN_CALL_SUPER(val, sz);
    }
 
    virtual bool set_value(vector<dods_float32> &val, int sz)
    {
        NCMLARRAY_CHECK_VECTOR_TYPE_THEN_CALL_SUPER(val, sz);
    }
 
    virtual bool set_value(dods_float64 *val, int sz)
    {
        NCMLARRAY_CHECK_ARRAY_TYPE_THEN_CALL_SUPER(val, sz);
    }
 
    virtual bool set_value(vector<dods_float64> &val, int sz)
    {
        NCMLARRAY_CHECK_VECTOR_TYPE_THEN_CALL_SUPER(val, sz);
    }
 
    virtual bool set_value(string *val, int sz)
    {
        NCMLARRAY_CHECK_ARRAY_TYPE_THEN_CALL_SUPER(val, sz);
    }
 
    virtual bool set_value(vector<string> &val, int sz)
    {
        NCMLARRAY_CHECK_VECTOR_TYPE_THEN_CALL_SUPER(val, sz);
    }
 
#undef NCMLARRAY_CHECK_ARRAY_TYPE_THEN_CALL_SUPER
#undef NCMLARRAY_CHECK_VECTOR_TYPE_THEN_CALL_SUPER
 
protected:

    virtual void cacheValuesIfNeeded()
    {
        // If the super Vector has no capacity, it's not set up correctly, so don't call this or we get exception.
        if (get_value_capacity() == 0) {
            BESDEBUG("ncml", "cacheValuesIfNeeded: the superclass Vector has no data so not copying...");
        }
 
        // If we haven't gotten this yet, go get it,
        // assuming the super Vector contains all values
        if (!_allValues) {
            BESDEBUG("ncml",
                "NCMLArray<T>:: we don't have unconstrained values cached, caching from Vector now..." << endl);
            unsigned int spaceSize = _noConstraints->getUnconstrainedSpaceSize();
 
#if 0
            ostringstream oss;
            oss <<"NCMLArray expected superclass Vector size() to be the same as unconstrained space size, but it wasn't!";
            oss << "size(): " << size() << "' spaceSize: " << spaceSize;
            NCML_ASSERT_MSG(static_cast<unsigned int>(length()) == spaceSize, oss.str());
#else
            NCML_ASSERT_MSG(static_cast<unsigned int>(length()) == spaceSize,
                "NCMLArray expected superclass Vector length() to be the same as unconstrained space size, but it wasn't!");
#endif
            // Make new default storage with enough space for all the data.
            _allValues = new vector<T>(spaceSize);
            NCML_ASSERT(_allValues->size() == spaceSize); // the values should all be default for T().
            // Grab the address of the start of the vector memory block.
            // This is safe since vector memory is required to be contiguous
            T* pFirstElt = &((*_allValues)[0]);
            // Now overwrite the defaults in from the buffer.
            unsigned int stored = buf2val(reinterpret_cast<void**>(&pFirstElt));
 
            NCML_ASSERT((stored / sizeof(T)) == spaceSize); // make sure it did what it was supposed to do.
            // OK, we have our copy now!
        }
 
        // We ignore the current constraints since we don't worry about them until later in read().
    }

    virtual void createAndSetConstrainedValueBuffer()
    {
        BESDEBUG("ncml", "NCMLArray<T>::createAndSetConstrainedValueBuffer() called!" << endl);
 
        // Whether to validate, depending on debug build or not.
#ifdef NDEBUG
        const bool validateBounds = false;
#else
        const bool validateBounds = true;
#endif
 
        // These need to exist or caller goofed.
        VALID_PTR(_noConstraints);
        VALID_PTR(_allValues);
 
        // This reflects the current constraints, so is what we want.
        unsigned int numVals = length();
        vector<T> values; // Exceptions may wind through and I want this storage cleaned, so vector<T> rather than T*.
        values.reserve(numVals);
 
        // Our current space, with constraints
        const Shape shape = getSuperShape();
        Shape::IndexIterator endIt = shape.endSpaceEnumeration();
        Shape::IndexIterator it;
        unsigned int count = 0;  // just a counter for number of points for sanity checking
        for (it = shape.beginSpaceEnumeration(); it != endIt; ++it, ++count) {
            // Take the current point in constrained space, look it up in cached 3values, set it as next elt in output
            values.push_back((*_allValues)[_noConstraints->getRowMajorIndex(*it, validateBounds)]);
        }
 
        // Sanity check the number of points we added.  They need to match or something is wrong.
        if (count != static_cast<unsigned int>(length())) {
            stringstream msg;
            msg << "While adding points to hyperslab buffer we got differing number of points "
                "from Shape space enumeration as expected from the constraints! "
                "Shape::IndexIterator produced " << count << " points but we expected " << length();
            THROW_NCML_INTERNAL_ERROR(msg.str());
        }
 
        if (count != shape.getConstrainedSpaceSize()) {
            stringstream msg;
            msg << "While adding points to hyperslab buffer we got differing number of points "
                "from Shape space enumeration as expected from the shape.getConstrainedSpaceSize()! "
                "Shape::IndexIterator produced " << count << " points but we expected "
                << shape.getConstrainedSpaceSize();
            THROW_NCML_INTERNAL_ERROR(msg.str());
        }
 
        // Otherwise, we're good, so blast the values into the valuebuffer.
        // tell it to reuse the current buffer since by definition is has enough room since it holds all points to start.
        val2buf(static_cast<void*>(&(values[0])), true);
    }
 
private:
    // This class ONLY methods

    void copyLocalRepFrom(const NCMLArray<T>& proto)
    {
        // Avoid unnecessary finagling
        if (&proto == this) {
            return;
        }
 
        // Blow away any old data before copying new
        destroy();
 
        // If there are values, make a copy of the vector.
        if (proto._allValues) {
            _allValues = new vector<T>(*(proto._allValues));
        }
    }

    void destroy() noexcept
    {
        delete _allValues;
        _allValues = 0;
    }
 
private:
 
    // The unconstrained data set, cached from super in first call to cacheSuperclassStateIfNeeded()
    // if it is null.
    std::vector<T>* _allValues;
 
};
// class NCMLArray<T>
 
}// namespace ncml_module
 
#endif /* __NCML_MODULE__NCMLARRAY_H__ */