dds_seq.hh

Go to the documentation of this file.

/*****************************************************************
 *
 *   file:   dds_seq.hh
 *   desc:   CoreDX DDS API for sequences
 *
 *****************************************************************
 *
 *   Copyright(C) 2006-2016 Twin Oaks Computing, Inc
 *   All rights reserved.   Castle Rock, CO 80108
 *
 *****************************************************************
 *
 *  This software has been provided pursuant to a License Agreement
 *  containing restrictions on its use.  This software contains
 *  valuable trade secrets and proprietary information of
 *  Twin Oaks Computing, Inc and is protected by law.  It may not be
 *  copied or distributed in any form or medium, disclosed to third
 *  parties, reverse engineered or used in any manner not provided
 *  for in said License Agreement except with the prior written
 *  authorization from Twin Oaks Computing, Inc.
 *
 *****************************************************************/

#ifndef _DDS_SEQ_HH
#define _DDS_SEQ_HH

#  include <dds/toc_util.h>

namespace DDS
{
  template <class T> class sequence {
  public:
    sequence();
    sequence( const sequence &x);
    ~sequence();
    sequence& operator= (const sequence& x) {
      this->resize(x.core_seq._length);
      for (unsigned int i = 0; i < this->core_seq._length; i++)
        this->core_seq._buffer[i] = x.core_seq._buffer[i]; // will do deep copy if implemented on T
      return *this;
    };

    // capacity
    uint32_t size() const;
    uint32_t length() const;
    uint32_t capacity() const;  // get current capactity
    bool reserve(uint32_t n);   // set capacity
    bool resize(uint32_t n);    // set capacity and size
    void maximum(uint32_t n); // set maximum
    uint32_t maximum() const; // get current maximum
    
    bool empty() const;         // test if empty
    void shrink_to_fit();       // reduce capacity to fit size

    void assign(T* buffer, uint32_t n);    // provide array of elements of size 'n', takes ownership of the memory
 
    T*   release(); // release sequence contents to caller (if successful, sequence is empty after this)

    // element access
    T&         operator[] (uint32_t n);
    const T&   operator[] (uint32_t n) const;
    T&         at (uint32_t n);
    const T&   at (uint32_t n) const;
    T&         front ();
    const T&   front () const;
    T&         back ();
    const T&   back () const;

    const T*   buffer() const;
    
    // modifiers
    void push_back(const T& v);
    void pop_back();
    void swap(sequence& x);
    void clear();
    
  private:
    
    typedef struct CoreSeqType
    {                                                   
      T            * _buffer;                           
      unsigned int   _maximum;                          
      unsigned int   _length;
      unsigned int   _size;
      unsigned char  _own;                              
      unsigned int   _item_size;
    } CoreSeqType_t;
    
    CoreSeqType_t core_seq;
  };

  template<class T>
  sequence<T>::sequence() {
    INIT_SEQ(this->core_seq);
    this->core_seq._item_size = sizeof(T);
  }

  // copy constructor
  template<class T>
  sequence<T>::sequence(const sequence&x) {
    INIT_SEQ(this->core_seq);
    this->core_seq._item_size = sizeof(T);
    (*this) = x;
  }

  template<class T>
  sequence<T>::~sequence() {
    clear();
  }

  // capacity
  template<class T>
  uint32_t
  sequence<T>::capacity() const {
    return this->core_seq._size;
  }

  template<class T>
  uint32_t sequence<T>::size() const {
    return this->core_seq._length;
  }

  template<class T>
  uint32_t sequence<T>::length() const {
    return this->core_seq._length;
  }

  template<class T>
  void sequence<T>::maximum(uint32_t n)
  {
    this->core_seq._maximum = n;
  }

  template<class T>
  uint32_t sequence<T>::maximum() const {
    return this->core_seq._maximum;
  }

  template<class T>
  bool 
  sequence<T>::empty() const {
    return (this->core_seq._length == 0)?true:false;
  }

  // reserve(n)
  //   allocate memory to hold up to 's' items (capacity) 
  //   will truncate if 'n' is smaller than current capacity
  template<class T>
  bool
  sequence<T>::reserve(uint32_t n)  {
    bool             retval = true;
    T *              tmpbuf  = (T*)0;
    if (n > 0)
      {
        T * newbuf = new T[n]; 
        if (newbuf)
          {
            this->core_seq._size = n;
            if (this->core_seq._length > n)
              this->core_seq._length = n; // truncated

            if (this->core_seq._buffer)
              for (uint32_t i = 0;i < this->core_seq._length; i++)
                newbuf[i] = this->core_seq._buffer[i];
            tmpbuf        = this->core_seq._buffer;
            this->core_seq._buffer = newbuf;
          }
        else
          retval = false; // failed to alloc
      }
    else
      {
        this->core_seq._size   = 0;
        this->core_seq._length = 0;
        tmpbuf = this->core_seq._buffer;
        this->core_seq._buffer = 0;
      }
    if ( tmpbuf )
      delete[] tmpbuf;
    return retval;
  }

  template<class T>
  bool sequence<T>::resize(uint32_t n) {
    bool retval;
    retval = reserve(n);
    if (this->core_seq._size == n)
      this->core_seq._length = n;
    return retval;
  }
  
  template<class T>
  void 
  sequence<T>::shrink_to_fit() {
    resize(this->core_seq._length);
  }

  // element access
  template<class T>
  T&         
  sequence<T>::operator[] (uint32_t n) {
    return this->core_seq._buffer[n];
  }

  template<class T>
  const T&   
  sequence<T>::operator[] (uint32_t n) const {
    return this->core_seq._buffer[n];
  }

  template<class T>       T&   sequence<T>::at (uint32_t n)       { return (*this)[n]; }
  template<class T> const T&   sequence<T>::at (uint32_t n) const { return (*this)[n]; }
  template<class T>       T&   sequence<T>::front ()       { return (*this)[0]; }
  template<class T> const T&   sequence<T>::front () const { return (*this)[0]; }

  template<class T>       T&   sequence<T>::back ()       { return (*this)[this->core_seq._length-1]; }
  template<class T> const T&   sequence<T>::back () const { return (*this)[this->core_seq._length-1]; }
  template<class T> const T*   sequence<T>::buffer () const { return this->core_seq._buffer; }
    
  // modifiers
  template<class T>  void      sequence<T>::push_back(const T& v) {     
    if (this->capacity() <= this->size())
      reserve(this->size() + 2);

    if (this->size() < this->capacity())
      {
        this->core_seq._buffer[this->size()] = v;
        this->core_seq._length ++;
      }
  }

  template<class T>  void      sequence<T>::pop_back()            {
    if (this->core_seq._length > 0) this->core_seq._length--; 
  }

  template<class T>  void      sequence<T>::swap(sequence& x)     { 
    CoreSeqType tmp; 
    tmp = this->core_seq; 
    this->core_seq = x.core_seq; 
    x.core_seq = tmp;
  }

  template<class T>  void      sequence<T>::clear()               { 
    delete[] this->core_seq._buffer;
    this->core_seq._buffer = 0;
    this->core_seq._length = 0;
    this->core_seq._size  = 0;
  }

  template<class T>  
  void sequence<T>::assign(T* buffer, uint32_t n) {
    delete[] this->core_seq._buffer;
    this->core_seq._buffer = buffer;
    this->core_seq._length = n;
    this->core_seq._size   = n;
  }

  template<class T>  
  T* sequence<T>::release() {
    T* retval = this->core_seq._buffer;
    this->core_seq._buffer = NULL;
    this->core_seq._length = 0;
    this->core_seq._size   = 0;
    return retval;
  }

#  define CPP_DECLARE_UNBOUNDED_SEQ( type, name )       typedef DDS::sequence<type> name
#  define DECLARE_CPP_UNBOUNDED_SEQ( type, name )       typedef DDS::sequence<type> name

} // namespace DDS
#endif