Shape.cc

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.

#include "Shape.h"
#include "NCMLDebug.h"
#include <sstream> // for std::stringstream

namespace ncml_module
{
  typedef vector<Array::dimension>::const_iterator DimItC;

  Shape::Shape()
  : _dims()
  {
  }

  Shape::Shape(const Array& copyDimsFrom)
  {
    Array& from = const_cast<Array&>(copyDimsFrom);
    Array::Dim_iter endIt = from.dim_end();
    Array::Dim_iter it;
    for (it = from.dim_begin(); it != endIt; ++it)
      {
        const Array::dimension& dim = (*it);
        _dims.push_back(dim);
      }
  }

  Shape::Shape(const Shape& proto)
  {
    _dims = proto._dims;
  }

  Shape::~Shape()
  {
    _dims.resize(0);
  }

  Shape&
  Shape::operator=(const Shape& rhs)
  {
    if (&rhs == this)
      {
        return *this;
      }

    _dims = rhs._dims;
    return *this;
  }

  bool
  Shape::operator==(const Shape& rhs) const
  {
    bool ret = true;

    // Simple dimensionality check must pass first
    if (rhs._dims.size() != _dims.size())
      {
        ret = false;
      }
    else // then compare all the dimensions
      {
        for (unsigned int i=0; i<_dims.size(); ++i)
          {
            ret = areDimensionsEqual(_dims[i], rhs._dims[i]);
            if (!ret) // just give up...
              {
                break;
              }
          }
      }
    return ret;
  }

  bool
  Shape::isConstrained() const
  {
    bool ret = false;
    for (unsigned int i=0; i<_dims.size(); ++i)
         {
           const Array::dimension& dim = _dims[i];
           ret |= (dim.c_size != dim.size);
           if (ret)
             {
               break;
             }
         }
       return ret;
  }

  void
  Shape::setToUnconstrained()
  {
    for (unsigned int i=0; i<_dims.size(); ++i)
      {
        Array::dimension& dim = _dims[i];
        dim.c_size = dim.size;
        dim.start = 0;
        dim.stop = dim.size-1;
        dim.stride = 1;
      }
  }


  bool
  Shape::areDimensionsEqual(const Array::dimension& lhs, const Array::dimension& rhs)
  {
    // Stolen from Array::dimension....
    /*
      int size;  ///< The unconstrained dimension size.
      string name;    ///< The name of this dimension.
      int start;  ///< The constraint start index
      int stop;  ///< The constraint end index
      int stride;  ///< The constraint stride
      int c_size;  ///< Size of dimension once constrained
     */
    // Must all match
    bool equal = true;
    equal &= (lhs.size == rhs.size);
    equal &= (lhs.name == rhs.name);
    equal &= (lhs.start == rhs.start);
    equal &= (lhs.stride == rhs.stride);
    equal &= (lhs.c_size == rhs.c_size);
    return equal;
  }

  unsigned int
  Shape::getRowMajorIndex(const IndexTuple& indices, bool validate /* = true */) const
  {
    if (validate && !validateIndices(indices))
      {
       THROW_NCML_INTERNAL_ERROR("Shape::getRowMajorIndex got indices that were out of range for the given space dimensions!");
      }

    NCML_ASSERT(indices.size() >= 1);
    unsigned int index = indices[0];
    for (unsigned int i=1; i<indices.size(); ++i)
      {
        index = indices[i] + (_dims[i].size * index);
      }
    return index;
  }

  Shape::IndexIterator
  Shape::beginSpaceEnumeration() const
  {
    return IndexIterator(*this, false);
  }

  Shape::IndexIterator
  Shape::endSpaceEnumeration() const
  {
    return IndexIterator(*this, true);
  }

  std::string
  Shape::toString() const
  {
    std::stringstream sos;
    print(sos);
    return sos.str();
  }

  void
  Shape::print(std::ostream& strm) const
  {
    strm << "Shape = { ";
    for (unsigned int i=0; i<_dims.size(); ++i)
      {
        const Array::dimension& dim = _dims[i];
        printDimension(strm, dim);
      }
    strm << " }\n";
  }

  void
  Shape::printDimension(std::ostream& strm, const Array::dimension& dim)
  {
    strm << "\tDim = { \n";
    strm << "\t\tname=" << dim.name << "\n";
    strm << "\t\tsize=" << dim.size << "\n";
    strm << "\t\tc_size=" << dim.c_size << "\n";
    strm << "\t\tstart=" << dim.start << "\n";
    strm << "\t\tstop=" << dim.stop << "\n";
    strm << "\t\tstride=" << dim.stride << "\n";
  }

  bool
  Shape::validateIndices(const IndexTuple& indices) const
  {
    if (indices.size() != _dims.size())
      {
        return false;
      }

    for (unsigned int i=0; i<_dims.size(); ++i)
      {
        // Must be > 0 and <= size-1
        if (indices[i] >= static_cast<unsigned int>(_dims[i].size))
          {
            return false;
          }
      }

    return true;
  }



  Shape::IndexIterator::IndexIterator()
  : _shape(0)
  , _current()
  , _end(true)
  {
  }

  Shape::IndexIterator::IndexIterator(const Shape& shape, bool isEnd/*=false*/)
  : _shape(&shape)
  , _current(shape.getNumDimensions()) // start with default of proper size, we'll fix it later.
  , _end(isEnd)
  {
    setCurrentToStart();
  }

  Shape::IndexIterator::IndexIterator(const Shape::IndexIterator& proto)
  : _shape(proto._shape)
  , _current(proto._current)
  , _end(proto._end)
  {
  }

  Shape::IndexIterator::~IndexIterator()
  {
    _shape = 0;
    _current.resize(0);
    _end = true;
  }

  Shape::IndexIterator&
  Shape::IndexIterator::operator=(const Shape::IndexIterator& rhs)
  {
    if (this == &rhs)
      {
        return *this;
      }

    _shape = rhs._shape;
    _current = rhs._current;
    _end = rhs._end;
    return *this;
  }

  bool
  Shape::IndexIterator::operator==(const Shape::IndexIterator& rhs) const
  {
    // The ptr's must be the same...  It has to come from the same Shape object.
    // We could use Shape::operator== but this is too slow for every increment.
    if (_shape != rhs._shape)
      {
        return false;
      }

    // If one has end set, the other needs to as well to be equal
    if (_end != rhs._end)
      {
        return false;
      }

    // Finally, make sure the arrays have the same values.
    return (_current == rhs._current);
  }

  void
  Shape::IndexIterator::advanceCurrent()
  {
    // We're done already, let the caller know they goofed.  This works for uninitialize with null _shape as well.
    if (_end)
      {
        THROW_NCML_INTERNAL_ERROR("Shape::IndexIterator::advanceCurrent(): tried to advance beyond end()!");
      }

    bool carry = true; // if a dimension's index wraps back to start on increment, this is set.  Starts true to initiate loop.
    unsigned int dimInd = _shape->getNumDimensions();
    while (carry && dimInd-- > 0) // first pass will decrement this so it starts at N-1m as we desire.
      {
        const Array::dimension& dim = _shape->_dims[dimInd];
        // grab the reference so we mutate the elt itself
        unsigned int& currentDimIndex = _current[dimInd];
        currentDimIndex += dim.stride;
        carry = false; // assume no carry to start
        // if we wrap, then set the carry bit to propagate the increment to the dimension to our left in the tuple
        if (currentDimIndex > static_cast<unsigned int>(dim.stop))
          {
            currentDimIndex = dim.start;
            carry = true;
          }
      }

    // If we end the loop with carry still set, we've wrapped the slowest varying dimension
    // and we're back to the starting group element.  Set _end!
    if (carry)
      {
        _end = true;
      }
  }

  void
  Shape::IndexIterator::setCurrentToStart()
  {
    VALID_PTR(_shape);
    for (unsigned int i=0; i<_shape->getNumDimensions(); ++i)
      {
        _current[i] = _shape->_dims[i].start;
      }
  }

} // namespace ncml_module