array.h

Go to the documentation of this file.

/* Copyright (C) 2000-2013 CEA
 *
 * This software and supporting documentation were developed by
 *     bioPICSEL
 *     CEA/DSV/I²BM/MIRCen/LMN, Batiment 61,
 *     18, route du Panorama
 *     92265 Fontenay-aux-Roses
 *     France
 */
 
#ifndef BIOPROCESSING_OBJECT_ARRAY_H
#define BIOPROCESSING_OBJECT_ARRAY_H
 
#include <string>
#include <vector>
#include <cartobase/object/object.h>
 
namespace carto
{
 
  template <typename T>
  class Array: public virtual Interface,
               public DynArrayInterface,
               public std::vector<T>
  {
  private :
    typedef typename std::vector<T>::const_iterator ArrayIterator;
 
  public :
    Array() : std::vector<T>() {}
 
    virtual ~Array() {
//       std::cout << "In array destructor" << std::endl << std::flush;
//       typename std::vector<T>::const_iterator it, et = std::vector<T>::end();
//       for(it = std::vector<T>::begin(); it < et; it++)
//       {
//         //cout << "*it : " << *it << endl << flush;
//         std::cout << "it : " << typeid(*it).name() << std::endl << std::flush;
//       }
    }
    
    class interfaced_iterator;
 
    inline interfaced_iterator getIterator() const 
    {
      return interfaced_iterator( std::vector<T>::begin(), std::vector<T>::end() );
    }

    virtual Object objectIterator() const 
    {
      return Object::value( getIterator() );
    }
 
    virtual size_t size() const { return std::vector<T>::size(); }
  
    virtual bool isContiguous() const { return true; }
    virtual bool hasItem( int index ) const
    { return index >= 0 && index < size(); }
    virtual Object getArrayItem( int index ) const { return Object::value(std::vector<T>::at( index )); }
    virtual void setArrayItem( int index, Object o ) { std::vector<T>::at( index ) = o->GenericObject::value<T>(); }

    virtual void reserveArray( size_t s ) { std::vector<T>::reserve(s); }
    virtual void resizeArray( size_t s ) { std::vector<T>::resize(s); }
    virtual void removeArrayItem( int i ) { std::vector<T>::erase( std::vector<T>::begin() + i ); }
    virtual void insertArrayItem( int i, Object o ) { std::vector<T>::insert( std::vector<T>::begin() + i, o->GenericObject::value<T>() ); }
 
    class interfaced_iterator : public IteratorInterface
    {
 
    public:
      inline interfaced_iterator()
      {
      }
      
      
      //-----------------------------------------------------------------------------
      inline interfaced_iterator(  const ArrayIterator &begin,
                                   const ArrayIterator &end ) :
      _iterator( begin ), _end( end ) 
      {
      }
  
      virtual bool isValid() const 
      {
        return _iterator != _end; 
      }
  
      virtual Object currentValue() const
      {
        return Object::value(*_iterator);
      }
  
  
      virtual void next()
      {
        ++_iterator;
      }
 
  
    private:
  
      friend interfaced_iterator Array::getIterator() const;
 
      ArrayIterator _iterator; 
      ArrayIterator _end;
    };
 
  };
 
}
 
#endif