arrays.h

Go to the documentation of this file.

//
// Copyright (c) 2000-2004 California Institute of Technology
// Copyright (c) 2004-2007 University of Southern California
// Rob Peters <rjpeters at usc dot edu>
//
// created: Mon Mar  6 15:56:36 2000
// commit: $Id: arrays.h 10065 2007-04-12 05:54:56Z rjpeters $
// $HeadURL: file:///lab/rjpeters/svnrepo/code/trunk/groovx/src/rutz/arrays.h $
//
// --------------------------------------------------------------------
//
// This file is part of GroovX.
//   [http://ilab.usc.edu/rjpeters/groovx/]
//
// GroovX 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 of the License, or
// (at your option) any later version.
//
// GroovX is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with GroovX; if not, write to the Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
//

#ifndef GROOVX_RUTZ_ARRAYS_H_UTC20050626084020_DEFINED
#define GROOVX_RUTZ_ARRAYS_H_UTC20050626084020_DEFINED

#include "rutz/algo.h"
#include "rutz/atomic.h"

#include <cstddef>

namespace rutz
{

  class out_of_range {};

  template<class T, std::size_t N>
  T* array_begin(T (&array)[N])
  {
    return &array[0];
  }

  template<class T, std::size_t N>
  T* array_end(T (&array)[N])
  {
    return &array[0]+N;
  }

  template<class T, std::size_t N>
  const T* array_begin(T const (&array)[N])
  {
    return &array[0];
  }

  template<class T, std::size_t N>
  const T* array_end(T const (&array)[N])
  {
    return &array[0]+N;
  }


  //  #######################################################
  //  =======================================================


  template <class T, size_t N>
  struct static_block
  {
    typedef T value_type;                     

    typedef T* pointer;                       
    typedef const T* const_pointer;           
    typedef T& reference ;                    
    typedef const T& const_reference;         

    typedef pointer iterator;                 
    typedef const_pointer const_iterator;     

    typedef size_t size_type;                 
    typedef ptrdiff_t difference_type;        

    iterator begin() { return data; }         
    iterator end() { return data+N; }         

    const_iterator begin() const { return data; } 
    const_iterator end() const { return data+N; } 

    reference operator[](size_type n) { return data[n]; }

    const_reference operator[](size_type n) const { return data[n]; }

    reference at(size_type n)
    {
      if ( n >= N )
        throw rutz::out_of_range();
      return data[n];
    }

    const_reference at(size_type n) const
    {
      if ( n >= N )
        throw rutz::out_of_range();
      return data[n];
    }

    size_type size() const { return N; }

    size_type max_size() const { return size_type(-1) / sizeof(T); }

    bool is_empty() const { return (N == 0); }


    void swap(static_block& other)
    {
      rutz::swap2(*this, other);
    }

    T data[N];
  };


  //  #######################################################
  //  =======================================================


  template <class T>
  class fixed_block
  {
  private:
    fixed_block(const fixed_block<T>& other);

    fixed_block<T>& operator=(const fixed_block<T>& other);

    template <class Itr>
    void assign(Itr thatitr, Itr thatend)
    {
      iterator thisitr = begin(), thisend = end();

      while (thatitr != thatend && thisitr != thisend)
        {
          *thisitr = *thatitr;
          ++thisitr;
          ++thatitr;
        }
    }

  public:
    typedef T value_type;                     

    typedef T* pointer;                       
    typedef const T* const_pointer;           
    typedef T& reference ;                    
    typedef const T& const_reference;         

    typedef pointer iterator;                 
    typedef const_pointer const_iterator;     

    typedef size_t size_type;                 
    typedef ptrdiff_t difference_type;        

    fixed_block(size_type n) : N(n), data(new T[N]) {}

    ~fixed_block() { delete [] data; }

    template <class Itr>
    fixed_block(Itr itr, Itr end) : N(end-itr), data(new T[N])
    {
      assign(itr, end);
    }

    iterator begin() { return data; }         
    iterator end() { return data+N; }         

    const_iterator begin() const { return data; } 
    const_iterator end() const { return data+N; } 

    reference operator[](size_type n) { return data[n]; }

    const_reference operator[](size_type n) const { return data[n]; }

    reference at(size_type n)
    {
      if ( n >= N )
        throw rutz::out_of_range();
      return data[n];
    }

    const_reference at(size_type n) const
    {
      if ( n >= N )
        throw rutz::out_of_range();
      return data[n];
    }

    size_type size() const { return N; }

    size_type max_size() const { return size_type(-1) / sizeof(T); }

    bool is_empty() const { return (N == 0); }


    void swap(fixed_block& other)
    {
      rutz::swap2(N,    other.N);
      rutz::swap2(data, other.data);
    }

  private:
    size_type N;
    T* data;
  };


  //  #######################################################
  //  =======================================================


  template<typename T>
  class shared_array
  {
  public:
    typedef T element_type;


    explicit shared_array(T* p =0) : px(p)
    {
      try { pn = new rutz::atomic_int_t; pn->atomic_set(1); }
      catch (...) { delete [] p; throw; }  // don't leak p if new throws
    }

    shared_array(const shared_array& r) throw() : px(r.px), pn(r.pn)
    { pn->atomic_incr(); }

    ~shared_array()
    {
      if (pn->atomic_decr_test_zero())
        {
          delete [] px; px = 0;
          delete pn;    pn = 0;
        }
    }

    shared_array& operator=(const shared_array& r)
    {
      if (pn != r.pn) // Q: why not px != r.px? A: fails when both px == 0
        shared_array(r).swap(*this);
      return *this;
    }

    void reset(T* p=0)
    {
      if (px != p) // self-assignment safe
        shared_array(p).swap(*this);
    }

    T* get() const                     throw() { return px; }

    T& operator[](std::size_t i) const throw() { return px[i]; }

    long use_count() const             throw() { return pn->atomic_get(); }

    bool unique() const                throw() { return use_count() == 1; }

    void swap(shared_array<T>& other) throw()
    { rutz::swap2(px,other.px); rutz::swap2(pn,other.pn); }

  private:
    T*                   px;     // contained pointer
    rutz::atomic_int_t*  pn;     // ptr to reference counter
  };  // shared_array

  template<typename T>
  inline bool operator==(const shared_array<T>& a, const shared_array<T>& b)
  { return a.get() == b.get(); }

  template<typename T>
  inline bool operator!=(const shared_array<T>& a, const shared_array<T>& b)
  { return a.get() != b.get(); }



  //  #######################################################
  //  =======================================================


  template <class T>
  class dynamic_block
  {
  public:
    typedef T value_type;                     

    typedef T* pointer;                       
    typedef const T* const_pointer;           
    typedef T& reference ;                    
    typedef const T& const_reference;         

    typedef pointer iterator;                 
    typedef const_pointer const_iterator;     

    typedef size_t size_type;                 
    typedef ptrdiff_t difference_type;        

    dynamic_block(size_type n = 0) : N(n), data(new T[N]) {}

    dynamic_block(const dynamic_block<T>& other) :
      N(other.N), data(new T[N])
    {
      assign_varsize(other, *this);
    }

    dynamic_block<T>& operator=(const dynamic_block<T>& other)
    {
      dynamic_block temp(other);
      this->swap(temp);
      return *this;
    }

    ~dynamic_block() { delete [] data; }

    iterator begin() { return data; }         
    iterator end() { return data+N; }         

    const_iterator begin() const { return data; } 
    const_iterator end() const { return data+N; } 

    reference operator[](size_type n) { return data[n]; }

    const_reference operator[](size_type n) const { return data[n]; }

    reference at(size_type n)
    {
      if ( n >= N )
        throw rutz::out_of_range();
      return data[n];
    }

    const_reference at(size_type n) const
    {
      if ( n >= N )
        throw rutz::out_of_range();
      return data[n];
    }

    size_type size() const { return N; }

    size_type max_size() const { return size_type(-1) / sizeof(T); }

    bool is_empty() const { return (N == 0); }


    void swap(dynamic_block& other)
    {
      rutz::swap2(N,    other.N);
      rutz::swap2(data, other.data);
    }

    void resize(size_type new_size)
    {
      dynamic_block temp(new_size);
      assign_varsize(*this, temp);
      this->swap(temp);
    }

    template <class RandomAccessIterator>
    void assign(RandomAccessIterator start, RandomAccessIterator finish)
    {
      int num = finish-start;
      if (num < 0)
        {
          resize(0);
          return;
        }
      resize(num);
      iterator ii = begin();
      while (start != finish)
        {
          *ii = *start;
          ++ii;
          ++start;
        }
    }

  private:
    static void assign_varsize(const dynamic_block& b_from,
                               dynamic_block& b_to)
    {
      const_iterator from = b_from.begin();
      iterator to = b_to.begin();

      while(from != b_from.end() && to != b_to.end())
        {
          *to++ = *from++;
        }
    }

    size_type N;
    T* data;
  };
}

static const char __attribute__((used)) vcid_groovx_rutz_arrays_h_utc20050626084020[] = "$Id: arrays.h 10065 2007-04-12 05:54:56Z rjpeters $ $HeadURL: file:
#endif // !GROOVX_RUTZ_ARRAYS_H_UTC20050626084020_DEFINED

---

The software described here is Copyright (c) 1998-2005, Rob Peters.
This page was generated Wed Dec 3 06:49:40 2008 by Doxygen version 1.5.5.