StdMatrix.h

Go to the documentation of this file.

/***************************************************************************
 *
 * Copyright (C) 2009-2010 Cassio Neri Moreira
 *
 * This file is part of the KeyValue library.
 *
 * The KeyValue library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or (at
 * your option) any later version.
 *
 * The KeyValue 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 General
 * Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with KeyValue. If not, see <http://www.gnu.org/licenses/>.
 *
 * If you modify this library, or any covered work, by linking or combining
 * it with Excel (or a modified version of that program), containing parts
 * covered by the terms of End-User License Agreement for Microsoft
 * Software, the licensors of KeyValue grant you additional permission to
 * convey the resulting work.
 *
 **************************************************************************/

#ifndef KEYVALUE_KEY_CONVERTER_STDMATRIX_H_
#define KEYVALUE_KEY_CONVERTER_STDMATRIX_H_

#include "keyvalue/extern/SharedPtr.h"
#include "keyvalue/extern/Vector.h"
#include "keyvalue/sys/exception/KV_ASSERT.h"
#include "keyvalue/value/Variant.h"
#include "keyvalue/value/Matrix.h"

namespace keyvalue {
namespace key {

template <typename ElementType>
class StdMatrix {

public:

  typedef value::Matrix InputType_;

  typedef shared_ptr<std::vector<std::vector<ElementType> > > OutputType_;

  StdMatrix(const InputType_& input, OutputType_* cache);

  bool
  isEmpty() const;

  value::Variant
  pop();

  void
  insert(const ElementType& element);

  OutputType_
  getOutput() const;

  bool
  mustUpdate() const;

private:

  const InputType_& input_;
  OutputType_       output_;
  OutputType_*      cache_;
  size_t            nRows_;
  size_t            nCols_;
  size_t            i_;
  size_t            j_;
  bool              mustUpdate_;

};

/*--------------------------------------------------------------------------
 * StdMatrix()
 *------------------------------------------------------------------------*/

template <typename ElementType>
StdMatrix<ElementType>::StdMatrix(const InputType_& input,
  OutputType_* const cache) :
  input_(input),
  output_(new std::vector<std::vector<ElementType> >),
  cache_(cache),
  nRows_(input.getNRows()),
  nCols_(input.getNCols()),
  i_(0),
  j_(0),
  mustUpdate_(!cache) {

  KV_ASSERT(nRows_ != 0 && nCols_ != 0, "Empty matrix given to StdMatrix!");

  output_->reserve(nRows_);
  output_->push_back(std::vector<ElementType>());
  output_->back().reserve(nCols_);

  mustUpdate_ = mustUpdate_ || (*cache_)->size() != nRows_ ||
    (*(*cache_))[0].size() != nCols_;
}

/*--------------------------------------------------------------------------
 * isEmpty()
 *------------------------------------------------------------------------*/

template <typename ElementType>
bool
StdMatrix<ElementType>::isEmpty() const {
  return (j_ == nCols_ && i_ == nRows_ - 1);
}

/*--------------------------------------------------------------------------
 * pop()
 *------------------------------------------------------------------------*/

template <typename ElementType>
value::Variant
StdMatrix<ElementType>::pop() {

  KV_ASSERT(!isEmpty(), "All elements have been processed!");

  if (j_ == nCols_) {
    j_ = 0;
    ++i_;
  }

  return input_(i_, j_++);
}

/*--------------------------------------------------------------------------
 * insert()
 *------------------------------------------------------------------------*/

template <typename ElementType>
void
StdMatrix<ElementType>::insert(const ElementType& element) {

  if (output_->back().size() == nCols_) {
    output_->push_back(std::vector<ElementType>());
    output_->back().reserve(nCols_);
  }

  output_->back().push_back(element);

  KV_ASSERT(i_ < nRows_, "Calls to StdMatrix.pop() and StdMatrix.insert() "
    "must be intercalated!");

  mustUpdate_ = mustUpdate_ ||
    (*(*cache_))[j_ == 0 ? i_-1 : i_][j_ == 0 ? nCols_-1 : j_-1] != element;
}

/*--------------------------------------------------------------------------
 * getOutput()
 *------------------------------------------------------------------------*/

template <typename ElementType>
typename StdMatrix<ElementType>::OutputType_
StdMatrix<ElementType>::getOutput() const {
  return output_;
}

/*--------------------------------------------------------------------------
 * mustUpdate()
 *------------------------------------------------------------------------*/

template <typename ElementType>
bool
StdMatrix<ElementType>::mustUpdate() const {
  return mustUpdate_;
}

} // namespace key
} // namespace keyvalue

#endif // KEYVALUE_KEY_CONVERTER_STDMATRIX_H_