itkPSMContainer.h

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef __itkPSMContainer_h
#define __itkPSMContainer_h

#include "itkDataObject.h"
#include "itkPoint.h"
#include "itkWeakPointer.h"
#include "itkCommand.h"
#include "itkPSMAttribute.h"
#include <map>

namespace itk
{
template <class T>
class ITK_EXPORT PSMContainer : public DataObject
{
public:
  typedef T DataType;
  typedef PSMContainer Self;
  typedef DataObject Superclass;
  typedef SmartPointer<Self>  Pointer;
  typedef SmartPointer<const Self>  ConstPointer;
  typedef WeakPointer<const Self>  ConstWeakPointer;

  itkNewMacro(Self);

  itkTypeMacro(PSMContainer, DataObject);
  
  struct ltcmp
  {
    inline bool operator()(unsigned int a, unsigned int b) const
    { return a < b; }
  };

  typedef std::map<unsigned int, T, ltcmp> MapType;  
  
  class ConstIterator : public MapType::const_iterator
  {
  public:
    typedef typename MapType::const_iterator Superclass;
    ConstIterator( const typename MapType::const_iterator &o) : Superclass(o) {}
    ConstIterator() : Superclass() {}
    
    inline const T &operator*() const
    { return Superclass::operator*().second;  } 
    inline unsigned long int GetIndex() const
    { return Superclass::operator*().first; }
  }; 

  class Iterator : public MapType::iterator
  {
  public:
    typedef typename MapType::iterator Superclass;
    Iterator( const typename MapType::iterator &o) : Superclass(o) {}
    Iterator() : Superclass() {}
    
    inline T &operator*() const
    { return Superclass::operator*().second;  }
    
    inline unsigned long int GetIndex() const
    { return Superclass::operator*().first; } 
  }; 
  
  inline ConstIterator GetBegin() const
  { return ConstIterator( m_Map.begin()); }
  inline ConstIterator GetEnd() const
  { return ConstIterator( m_Map.end()); }

  inline typename MapType::const_iterator GetMapBegin() const
  { return m_Map.begin(); }
  inline typename MapType::const_iterator GetMapEnd() const
  { return m_Map.end(); }
  inline typename MapType::iterator GetMapBegin() 
  { return m_Map.begin(); }
  inline typename MapType::iterator GetMapEnd()
  { return m_Map.end(); }

  inline T &operator[](const unsigned long int &k)  { return m_Map[k]; }
  inline const T&operator[](const unsigned long int &k) const { return m_Map[k]; }

  bool HasIndex(unsigned long int k) const
  {
    if ( m_Map.find(k) != m_Map.end()) return true;
    else return false;
  }

  unsigned long int GetSize() const  { return m_Map.size(); }

  typename MapType::size_type Erase( const unsigned int &k )
  { return m_Map.erase(k); }
  
protected:
  PSMContainer() { }
  void PrintSelf(std::ostream& os, Indent indent) const
  {
    Superclass::PrintSelf(os,indent);
  
    os << indent << "PSMContainer: " << std::endl;
    //    for (typename MapType::const_iterator it= this->GetMapBegin();
    //         it != this->GetMapEnd();  it++)
    //      {      os <<  it->first << " " << it->second << std::endl;      }
  }
  virtual ~PSMContainer() {};

 private:
  PSMContainer(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

  MapType m_Map;
};

} // end namespace itk

#endif