vector.hpp

"More for C++" is a class library that provides some features that are usually common for object ori

//
//  This file is part of the "More for C++" library
//
//  Copyright (c) 1999-2003 by Thorsten Goertz ([e-mail])
//
//  The "More for C++" library is free software; you can redistribute it and/or
//  modify it under the terms of the license that comes with this package.
//
//  Read "license.txt" for more details.
//
//  THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
//  WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES
//  OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
////////////////////////////////////////////////////////////////////////////////

#ifndef MORE_UTIL_VECTOR_HPP
#define MORE_UTIL_VECTOR_HPP

////////////////////////////////////////////////////////////////////////////////

#include <more/array.hpp>
#include <more/create.hpp>
#include <more/pointer.hpp>
#include <more/synchronized.hpp>
#include <more/core/finalizable.hpp>
#include <more/os/mutex.hpp>

////////////////////////////////////////////////////////////////////////////////

namespace more
{
  namespace util
  {
    template<typename Type>
    class Vector
    {
      public:
        Vector( );
        Vector( const Array<Type>& );
        void add( const Type& rElement );
        void remove( const Type& rElement );
        void clear( );
        bool isEmpty( ) const;
        size_t getSize( ) const;
        Array<Type> toArray( bool flush = false );

      protected:
        virtual ~Vector( );

      private:
        struct Node
        {
          Node( const Type& rType ) : m_element( rType ) { }
      //  Node( const Type& rType );
          virtual ~Node( ) { }
      //  virtual ~Node( );

          p<Node> m_pNext;
          Type    m_element;
        };

        p<more::os::Mutex>  m_pMutex;
        size_t              m_nNoOfNodes;
        p<Node>             m_pFirstNode;
        p<Node>             m_pLastNode;
    };
  }
}

////////////////////////////////////////////////////////////////////////////////

template<typename Type>
inline more::util::Vector<Type>::Vector( )
{
  m_pMutex = more::os::Mutex::create( );
  m_nNoOfNodes = 0;
}

////////////////////////////////////////////////////////////////////////////////

template<typename Type>
inline more::util::Vector<Type>::Vector( const Array<Type>& rArray )
{
  m_pMutex = more::os::Mutex::create( );
  m_nNoOfNodes = 0;

  for( size_t i = 0; i < rArray.getLength( ); i++ )
  {
    add( rArray[i] );
  }
}

////////////////////////////////////////////////////////////////////////////////

template<typename Type>
inline void more::util::Vector<Type>::add( const Type& rElement )
{
  synchronized( m_pMutex )
  {
    p<Node> pNode = CREATE Node( rElement );

    if( m_pFirstNode == 0 && m_pLastNode == 0 )
    {
      m_pFirstNode = m_pLastNode = pNode;
    }
    else
    {
      m_pLastNode -> m_pNext = pNode;
      m_pLastNode = pNode;
    }

    m_nNoOfNodes++;

  } end_synchronized
}

////////////////////////////////////////////////////////////////////////////////

template<typename Type>
inline void more::util::Vector<Type>::remove( const Type& rElement )
{
  synchronized( m_pMutex )
  {
    while( m_pFirstNode != 0 && m_pFirstNode -> m_element == rElement )
    {
      m_nNoOfNodes--;
      m_pFirstNode = m_pFirstNode -> m_pNext;
    }

    if( m_pFirstNode == 0 )
    {
      m_pLastNode = 0;
    }
    else
    {
      p<Node> pPrevNode( m_pFirstNode );
      p<Node> pNode( pPrevNode -> m_pNext );

      while( pNode != 0 )
      {
        if( pNode -> m_element == rElement )
        {
          m_nNoOfNodes--;
          pPrevNode -> m_pNext = pNode -> m_pNext;
        }
        else
        {
          pPrevNode = pNode;
        }

        pNode = pPrevNode -> m_pNext;
      }

      if( m_pLastNode != pPrevNode )
      {
        m_pLastNode = pPrevNode;
      }
    }

  } end_synchronized
}

////////////////////////////////////////////////////////////////////////////////

template<typename Type>
inline void more::util::Vector<Type>::clear( )
{
  synchronized( m_pMutex )
  {
    m_nNoOfNodes = 0;
    m_pFirstNode = 0;
    m_pLastNode = 0;

  } end_synchronized
}

////////////////////////////////////////////////////////////////////////////////

template<typename Type>
inline bool more::util::Vector<Type>::isEmpty( ) const
{
  return getSize( ) == 0;
}

////////////////////////////////////////////////////////////////////////////////

template<typename Type>
inline size_t more::util::Vector<Type>::getSize( ) const
{
  return m_nNoOfNodes;
}

////////////////////////////////////////////////////////////////////////////////

template<typename Type>
inline more::Array<Type> more::util::Vector<Type>::toArray
(
  bool bFlush
)
{
  Array<Type> result;

  synchronized( m_pMutex )
  {
    size_t   index = 0;
    p<Node>  pNode = m_pFirstNode;

    result = Array<Type>( getSize( ) );

    while( pNode != 0 )
    {
      result[index++] = pNode -> m_element;
      pNode = pNode -> m_pNext;
    }

    if( bFlush )
    {
      clear( );
    }

  } end_synchronized

  return result;
}

////////////////////////////////////////////////////////////////////////////////

template<typename Type>
inline more::util::Vector<Type>::~Vector( )
{
}

////////////////////////////////////////////////////////////////////////////////
/*
template<typename Type>
inline more::util::Vector<Type>::Node::Node
(
  const Type& rType
)
: m_element( rType )
{
}

////////////////////////////////////////////////////////////////////////////////

template<typename Type>
inline more::util::Vector<Type>::Node::~Node( )
{
}
*/
////////////////////////////////////////////////////////////////////////////////

#endif