albaVector.h

Go to the documentation of this file.

/*=========================================================================
 
 Program: ALBA (Agile Library for Biomedical Applications)
 Module: albaVector
 Authors: Marco Petrone
 
 Copyright (c) BIC
 All rights reserved. See Copyright.txt or
 
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
 
#ifndef __albaVector_h
#define __albaVector_h
 
#include "albaDefines.h"
#include "albaBase.h"
#include "albaUtility.h"
#include <vector>
 
template <class T> class mmuVectorItems;
 
template <class T>
class albaVector : public albaBase
{
public:
  albaVector();
  virtual ~albaVector();
 
  albaID GetNumberOfItems();
 
  void SetItem(const albaID idx,const T &object);
 
  albaID AppendItem(const T &object);
 
  bool ReplaceItem(const albaID idx, const T &newitem);
 
  bool RemoveItem(const albaID idx);  
 
  bool FindAndRemoveItem(const T &object);
 
  void RemoveAllItems();
 
  bool IsItemPresent(const T &object);
 
  bool GetItem(const albaID idx,T &obj);
 
  T &GetItem(const albaID idx);
 
  bool FindItem(const T &object, albaID &idx);
 
  //int GetNumberOfItems();
 
  albaID Push(const T &obj);
 
  bool Pop(T &obj);
  
  T &operator [](const albaID idx);
  
  const T &operator [](const albaID idx) const;
 
  static T m_NullItem;
  
protected:
 
  mmuVectorItems<T> *m_Items;
  
private:
 
  albaVector(const albaVector&);  // Not implemented.
  void operator=(const albaVector&);  // Not implemented.
 
};
 
template <class T>
T albaVector<T>::m_NullItem;
 
//------------------------------------------------------------------------------
// PIMPL declarations
//------------------------------------------------------------------------------
template <class T>
class mmuVectorItems: public albaUtility 
{
  public:
  std::vector<T> Vector;
};
 
//------------------------------------------------------------------------------
template <class T>
albaVector<T>::albaVector()
//------------------------------------------------------------------------------
{
  m_Items  = new mmuVectorItems<T>;
}
 
//------------------------------------------------------------------------------
template <class T>
albaVector<T>::~albaVector()
//------------------------------------------------------------------------------
{
  RemoveAllItems();
  delete m_Items;
}
 
//------------------------------------------------------------------------------
template <class T>
void albaVector<T>::SetItem(albaID idx,const T &object)
//------------------------------------------------------------------------------
{
  if (m_Items->Vector.size()<=idx)
  {
   m_Items->Vector.resize(idx+1);
  }
 
  m_Items->Vector[idx]=object;
}
 
//------------------------------------------------------------------------------
template <class T>
albaID albaVector<T>::AppendItem(const T &object)
//------------------------------------------------------------------------------
{
  m_Items->Vector.push_back(object);
  return m_Items->Vector.size()-1;
}
 
//------------------------------------------------------------------------------
template <class T>
bool albaVector<T>::GetItem(albaID idx,T &obj)
//------------------------------------------------------------------------------
{
   if (idx>=0 && idx<m_Items->Vector.size())
   {
      obj=m_Items->Vector[idx];
      return true;
   }
   else
   {
      return false;
   }
}
 
//------------------------------------------------------------------------------
template <class T>
T &albaVector<T>::GetItem(const albaID idx)
//------------------------------------------------------------------------------
{
   if (idx>=0 && idx<m_Items->Vector.size())
   {
      return m_Items->Vector[idx];
   }
   else
   {
      return m_NullItem;
   }
}
 
//------------------------------------------------------------------------------
template <class T>
T &albaVector<T>::operator [](const albaID idx)
//------------------------------------------------------------------------------
{
  return (idx<m_Items->Vector.size())?m_Items->Vector[idx]:m_NullItem;
}
 
//------------------------------------------------------------------------------
template <class T>
const T &albaVector<T>::operator [](const albaID idx) const
//------------------------------------------------------------------------------
{
  return (idx<m_Items->Vector.size())?m_Items->Vector[idx]:m_NullItem;
}
 
//------------------------------------------------------------------------------
template <class T>
bool albaVector<T>::ReplaceItem(albaID idx, const T &newitem)
//------------------------------------------------------------------------------
{
  if (idx<m_Items->Vector.size())
  {
   m_Items->Vector[idx]=newitem;
 
    return true;
  }
 
  return false;
}
 
//------------------------------------------------------------------------------
template <class T>
bool albaVector<T>::RemoveItem(const albaID idx)
//------------------------------------------------------------------------------
{
  if (idx<m_Items->Vector.size())
  {
    m_Items->Vector.erase(m_Items->Vector.begin()+idx);
 
    return true;
  }
 
  return false;
}
 
//------------------------------------------------------------------------------
template <class T>
bool albaVector<T>::FindAndRemoveItem(const T &object)
//------------------------------------------------------------------------------
{
  albaID idx;
  if (FindItem(object,idx))
  {   
    return RemoveItem(idx);
  }
 
  return false;
}
 
//------------------------------------------------------------------------------ 
template <class T>
void albaVector<T>::RemoveAllItems()
//------------------------------------------------------------------------------
{
  m_Items->Vector.clear();
}
 
//------------------------------------------------------------------------------
template <class T>
bool albaVector<T>::FindItem(const T &object, albaID &idx)
//------------------------------------------------------------------------------
{
  for (albaID i=0;i<m_Items->Vector.size();i++)
    if (m_Items->Vector[i]==object)
   {
     idx=i;
      return true;
   }
 
  return false;
}
 
 
//------------------------------------------------------------------------------
template <class T>
bool albaVector<T>::IsItemPresent(const T &object)
//------------------------------------------------------------------------------
{
  albaID idx;
  return FindItem(object,idx);
}
 
//------------------------------------------------------------------------------
template <class T>
albaID albaVector<T>::Push(const T &object)
//------------------------------------------------------------------------------
{
  return AppendItem(object);
}
 
//------------------------------------------------------------------------------
template <class T>
bool albaVector<T>::Pop(T &obj)
//------------------------------------------------------------------------------
{
  if (GetItem(GetNumberOfItems()-1,obj))
  {
    RemoveItem(GetNumberOfItems()-1);
    return true;
  }
    
  return false;   
}
 
//------------------------------------------------------------------------------
template <class T>
albaID albaVector<T>::GetNumberOfItems()
//------------------------------------------------------------------------------
{
  return m_Items->Vector.size();
}
 
 
#endif