Teuchos_SimpleObjectDB.hpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
//
//                    Teuchos: Common Tools Package
//                 Copyright (2004) Sandia Corporation
//
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
//
// ***********************************************************************
// @HEADER

#ifndef TEUCHOS_SIMPLE_OBJECT_DB_HPP
#define TEUCHOS_SIMPLE_OBJECT_DB_HPP


#include "Teuchos_Array.hpp"
#include "Teuchos_ConstNonconstObjectContainer.hpp"
#include "Teuchos_as.hpp"


namespace Teuchos
{


template <class T>
class SimpleObjectDB
{
public:
  
  SimpleObjectDB();

  int tableSize() const;

  int numFreeIndexes() const;

  int numObjects() const;

  int storeNonconstObj(const RCP<T> &obj);

  int storeConstObj(const RCP<const T> &obj);
  
  template <class TOld>
  int storeCastedNonconstObj(const RCP<TOld> & robj_old);

  void removeObj(const int index);

  RCP<T> removeNonconstObj(const int index);

  RCP<const T> removeConstObj(const int index);
  
  int removeRCP(int &index);
  
  RCP<T> getNonconstObjRCP(const int index);
  
  RCP<const T> getConstObjRCP(const int index) const;
  
  Ptr<T> getNonconstObjPtr(const int index);
  
  Ptr<const T> getConstObjPtr(const int index) const;
  
  void purge();
  
private:

  typedef Array<ConstNonconstObjectContainer<T> > tableOfObjects_t;
  typedef Array<int> freedIndices_t;
  
  tableOfObjects_t tableOfObjects_;
  freedIndices_t freedIndices_;

  void validateIndex(const int index) const
#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
    ;
#else
    {}
#endif

  template <class T2>
  int storeObjectImpl(const RCP<T2> &robj);
  
  void removeObjImpl(const int index);

};


template <class T>
RCP<SimpleObjectDB<T> > createSimpleObjectDB()
{
  return rcp(new SimpleObjectDB<T>);
}


//
// Template definitions
//


template <class T>
SimpleObjectDB<T>::SimpleObjectDB()
{}


template <class T>
int SimpleObjectDB<T>::tableSize() const
{
  return tableOfObjects_.size();
}


template <class T>
int SimpleObjectDB<T>::numFreeIndexes() const
{
  return freedIndices_.size();
}


template <class T>
int SimpleObjectDB<T>::numObjects() const
{
  return tableSize() - numFreeIndexes();
}


template <class T>
int SimpleObjectDB<T>::storeNonconstObj(const RCP<T> &obj)
{
  return storeObjectImpl(obj);
}


template <class T>
int SimpleObjectDB<T>::storeConstObj(const RCP<const T> &obj)
{
  return storeObjectImpl(obj);
}


template <class T>
template <class TOld>
int SimpleObjectDB<T>::storeCastedNonconstObj(const RCP<TOld> & robj_old)
{
  return storeNonconstObj(rcp_dynamic_cast<T>(robj_old, true));
}


template <class T>
void SimpleObjectDB<T>::removeObj(const int index)
{
  validateIndex(index);
  removeObjImpl(index);
}


template <class T>
RCP<T> SimpleObjectDB<T>::removeNonconstObj(const int index)
{
  validateIndex(index);
  const RCP<T> obj = tableOfObjects_[index].getNonconstObj();
  removeObjImpl(index);
  return obj;
}


template <class T>
RCP<const T> SimpleObjectDB<T>::removeConstObj(const int index)
{
  validateIndex(index);
  const RCP<const T> obj = tableOfObjects_[index].getConstObj();
  removeObjImpl(index);
  return obj;
}


template <class T>
int SimpleObjectDB<T>::removeRCP(int &index)
{
  const int index_in = index;
  validateIndex(index);
  const int cnt = tableOfObjects_[index_in].count();
  removeObjImpl(index_in);
  index = -1;
  return (cnt - 1);
}


template <class T>
RCP<T> SimpleObjectDB<T>::getNonconstObjRCP(const int index)
{
  validateIndex(index);
  return tableOfObjects_[index].getNonconstObj();
}


template <class T>
RCP<const T> SimpleObjectDB<T>::getConstObjRCP(const int index) const
{
  validateIndex(index);
  return tableOfObjects_[index].getConstObj();
}


template <class T>
Ptr<T> SimpleObjectDB<T>::getNonconstObjPtr(const int index)
{
  validateIndex(index);
  return tableOfObjects_[index].getNonconstObj().ptr();
}


template <class T>
Ptr<const T> SimpleObjectDB<T>::getConstObjPtr(const int index) const
{
  validateIndex(index);
  return tableOfObjects_[index].getConstObj().ptr();
}


template <class T>
void SimpleObjectDB<T>::purge()
{
  // Wipe out all memory (see Item 82 in "C++ Coding Standards")
  tableOfObjects_t().swap(tableOfObjects_);
  freedIndices_t().swap(freedIndices_);
}


// private


#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
template <class T>
void SimpleObjectDB<T>::validateIndex(const int index) const
{
  using Teuchos::as;
  TEUCHOS_TEST_FOR_EXCEPTION(
    !(0 <= index && index < as<int>(tableOfObjects_.size())),
    RangeError,
    "Error, the object index = " << index << " falls outside of the range"
    << " of valid objects [0,"<<tableOfObjects_.size()<<"]");
  const RCP<const T> &obj = tableOfObjects_[index].getConstObj();
  TEUCHOS_TEST_FOR_EXCEPTION(is_null(obj), NullReferenceError,
    "Error, the object at index "<<index<<" of type "
    <<TypeNameTraits<T>::name()<<" has already been deleted!");
}
#endif // HAVE_TEUCHOS_ARRAY_BOUNDSCHECK


template <class T>
template <class T2>
int SimpleObjectDB<T>::storeObjectImpl(const RCP<T2> & robj)
{
  robj.assert_not_null();

  int index = -1;

  if (freedIndices_.size() != 0) {
    index = freedIndices_.back();
    freedIndices_.pop_back();
    tableOfObjects_[index].initialize(robj);
  } else {
    tableOfObjects_.push_back(robj);
    index = tableOfObjects_.size() - 1;
  }

  return index;
}


template <class T>
void SimpleObjectDB<T>::removeObjImpl(const int index)
{
  tableOfObjects_[index] = null;
  freedIndices_.push_back(index);
}


} // end namespace Teuchos


#endif // TEUCHOS_SIMPLE_OBJECT_DB_HPP