RCArray.h

Go to the documentation of this file.

#ifndef RCARRAY_H
#define RCARRAY_H

#include "GrowableArray.h"
#include "RCObject.h"
#include "RCPtr.h"
#include "RCBase.h"

template <class T>
class RCArray : public RCBase<T>
{

protected:
  class SharedData : public RCObject
  {
  public:
    GrowableArray<T> data;

    SharedData() {};
    SharedData(const GrowableArray<T> &v ) { copy( v ); }
    SharedData( size_t initialSize ) : data( initialSize ) {}
    SharedData(const SharedData& rhs) { copy( rhs.data ); }
    ~SharedData() {}
    size_t getRefCnt() { return refCnt(); }

  private:
    void copy(const GrowableArray<T> &v )
    {
      size_t len = v.length();
      for (size_t i = 0; i < len; i++) {
        data.append( v[i] );
      }
    } // copy
  }; // class SharedData

  RCPtr<SharedData> value;

  void init(T intialVal );

  RCArray(size_t initialSize);
  RCArray(size_t initialSize, T initVal );

  T read(const int i) const;
  void write(const int i, const T v);

  size_t length() const;
  size_t getRefCnt();

public:
  RCArray();

  ValRef operator[](const int ix) throw(std::out_of_range);
  T operator[](const int ix) const;

  ValRef operator[](const size_t ix) throw(std::out_of_range);
  T operator[](const size_t ix) const;

  void append(T val);
}; // RCArray


template <class T>
inline
void RCArray<T>::init( T initialVal )
{
  size_t len = value->data.length();
  for (size_t i = 0; i < len; i++) {
    value->data[i] = initialVal;
  }
}

template <class T>
inline
RCArray<T>::RCArray() : value( new SharedData() ) {}


template <class T>
inline
RCArray<T>::RCArray( size_t initialSize ) : 
  value( new SharedData(initialSize) ) {}


template <class T>
inline
RCArray<T>::RCArray( size_t initialSize, T initialVal ) :
  value( new SharedData(initialSize) )
{
  init( initialVal );
}


template <class T>
inline
void RCArray<T>::append( T val )
{
  value->data.append( val );
}

template <class T>
inline
size_t RCArray<T>::length() const
{
  return value->data.length();
}


template <class T>
inline
size_t RCArray<T>::getRefCnt()
{
  return value->getRefCnt();
}



template <class T>
inline
T RCArray<T>::operator[](const int ix) const
{
  return value->data[ix];
}



template <class T>
inline
RCArray<T>::ValRef RCArray<T>::operator[](const int ix)
  throw(std::out_of_range)
{
  if (ix < 0 || ix >= value->data.length()) {
    const char *errMsg = "operator[] - index out of bounds";
    throw std::out_of_range( errMsg );
  }
  return ValRef( *this, ix );
}


template <class T>
inline
T RCArray<T>::operator[](const size_t ix) const
{
  return value->data[ix];
}

template <class T>
inline
RCArray<T>::ValRef RCArray<T>::operator[](const size_t ix)
  throw(std::out_of_range)
{
  if (ix >= value->data.length()) {
    const char *errMsg = "operator[] - index out of bounds";
    throw std::out_of_range( errMsg );
  }
  return ValRef( *this, ix );
}


template <class T>
inline
T RCArray<T>::read(const int i) const 
{ 
  return value->data[i]; 
}


template <class T>
inline
void RCArray<T>::write(const int i, const T v) 
{ 
  if (value->isShared()) {
    value = new SharedData( value->data );
  }
  value->data[i] = v; 
}

#endif

---