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 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