ikp1dlayers.hpp

/* ikp1dlayer.hpp */
/* $Id: ikp1dlayers.hpp,v 1.3 2008/04/25 11:16:52 urij Exp $ */
#ifndef __ikp1dlayers_hpp
#define __ikp1dlayers_hpp

#include <vector>
#include <string>

#include <mix/u_message.hpp>

using namespace std;

template <class T>
class IKP1dLayers
{
public:
  
  IKP1dLayers (string name = "IKP1dLayers") {
    m_name = name; 
  }
  
  IKP1dLayers (const IKP1dLayers& obj);
  
  virtual ~IKP1dLayers ();
  
  int laysNum () const {
    return lays.size();
  }
  
  T* layer (int n) const;
  
  virtual void push (T& lay) {
    lays.push_back(new T(lay));
  }
  
  bool erase (int n);
  
  void insert (int n, T& lay);
  
  void clear();
  
  void info () const; 
  
  const string& getName() const {
    return m_name;
  }
    
protected:
  
  std::vector <T*> lays;

  string m_name;
};

//------------------------------------------------------------------------------------------
// Implementation
template <typename T> IKP1dLayers<T>::IKP1dLayers (const IKP1dLayers& obj)
{
  //copy all layers 
  for (int i=0; i<obj.laysNum(); i++)
    push(*obj.layer(i));
  
  m_name = obj.getName();
}


template <typename T> IKP1dLayers<T>::~IKP1dLayers ()
{
  // remove all layers
  clear();
}

template <typename T> void IKP1dLayers<T>::clear ()
{
  for (int i=0; i<laysNum(); i++)
    delete lays[i];
#if 0
  UMessage::info ("%s->clear.", m_name.c_str());
#endif
  lays.clear();
}

template <typename T> T* IKP1dLayers<T>::layer (int n) const
{
  if (n < 0 || n >= laysNum())
    {
      UMessage::error ("%s->layer: Index out of range 0<%d<%d",
               m_name.c_str(), n, laysNum());
      return NULL;
    }
  else
    return lays[n];
}


template <typename T> bool IKP1dLayers<T>::erase (int n)
{
  if (n < 0 || n >= laysNum())
    {
      UMessage::error ("%s->erase: Index out of range 0<%d<%d",
              m_name.c_str(), n, laysNum());
      return false;
    }
  else
    {
      lays.erase(lays.begin()+n);
      return true;
    }
}


template <typename T> void IKP1dLayers<T>::insert (int n, T& lay)
{
  if (n < 0)
    {
      UMessage::warning ("%s->insert: Index out of range 0<%d<=%d",
               m_name.c_str(), n, laysNum());
      n = 0;
    }
  if (n > laysNum())
    {
      UMessage::warning ("%s->insert: Index out of range 0<%d<=%d",
             m_name.c_str(), n, laysNum());
      n = laysNum();
    }
  lays.insert(lays.begin() + n, new T(lay));
}


template <typename T> void IKP1dLayers<T>::info () const
{
  for (int i=0; i<laysNum(); i++)
    {
      UMessage::info ("%s->info: Layer %d/%d",
              m_name.c_str(), i+1, laysNum());
      lays[i]->info();    
    }
}
//------------------------------------------------------------------------------------------


#endif /* ikp1dlayers.hpp */