Array.h

Go to the documentation of this file.

// Copyright (C) 2002 Johan Hoffman and Anders Logg.
// Licensed under the GNU GPL Version 2.

#ifndef __ARRAY_H
#define __ARRAY_H

#include <signal.h>

#include <dolfin/dolfin_log.h>
#include <dolfin/General.h>

namespace dolfin {
  


  template <class T> class Array {
  public:
    
    class Iterator;
    friend class Iterator;
    
    Array();
    
    Array(int size);
    
    ~Array();
    
    void init(int new_size);
    
    void resize(int new_size);

    void clear();
    
    T& operator() (int i) const;

    void operator= (const T& element);
   
    int size() const;

    bool empty() const;
        
    bool contains(const T& element);
    
    T& max() const;

    void remove(const T& element);

    void swap(int i, int j);
         
    Iterator begin() const;


    void reset();
    
    void setsize(int new_size);
    
    void init();
   
    int add(T element);

    void resize();


    class Iterator {
    public:
      
      Iterator();
      
      Iterator(const Array<T>& array);

      Iterator(const Array<T>& array, Index index);

      Iterator& operator++();

      Iterator& operator--();

      bool end() const;
      
      bool last() const;

      bool operator==(const Iterator& it);
      
      void operator=(Iterator& it);

      void operator=(const Iterator& it);

      int index() const;
      
      T& operator*() const;
      
      T* operator->() const;
      
      operator T*() const;

      T* pointer() const;
      
    private:
      
      T *array;
      T *element;
      int _index;
      int size;
      bool at_end;
      
    };
    
  private:
    
    T *array;
    int _size;
    
  };

  //---------------------------------------------------------------------------
  // Implementation of Array
  //---------------------------------------------------------------------------
  template <class T> Array<T>::Array()
  {
    //dolfin_debug("Array ctor");

    array = 0;
    _size = 0;
  }
  //---------------------------------------------------------------------------    
  template <class T> Array<T>::Array(int size)
  {
    //dolfin_debug("Array size ctor");

    array = 0;
    _size = 0;
    init(size);
  }
  //---------------------------------------------------------------------------    
  template <class T> Array<T>::~Array()
  {
    clear();
  }
  //---------------------------------------------------------------------------
  template <class T> void Array<T>::init(int new_size)
  {
    if ( array )
      clear();
    
    if ( new_size <= 0 )
      return;
    
    array = new T[new_size];
    _size = new_size;
  }
  //---------------------------------------------------------------------------    
  template <class T> void Array<T>::resize(int new_size)
  {
    if ( !array ) {
      init(new_size);
      return;
    }
    
    // Create new array and copy the elements
    T *new_array = new T[new_size];
    for (int i = 0; i < _size && i < new_size; i++)
      new_array[i] = array[i];
    
    // Update the old array with the new array
    delete [] array;
    array = new_array;
    _size = new_size;
  }
  //---------------------------------------------------------------------------    
  template <class T> void Array<T>::clear()
  {
    if ( array )
      delete [] array;
    array = 0;
    _size = 0;
  }
  //---------------------------------------------------------------------------    
  template <class T> T& Array<T>::operator() (int i) const
  {
    dolfin_assert(i >= 0);
    dolfin_assert(i < _size);
    return array[i];
  }
  //---------------------------------------------------------------------------    
  template <class T> void Array<T>::operator= (const T& element)
  {
    for (int i = 0; i < _size; i++)
      array[i] = element;
  }
  //---------------------------------------------------------------------------    
  template <class T> int Array<T>::size() const
  {
    return _size;
  }
  //---------------------------------------------------------------------------    
  template <class T> bool Array<T>::empty() const
  {
    return _size == 0;
  }
  //---------------------------------------------------------------------------    
  template <class T> bool Array<T>::contains(const T& element)
  {
    for (int i = 0; i < _size; i++)
      if ( array[i] == element )
        return true;
    return false;
  }
  //---------------------------------------------------------------------------    
  template <class T> void Array<T>::remove(const T& element)
  {
    for (int i = 0; i < _size; i++)
      if ( array[i] == element ) {
        array[i] = 0;
        return;
      }
    dolfin_error("Element is not in the array.");
  }
  //---------------------------------------------------------------------------  
  template <class T> T& Array<T>::max() const
  {
    int pos = 0;
    for (int i = 1; i < _size; i++)
      if ( array[pos] < array[i] )
        pos = i;
    
    return array[pos];
  }
  //---------------------------------------------------------------------------
  template <class T> void Array<T>::swap(int i, int j)
  {
    T tmp = array[i];
    array[i] = array[j];
    array[j] = tmp;
  }
  //---------------------------------------------------------------------------  
  template <class T> typename Array<T>::Iterator Array<T>::begin() const
    {
    return Iterator(*this);
  }
  //---------------------------------------------------------------------------    
  template <class T> void Array<T>::setsize(int new_size)
  {
    _size = new_size;
  }
  //---------------------------------------------------------------------------    
  template <class T> void Array<T>::reset()
  {
    for (int i = 0; i < _size; i++)
      array[i] = 0;
  }
  //---------------------------------------------------------------------------    
  template <class T> void Array<T>::init()
  {
    init(_size);
    reset();
  }
  //---------------------------------------------------------------------------    
  template <class T> int Array<T>::add(T element)
  {
    for (int i = 0; i < _size; i++)
      if ( !array[i] ) {
        array[i] = element;
        return i;
      }

    dolfin_segfault();
    dolfin_error("Array is full.");
    return -1;
  }
  //--------------------------------------------------------------------------- 
  template <class T> void Array<T>::resize()
  {
    if ( !array )
      return;
    
    // Count the number of used positions
    int new_size = 0;
    for (int i = 0; i < _size; i++)
      if ( array[i] )
        new_size++;
    
    if ( new_size == 0 ){
      clear();
      return;
    }
    
    // Copy and reallocate
    T *new_array = new T[new_size];
    int pos = 0;
    for (int i = 0; i < _size; i++)
      if ( array[i] )
        new_array[pos++] = array[i];
    delete [] array;
    array = new_array;
    _size = new_size;
  }
  //---------------------------------------------------------------------------
  // Implementatio of Array::Iterator
  //---------------------------------------------------------------------------
  template <class T> Array<T>::Iterator::Iterator()
  {
    array = 0;
    element = 0;
    _index = 0;
    size = 0;
    at_end = true;
  }
  //---------------------------------------------------------------------------      
  template <class T> Array<T>::Iterator::Iterator(const Array<T> &array)
  {
    if ( array._size > 0 ){
      element = array.array;
      at_end = false;
    }
    else{
      element = 0;
      at_end = true;
    }
    
    _index = 0;
    size = array._size;
    this->array = array.array;
  }
  //---------------------------------------------------------------------------      
  template <class T> Array<T>::Iterator::Iterator
  (const Array<T> &array, Index index)
  {
    switch (index) {
    case dolfin::first:
      
      if ( array._size > 0 ){
        element = array.array;
        at_end = false;
      }
      else{
        element = 0;
        at_end = true;
      }
      
      _index = 0;
      size = array._size;
      this->array = array.array;
      
      break;

    case dolfin::last:
      
      if ( array._size > 0 ){
        element = array.array + array._size - 1;
        at_end = false;
      }
      else{
        element = 0;
        at_end = true;
      }
      
      _index = array._size - 1;
      size = array._size;
      this->array = array.array;

      break;
      
    default:
      
      dolfin_error("Unknown iterator position.");

    }      

  }
  //---------------------------------------------------------------------------      
  template <class T> typename Array<T>::Iterator::Iterator& 
  Array<T>::Iterator::operator++()
  {
    if ( _index == (size - 1) )
      at_end = true;
    else {
      at_end = false;
      _index++;
    }
    
    element = array + _index;
    
    return *this;
  }
  //---------------------------------------------------------------------------      
  template <class T> typename Array<T>::Iterator::Iterator& 
  Array<T>::Iterator::operator--()
  {
    if ( _index == 0 )
      at_end = true;
    else {
      at_end = false;
      _index--;
    }
    
    element = array + _index;
    
    return *this;
  }
  //---------------------------------------------------------------------------      
  template <class T> bool Array<T>::Iterator::end() const
  {
    return at_end;
  }
  //---------------------------------------------------------------------------      
  template <class T> bool Array<T>::Iterator::last() const
  {
    return _index == (size - 1);
  }
  //---------------------------------------------------------------------------
  template <class T> bool Array<T>::Iterator::operator==(const Iterator& it)
  {
    return element == it.element;
  }
  //---------------------------------------------------------------------------      
  template <class T> void Array<T>::Iterator::operator=(Iterator& it)
  {
    array   = it.array;
    element = it.element;
    _index  = it._index;
    size    = it.size;
    at_end  = it.at_end;
  }
  //---------------------------------------------------------------------------
  template <class T> void Array<T>::Iterator::operator=(const Iterator& it)
  {
    array   = it.array;
    element = it.element;
    _index  = it._index;
    size    = it.size;
    at_end  = it.at_end;
  }
  //---------------------------------------------------------------------------
  template <class T> int Array<T>::Iterator::index() const
  {
    return _index;
  }
  //---------------------------------------------------------------------------      
  template <class T> T& Array<T>::Iterator::operator*() const
  {
    return *element;
  }
  //---------------------------------------------------------------------------      
  template <class T> T* Array<T>::Iterator::operator->() const
  {
    return element;
  }
  //---------------------------------------------------------------------------      
  template <class T> Array<T>::Iterator::operator T*() const
  {
    return element;
  }
  //---------------------------------------------------------------------------      
  template <class T> T* Array<T>::Iterator::pointer() const
  {
    return element;
  }
  //---------------------------------------------------------------------------      
  
}

#endif

Documentation automatically generated with Doxygen on 10 Sep 2004.