---

barray.cpp

/*=============================================================================
        File: barray.cpp
     Purpose:       
    Revision: $Id: barray.cpp,v 1.5 2003/05/15 02:34:55 philosophil Exp $
  Created by: Philippe Lavoie          (3 Oct, 1996)
 Modified by: 

 Copyright notice:
          Copyright (C) 1996-1998 Philippe Lavoie
 
          This library is free software; you can redistribute it and/or
          modify it under the terms of the GNU Library General Public
          License as published by the Free Software Foundation; either
          version 2 of the License, or (at your option) any later version.
 
          This library 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
          Library General Public License for more details.
 
          You should have received a copy of the GNU Library General Public
          License along with this library; if not, write to the Free
          Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
=============================================================================*/

#ifndef BARRAY_SOURCES_
#define BARRAY_SOURCES_


#include "matrix_global.h"
#include <new>
#include "barray.h"
#include <cstring>

namespace PLib {

template<class T>
BasicArray<T>::BasicArray() : rsize(0), wdth(0), sze(0)
{
  x = 0;
  destruct = 0 ;
}

template<class T>
BasicArray<T>::BasicArray(const int ni) {
  x = 0 ;
  sze = wdth = rsize = 0 ;
  resize(ni) ;
  destruct = 1 ;
}

template<class T>
BasicArray<T>::BasicArray(T* ap, const int size) : rsize(size), wdth(size+1), sze(size)
{
  x = ap ;
  destruct = 0 ;
}

template<class T> BasicArray<T>::BasicArray(const BasicArray<T>& f2) 
{
  rsize = sze = 0 ;
  x = 0 ;
  resize(f2.size());
  T *p2,*p1 ;
  p1 = x-1 ;
  p2 = f2.x - 1 ;
  
  for (int k = rsize; k >0; --k)
    *(++p1) = *(++p2) ;
  destruct = 1 ;
}

template<class T> BasicArray<T>::BasicArray(BasicList<T> &list) 
{
  BasicNode<T> *node = list.goToFirst() ;
  rsize = sze = 0 ;
  x = 0 ;
  resize(list.size());

  for (int k = rsize; k>0; --k){
    x[k] = *node->data ;
    node = list.goToNext() ;
  }
  destruct = 1 ;
}

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

template<class T> void BasicArray<T>::clear()
{
  if(destruct){
    if ( x ) delete []x;
    x = 0;
    rsize = sze = 0;                 
  }
}

template<class T> 
BasicArray<T>& BasicArray<T>::operator=(const BasicArray<T>& f2)
{
  if ( this == &f2 )
    return *this;

  resize(f2.size()) ;
  
  // wdth = f2.wdth;
  T *p1,*p2 ;
  p1 = x-1 ;
  p2 = f2.x-1 ;

  for (int k = sze; k >0; --k)
    *(++p1) = *(++p2) ;

  return *this; 
}

template<class T>
void 
BasicArray<T>::trim(const int nsize)    
{
  if ( nsize >= 0 && nsize <= rsize )
    sze = nsize;
}

template<class T>
void 
BasicArray<T>::reset(const T val)
{
  T *p1 ;
  p1 = x-1 ;
  for (int k = sze; k >0; --k)
    *(++p1) = val;
}

template <class T>
void resizeBasicArray(BasicArray<T>& a, int nsize)
{
  int k;
  
  if ( nsize == a.rsize ){
    a.sze = nsize ;
    return;                     // nothing to do
  }
  
  if(a.sze>nsize){
    a.sze = nsize ;
    return ;
  }

  if((a.sze<nsize) && (nsize<a.rsize)){
    for(k=a.sze;k<nsize;++k)
      a.x[k] = T() ;
    a.sze = nsize ;
    return ;
  }

  T *xn ; 
  T *p,*pn ;
  xn = new T[nsize];
  p = a.x ;
  pn = xn ;
  
  if ( a.x )
    {
      // copy the old data
      memcpy((void*)xn,(void*)a.x,a.sze*sizeof(T)) ;
      if(a.sze<nsize)
        memset((void*)(xn+a.sze),0,(nsize-a.sze)*sizeof(T)) ;
      if(a.destruct)
        delete []a.x;
    }
  else
    memset((void*)xn,0,nsize*sizeof(T)) ;
  
  a.rsize = nsize;
  a.sze = a.rsize ;
  a.x = xn;
  a.destruct = 1 ;
  a.wdth = a.rsize + 1;
}


template<class T>
istream&  
operator>> (istream& is, BasicArray<T>& arry)
{
  T new_x;
  int k, kend;

  if ( is.eof() )
    return is;
  
  
  kend = arry.size();
  
  for (k = 0; k < kend; ++k)
        {               
          is >> new_x;    
          // end of file reached, abort the read
          if ( is.eof() || is.fail() )
            return is;
          
          arry[k] = new_x;              
        }
  
  return is;
        
}

template<class T>
ostream& BasicArray<T>::print(ostream& os) const
{
  const int iend = size();
  
  for (int i = 0; i < iend;  )
    {
      os << x[i] ; // << endl;
      if ( (++i % wdth) == 0 )
        os << '\n';
      else
        os << "   "; 
    }
  os << '\n' ;
  
  return os;    
}


template<class T>
ostream&  
operator<<(ostream& os,const BasicArray<T>& arry)
{
  return arry.print(os);        
}


template<class T>
int  
operator!=(const BasicArray<T> &a,const BasicArray<T> &b) 
{
  if ( a.size() != b.size() )
    return 1;
  
  const int sz = a.size();
  int l = 1;
  
  for (int i = 0; i < sz; ++i){
    l = l && ( a[i] == b[i] );
    if(!l) break ;
  }
  
  return (l==0 ? 1 : 0);
  
}

template<class T>
int  
operator==(const BasicArray<T> &a,const BasicArray<T> &b) 
{
  if ( a.size() != b.size() )
    return 0;
  
  const int sz = a.size();
  int l = 1;
  
  for (int i = 0; i < sz; ++i)
    l = l && ( a[i] == b[i] );
  
  return l; 
}

#ifdef DEBUG_PLIB
template <class T>
T& BasicArray<T>::elem(const int i) {
  if(i<0 || i>=sze){
#ifdef USE_EXCEPTION
    throw OutOfBound(i,0,n()-1) ;
#else
    Error error("BasicArray<T>::operator[]") ;
    error << "Error Accessing the vector (press C-c to stop)\n" ;
    error << "Bad index " << i << endl ;
    error.fatal() ;
#endif
  }
  return x[i] ;
  
}

template <class T>
T  BasicArray<T>::elem(const int i) const {
  if(i<0 || i>=n()){
#ifdef USE_EXCEPTION
    throw OutOfBound(i,0,n()-1) ;
#else
    Error error("BasicArray<T>::operator[]") ;
    error << "Error Accessing the vector (press C-c to stop)\n" ;
    error << "Bad index " << i << endl ;
    error.fatal() ;
#endif
  }
  return x[i] ;
}

#endif

template<class T>  
T& BasicArray<T>::push_back(const T i, int end_buffer, double end_mult){
  int old_size = sze;
  if(sze>=rsize){
    int n=sze; 
    if(end_mult>1.0){
      n = (int)( double(rsize)*end_mult) ;
    }
    else if(end_buffer<0){
      n++;
    }
    else{
      n += end_buffer;
    }
    resize(n); // allocate new memory, set rsze
  }
  resize(old_size+1); // set sze
  x[old_size] = i ; 
  return x[old_size];
}

}


#endif //BARRAY_SOURCES

---