source: orxonox.OLD/orxonox/trunk/src/lib/graphics/importer/array.h @ 4787

/*
   orxonox - the future of 3D-vertical-scrollers

   Copyright (C) 2004 orx

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

### File Specific:
   main-programmer: Benjamin Grauer
   co-programmer: ...
*/

/*!
  \file array.h
  \brief Contains the Array Class that handles float arrays.
  this class creates a Array of a semi-Dynamic length.
  beware, that after finalizing the array may not be resized again.
*/

#ifndef _ARRAY_H
#define _ARRAY_H
#include "debug.h"

//! Array Class that handles dynamic-float arrays.
template<class T> class Array
{
  public:
    Array ();
    ~Array();

    void finalizeArray ();
    void addEntry (T entry);
    void addEntry(T entry0, T entry1, T entry2);

    /** \returns The array */
    inline const T* getArray () const { return this->array; };
    /**   \returns The Count of entries in the Array*/
    inline unsigned int getCount()const { return this->entryCount; };
    void debug() const ;

  private:
    //! One entry of the Array
    struct Entry
    {
      T            value;          //!< The value of this Entry.
      Entry*       next;           //!< Pointer to the Next entry.
    };

    T*            array;           //!< The array that will be produced when finalizing the Array.
    unsigned int  entryCount;      //!< The count of Entries in this Array.
    bool          finalized;       //!< If this variable is set to true, the Array can not be changed anymore. true if finalized, false else (initially).
    Entry*        firstEntry;      //!< Pointer to the first Entry of this Array
    Entry*        currentEntry;    //!< Pointer to the current Entry of this Array. The one Entry we are working with.
};


/**
   \brief creates a new Array
*/
template<class T>
Array<T>::Array ()
{
  PRINTF(4)("crating new Array\n");
  this->firstEntry = new Entry;
  this->firstEntry->next =NULL;
  this->currentEntry = this->firstEntry;
  this->finalized = false;
  this->entryCount = 0; //0 means one entry
}

/**
   \brief deletes an Array.
   It does this by first deleting all the array-entries, and then delete the array[] itself
*/
template<class T>
Array<T>::~Array()
{
  PRINTF(4)("deleting array\n");
  Entry* walker = this->firstEntry;
  Entry* previous;
  while (walker)
  {
    previous = walker;
    walker = walker->next;
    delete previous;
  }
  if (finalized)
    delete []this->array;
}

/**
   \brief finalizes an array.
   This Function creates the array, and makes it ready to be sent to the application.
*/
template<class T>
void Array<T>::finalizeArray ()
{
  PRINTF(4)("Finalizing array. Length: %i\n", entryCount);
  //  if ((array = (GLfloat*)malloc( entryCount* sizeof(GLfloat))) == NULL)
  if (!(this->array = new GLfloat [this->entryCount]))
    PRINTF(1)("could not allocate %i data Blocks\n", this->entryCount);
  Entry* walker = this->firstEntry;
  for (int i=0; i<this->entryCount; i++)
  {
    this->array[i] = walker->value;
    walker = walker->next;
  }
  walker = this->firstEntry;
  Entry* previous;
  while (walker)
  {
    previous = walker;
    walker = walker->next;
    delete previous;
  }
  this->firstEntry = NULL;
  this->finalized = true;
}

/**
   \brief adds a new Entry to the Array
   \param entry Entry to add.
*/
template<class T>
void Array<T>::addEntry (T entry)
{
  if (!this->finalized)
  {
    PRINTF(5)("adding new Entry to Array: %f\n", entry);

    this->currentEntry->value = entry;
    this->currentEntry->next = new Entry;
    this->currentEntry = currentEntry->next;
    this->currentEntry->next = NULL;
    ++this->entryCount;
  }
  else
    PRINTF(2)("adding failed, because array has already been finalized\n");
}

/**
   \brief Adds 3 entries at once (convenience)
*/
template<class T>
void Array<T>::addEntry (T entry0, T entry1, T entry2)
{
  this->addEntry(entry0);
  this->addEntry(entry1);
  this->addEntry(entry2);
}

/**
   \brief Simple debug info about the Array
*/
template<class T>
void Array<T>::debug () const
{
  PRINT(0)("entryCount=%i, address=%p\n", this->entryCount, this->array);
}
#endif