ScratchVect.h

//===========================================================================
// GoTools - SINTEF Geometry Tools version 1.1
//
// GoTools module: CORE
//
// Copyright (C) 2000-2007 SINTEF ICT, Applied Mathematics, Norway.
//
// 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 version 2 of the License. 
//
// This program 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 this program; if not, write to the Free Software            
// Foundation, Inc.,                                                      
// 59 Temple Place - Suite 330,                                           
// Boston, MA  02111-1307, USA.                                           
//
// Contact information: E-mail: tor.dokken@sintef.no                      
// SINTEF ICT, Department of Applied Mathematics,                         
// P.O. Box 124 Blindern,                                                 
// 0314 Oslo, Norway.                                                     
//
// Other licenses are also available for this software, notably licenses
// for:
// - Building commercial software.                                        
// - Building software whose source code you wish to keep private.        
//===========================================================================
#ifndef _GOSCRATCHVECT_H
#define _GOSCRATCHVECT_H


#include <vector>
//#include "Utils.h"


namespace Go {


template <typename T, size_t N>
class ScratchVect {

private:
    T scratch_[N];
    std::vector<T> stl_vect_;
    T* begin_;
    T* end_;

public:
    typedef T* iterator;
    typedef const T*  const_iterator;

    ScratchVect() :
      stl_vect_(0),
      begin_(scratch_),
      end_(scratch_) {}

    ScratchVect(size_t size) :
      stl_vect_((size>N)?size:0) {
      if (size>N) {
        begin_ = &stl_vect_[0];
        end_ = (&stl_vect_[0])+size; 
      } else {
        begin_=scratch_;
        end_=(&scratch_[size]);
      }
    }

    ScratchVect(size_t size, T elem) :
      stl_vect_((size>N)?size:0) {
      if (size>N) {
        begin_ = &stl_vect_[0];
        end_ = (&stl_vect_[0])+size; 
      } else {
        begin_=scratch_;
        end_=(&scratch_[size]);
      }
      std::fill(begin_, end_, elem);
    }



    ScratchVect(const std::vector<T>& vec) {
        assign(vec.begin(), vec.end());
    }

    template<typename RAIter>
    ScratchVect(RAIter beg, RAIter end) {
        assign(beg, end);
    }

    template <int M>
    ScratchVect(const ScratchVect<T,M> &orig) {
        assign(orig.begin(), orig.end());
    }

    ScratchVect& operator = (const ScratchVect &orig) {
        assign(orig.begin(), orig.end());
        return *this;
    }

    void resize(size_t new_size) {
        const int cur_size = size();
        if (new_size == cur_size) {
            return;
        }
        if (new_size < cur_size) {
            if (cur_size < N) {
                end_ -= (cur_size - new_size);          
            } else if (new_size >N) {
                // both cur_size and new_size > N
                end_ -= (cur_size - new_size);          
            } else {
                // cur_size > N but new_size < N
                begin_ = scratch_;
                end_ = begin_ + new_size;
                stl_vect_.clear(); // release memory
            }
        }
        // new_size > size
        if (new_size < N) {
            end_ = begin_ + new_size;
        } else {
            stl_vect_.resize(new_size);
            begin_ = &stl_vect_[0];
            end_ = begin_ + new_size;
        }
    }

    template<typename RAIter>
    void assign(RAIter beg, RAIter end) {
        size_t sz = end - beg;
        stl_vect_.clear();
        if (sz>N) {
            stl_vect_.insert(stl_vect_.end(), beg, end);
            begin_ = &stl_vect_[0];
            end_ = (&stl_vect_[0])+sz; 
        } else {
            begin_=scratch_;
            end_=(&scratch_[sz]);
            std::copy(beg, end, begin_);
        }
    }
     
    inline iterator begin() { return begin_;}

    inline const_iterator begin() const { return begin_;}

    inline iterator end() { return end_;}

    inline const_iterator end() const { return end_;}

    inline size_t size() const {return (end_-begin_);}

    inline const T& operator [] (int i) const { return begin_[i]; }
    inline T& operator [] (int i)       { return begin_[i]; }
    
    void push_back(const T &e)
    {
      size_t n=size();
      if (n<N)
        *(end_++)=e;
      else if (n>N)
      {
        stl_vect_.push_back(e);
        begin_=&stl_vect_[0];
        end_=&stl_vect_[0]+stl_vect_.size();
      }
      else
      {
        stl_vect_.reserve(2*n);
        stl_vect_.insert(stl_vect_.end(), begin_, end_);
        stl_vect_.insert(stl_vect_.end(), e);
        begin_=&stl_vect_[0];
        end_=&stl_vect_[0]+stl_vect_.size();
      }
    }
    
    void clear()
    {
      if (begin_==scratch_)
        end_=scratch_;
      else
      {
        stl_vect_.clear();
        begin_=end_=scratch_;
      }
    }

};
}
#endif

---