NCMLArray.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__NCMLARRAY_H__
#define __NCML_MODULE__NCMLARRAY_H__

#include <dods-datatypes.h>
#include <Array.h>
#include <BaseType.h>
#include <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;

using std::string;
using std::vector;

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());
    add_var(from.var()->ptr_duplicate()); // TODO This may leak memory

    // 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 length() 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();
        // These must match or we're not getting all the data and the caller messed up.
        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!");
        // 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() throw ()
   {
     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__ */