STK_IArrayBase.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004  Serge Iovleff

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as
    published by the Free Software Foundation; either version 2 of the
    License, or (at your option) any later version.

    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 Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser 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 : Serge.Iovleff@stkpp.org
*/

/*
 * Project:  stkpp::Arrays
 * Purpose:  Define the Base Interface for the Array classes.
 * Author:   Serge Iovleff, serge.iovleff@stkpp.org
 *
 **/

#ifndef STK_IARRAYBASE_H
#define STK_IARRAYBASE_H

#include <stdexcept>

#include "../../Sdk/include/STK_IContainerRef.h"
#include "../../STKernel/include/STK_Range.h"

namespace STK
{

template<class DATA>
class IArrayBase : public IContainerRef
{
  protected:
    IArrayBase( Range const& I = Range()) : IContainerRef(false)
                                          , p_data_(0)
                                          , rangeData_(I)
    { mallocPtrData( I.size(), I.first());}

    IArrayBase( const IArrayBase& T, bool ref = false)
              : IContainerRef(ref)
    {
      if (ref) // set T data
      {
        p_data_   = T.p_data_;
        rangeData_ = T.rangeData_;
      }
      else // Allocate memory in base class
      {
        setDefault();
      }
    }

    IArrayBase(DATA* q, Range const& I) : IContainerRef(true)
                                        , p_data_(q)
                                        , rangeData_(I)
    { ;}

  public:
    virtual ~IArrayBase()
    { if (!this->isRef()) this->freePtrData(); }

    inline Integer const& firstData() const { return rangeData_.first();}
    inline Integer const& lastData() const { return rangeData_.last();}
    inline Integer const& sizeData() const { return rangeData_.size();}
    inline Range const& rangeData() const { return rangeData_;}
    inline DATA const* const ptrData() const { return p_data_;}

    inline DATA const& data( Integer const& pos) const
    {
#ifdef STK_BOUNDS_CHECK
      if (pos < firstData())
      { throw std::out_of_range("IArrayBase::data(pos) const "
                                "IArrayBase::firstData() > pos");
      }
      if (pos > lastData())
      { throw std::out_of_range("IArrayBase::data(pos) const "
                                "IArrayBase::lastData() < pos");
      }
#endif
      return p_data_[pos];
    }
    
    static Integer evalCapacity(Integer const& m)
    {
      Integer n = 0;
      Integer b = m;
      for (Integer k=1 ; k <= b; n++, k <<= 1);
      return m+n;
    }

  protected:
    inline DATA* ptrData()
    { return p_data_;}

    inline DATA& data(Integer const& pos)
    {
#ifdef STK_BOUNDS_CHECK
      if (pos < firstData())
      { throw std::out_of_range("IArrayBase::data(pos) "
                                "IArrayBase::firstData() > pos");
      }
      if (pos > lastData())
      { throw std::out_of_range("IArrayBase::data(pos) "
                                "IArrayBase::lastData() < pos");
      }
#endif
      return p_data_[pos];
    }
        
   inline void setData( Integer const& pos, DATA const& data = DATA())
   {
#ifdef STK_BOUNDS_CHECK
      if (pos < firstData())
      { throw std::out_of_range("IArrayBase::setData(pos, data) "
                                "IArrayBase::firstData() > pos");
      }
      if (pos > lastData())
      { throw std::out_of_range("IArrayBase::setData(pos, data) "
                                "IArrayBase::lastData() > pos");
      }
#endif
     p_data_[pos] = data;
   }

    void swap(IArrayBase &T)
    {
      // copy main ptr data and range of this
      DATA*   auxMainPtr(p_data_);
      Range   auxRange(rangeData_);
      bool    auxRef(this->isRef());

      // overwrite main ptr data of this
      this->setPtrData(T.p_data_);
      this->setRangeData(T.rangeData_);
      this->setRef(T.isRef());

      // overwrite main PTRCOL of T
      T.setPtrData(auxMainPtr);
      T.setRangeData(auxRange);
      T.setRef(auxRef);
    }

    void shiftPtrData(Integer const& first)
    {
      // check if there is something to do
      if (first == firstData()) return;
      // check for reference
      if (this->isRef())
      { throw std::runtime_error("In IArrayBase::shiftPtrData(first)"
                                 " can't operate on reference.");
      }
      // compute increment
      Integer inc = first - firstData();
      // translate data
      decPtrData(inc);
    }
    void mallocPtrData( Integer const& size, Integer const& inc  = 0)
    {
      // check for reference
      if (this->isRef())
      { throw std::runtime_error("In IArrayBase::mallocPtrData(first)"
                                 " can't operate on reference.");
      }
      // delete any memory allocated
      freePtrData();
      // check size
      if (size <= 0)
      {
        // set initial values
        setRangeData(Range(0,size-1));
        // first index is 0
        return;
      }
      // allocate memory
      try
      {
        setPtrData(new DATA[size]);
      }
      catch (std::bad_alloc & error)  // if an alloc error occur
      {
        // initialize to default
        setDefault();
        // and throw an exception
        throw std::runtime_error("IArrayBase::mallocPtrData(size, inc) "
                                 "memory allocation failed.");
      }
      // set initial values
      setRangeData(Range(0,size-1));  // first index is 0
      // apply increment
      decPtrData(inc);
    }

    void reallocPtrData( Integer const& size, Integer const& inc  = 0)
    {
      // check for reference
      if (this->isRef())
      { throw std::runtime_error("In IArrayBase::reallocPtrData(first)"
                                 " can't operate on reference.");
      }
      // if there is no memory allocated, we use mallocPtrData
      if (!p_data_)
      {
        mallocPtrData(size, inc);
        return;
      }
      // if the new size is empty we can safely remove existing data
      if (size <= 0)
      {
        freePtrData();
        return;
      }
      // reset to zero increment and get data adress
      incPtrData(firstData());
      DATA* p_data = p_data_;
      // allocate memory
      try
      {
        setPtrData(new DATA[size]);
      }
      catch (std::bad_alloc & error)  // if an alloc error occur
      {
        // delete existing data
        delete [] p_data;
        // initialize members to default
        setDefault();
        // and throw an exception
        throw std::runtime_error("IArrayBase::reallocPtrData(size, inc) "
                                 "memory allocation failed.");
      }
      // copy existing data
      Integer nbData = min(size, sizeData());
      for (Integer i=0; i< nbData; i++)
      { p_data_[i] = p_data[i];}
      // delete previous allocated data
      // delete existing data
      delete [] p_data;
      // set initial values
      setRangeData(Range(0,size-1));     // first index is 0
      // apply increment
      decPtrData(inc);
    }

    void freePtrData()
    {
      // nothing to do for ref
      if (this->isRef()) return;
      // if there is elts
      if (p_data_)
      {
        incPtrData(firstData());  // translate
        delete [] p_data_;   // erase
        setPtrData();        // set default values
      }
    }

    inline void setPtrData( DATA* p_data = 0)
    { p_data_ = p_data;}

    inline void setRangeData( Range const& rangeData = Range())
    { rangeData_ = rangeData;}

  private:
    inline void incPtrData( Integer const& inc)
    {
      // translate p_data_ only if there exists data
      if (this->p_data_) { p_data_ += inc;}
      rangeData_.dec(inc);
    }

    inline void decPtrData( Integer const& dec)
    {
      // translate p_data_ only if there exists data
      if (this->p_data_) { p_data_  -= dec;}
      rangeData_.inc(dec);
    }

    inline void setDefault()
    {
      setPtrData();
      setRangeData();
    }

  private:
    DATA* p_data_;
    Range rangeData_;
};

} // namespace STK

#endif
// STK_IARRAYBASE_H