diff --git a/include/array.cpp b/include/array.cpp
index 7d5c78153..c91590a84 100755
--- a/include/array.cpp
+++ b/include/array.cpp
@@ -4,6 +4,116 @@
 #include <array.h>
 #include <strings.h>
 
+void TContainer::for_each( OPERATION_FUNCTION op )
+{
+  TObject* curr = first_item( );
+  while( curr )
+  {
+    op( *curr );
+    curr = succ_item( );
+  } 
+}
+
+void TContainer::for_each_that( OPERATION_FUNCTION op, CONDITION_FUNCTION match )
+{
+  TObject* curr =  first_that( match );
+  while( curr )
+  {
+    op( *curr );
+    curr = succ_that( );
+  } 
+}
+
+TObject* TContainer::first_that( CONDITION_FUNCTION match )
+{
+  _last_condition = match;
+  if( _last_condition )
+  {
+    TObject* curr = first_item( );
+    while( curr && !_last_condition( *curr ) )
+      curr = succ_item( );
+    return curr;      
+  }
+  else
+    return first_item( );  
+}
+
+TObject* TContainer::last_that( CONDITION_FUNCTION match )
+{
+  _last_condition = match;
+  if( _last_condition )
+  {
+    TObject* curr = last_item( );
+    while( curr && !_last_condition( *curr ) )
+      curr = pred_item( );
+    return curr;      
+  }
+  else
+    return last_item( );  
+}
+
+TObject* TContainer::succ_that( )
+{
+  if( _last_condition )
+  {
+    TObject* curr = succ_item( );
+    while( curr && !_last_condition( *curr ) )
+      curr = succ_item( );
+    return curr;      
+  }
+  else
+    return succ_item( );
+}
+
+TObject* TContainer::pred_that( )
+{
+  if( _last_condition )
+  {
+    TObject* curr = pred_item( );
+    while( curr && !_last_condition( *curr ) )
+      curr = pred_item( );
+    return curr;      
+  }
+  else
+    return pred_item( );
+}
+
+long TContainer::count( CONDITION_FUNCTION match )
+{
+  long c = 0;
+  TObject* curr = first_item( );
+  while( curr )
+    if( match( *curr ) )
+      c++;
+  return c;    
+}
+
+TObject* TArray::first_item( )
+{
+  _scanindex = first( ); 
+  return ( _scanindex == size( ) )?NULL:_data[ _scanindex ]; 
+};
+
+TObject* TArray::last_item( )
+{ 
+  _scanindex = last( ); 
+  return ( _scanindex == -1 )?NULL:_data[ _scanindex ]; 
+};
+
+TObject* TArray::succ_item( )
+{ 
+  _scanindex = succ( _scanindex ); 
+  return ( _scanindex == size( ))?NULL:_data[ _scanindex ]; 
+};
+
+TObject* TArray::pred_item( )
+{ 
+  _scanindex = pred( _scanindex ); 
+  return ( _scanindex == -1)?NULL:_data[ _scanindex ]; 
+};
+
+
+
 // @doc INTERNAL
 
 // @mfunc Modifica la dimensione dell'array.
@@ -97,8 +207,8 @@ TArray& TArray::operator= (const TArray& a)
     const TObject* o = a.objptr(i);
     if (o != NULL) _data[i] = o->dup();
   }  
-  _items = a.items();
-  _next = a._next;  
+  _items = ( int )a.items();
+  _next = ( int )a._next;  
   
   return *this;
 }              
diff --git a/include/array.h b/include/array.h
index 95990c755..f600ea92c 100755
--- a/include/array.h
+++ b/include/array.h
@@ -15,10 +15,70 @@
 //      clsse <c TObject> da passare al metodo sort dei <c TArray>
 typedef (*COMPARE_FUNCTION)(const TObject**, const TObject**);
 
+// @doc EXTERNAL
+//
+// @type CONDITION_FUNCTION | Prototipo funzione di ricerca/filtro
+//      per i derivati di <c TObject> da passare ai metodi dei <c TContainer>
+
+typedef bool (*CONDITION_FUNCTION) ( const TObject& );
+
+// @doc EXTERNAL
+//
+// @type OPERATION_FUNCTION | Prototipo funzione attuatore 
+//      da passare ai metodi sort dei <c TContainer>
+
+typedef void (*OPERATION_FUNCTION) ( const TObject& );
+
+
+// @class TContainer | Generico contenitore ad accesso casuale( con indice )
+// @base public | TObject
+
+class TContainer : public TObject
+{
+  
+  // @access Private Member
+private:
+  
+  CONDITION_FUNCTION _last_condition;    
+  
+  // @access Public Member
+public:
+  
+  // @cmember Ritorna l'indice del primo oggetto
+  virtual TObject* first_item( ) pure;
+  // @cmember Ritorna l'indice dell'ultimo oggetto
+  virtual TObject* last_item( ) pure;
+  // @cmember Ritorna l'indice del primo oggetto dopo i
+  virtual TObject* succ_item( ) pure;
+  // @cmember Ritorna l'indice del primo oggetto che precede i
+  virtual TObject* pred_item( ) pure;
+  // @cmember Ritorna numero di oggetti nel container
+  virtual long objects( ) pure;
+  
+  virtual void for_each( OPERATION_FUNCTION );    
+  virtual void for_each_that( OPERATION_FUNCTION, CONDITION_FUNCTION = NULL );
+  
+  // @cmember Ritorna il puntatore al primo oggetto che soddisfa la condizione
+  virtual TObject* first_that( CONDITION_FUNCTION = NULL );
+  // @cmember Ritorna il puntatore all'ultimo oggetto che soddisfa la condizione
+  virtual TObject* last_that( CONDITION_FUNCTION = NULL );
+  // @cmember Ritorna il prossimo oggetto che soddisfa la condizione. Va usata con first_that per scandire il container
+  virtual TObject* succ_that( );
+  // @cmember Ritorna il precedente oggetto che soddisfa la condizione. Va usata con last_that per scandire il container all'indietro
+  virtual TObject* pred_that( );
+  // @cmember Ritorna il numero di elementi che soddisfano la condizione
+  virtual long count( CONDITION_FUNCTION = NULL );
+  TObject* operator++ (){ return succ_item( ); };
+  TObject* operator-- (){ return pred_item( ); };
+  
+};
+
+
+
 // @class TArray | Classe per la definizione degli array
 //
 // @base public | TObject
-class TArray : public TObject
+class TArray : public TContainer
 {
 
   // @access Private Member
@@ -32,6 +92,9 @@ class TArray : public TObject
   // @cmember Prossimo elemento libero nell'array
   int _next;
   
+  // @cmember Indice per la scansione sequenziale
+  int _scanindex;
+  
   // @access Protected Member
 protected:
 
@@ -62,9 +125,21 @@ public:
   int size() const
   { return _size; }
   // @cmember Ritorna numero di oggetti nell'array
-  int items() const
+  virtual long objects( )
   { return _items; }
   
+  virtual int items( ) const
+  { return _items; }
+  
+  
+  virtual TObject* first_item( );
+  
+  virtual TObject* last_item( );
+  
+  virtual TObject* succ_item( );
+  
+  virtual TObject* pred_item( );
+  
   // @cmember Ritorna l'indice del primo oggetto
   int first() const;
   // @cmember Ritorna l'indice dell'ultimo oggetto