Teuchos_SimpleObjectDB.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//                    Teuchos: Common Tools Package
//
// Copyright 2004 NTESS and the Teuchos contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @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;
 
  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
 
 
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!");
}
 
 
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