Vector.H

Go to the documentation of this file.

/* _______              __
  / ___/ /  ___  __ _  / /  ___
 / /__/ _ \/ _ \/  ' \/ _ \/ _ \
 \___/_//_/\___/_/_/_/_.__/\___/ 
*/
//
// This software is copyright (C) by the Lawrence Berkeley
// National Laboratory.  Permission is granted to reproduce
// this software for non-commercial purposes provided that
// this notice is left intact.
// 
// It is acknowledged that the U.S. Government has rights to
// this software under Contract DE-AC03-765F00098 between
// the U.S.  Department of Energy and the University of
// California.
//
// This software is provided as a professional and academic
// contribution for joint exchange. Thus it is experimental,
// is provided ``as is'', with no warranties of any kind
// whatsoever, no support, no promise of updates, or printed
// documentation. By using this software, you acknowledge
// that the Lawrence Berkeley National Laboratory and
// Regents of the University of California shall have no
// liability with respect to the infringement of other
// copyrights by any part of this software.
//

// 
//  The simplest of all possible vector classes
//  dtg
//  ANAG 10-28-97
// 

#ifndef _SIMP_VECTOR_H_
#define _SIMP_VECTOR_H_

#include <cmath>
#include <cstdlib>
#include <cassert>
#include <vector>
#include <typeinfo>
#include <string>
#include <map>
#include <list>
#include <algorithm>
#include <iostream>

#ifdef ENABLE_MEMORY_TRACKING
//these objects are used for memory tracking system
typedef std::pair<long int*, long int*> ppair;
typedef std::map<std::string, ppair > VectorList;

typedef std::list<int> lst; //not currently used, bvs.
typedef std::map<std::string, lst*> incr; // not currently used, bvs

extern VectorList* vectorList_;
extern incr*       vectorIncr_;
#endif

using std::vector;
using std::ostream;


template <class T>

class Vector
{
public:

  inline
  Vector()
  {
  }


  inline
  virtual ~Vector()
  {
#ifdef ENABLE_MEMORY_TRACKING  
    if(size()>0) decrement(size());
#endif
  }


  inline
  Vector(const Vector<T>& invec):v(invec.v)
  {
#ifdef ENABLE_MEMORY_TRACKING  
    increment(invec.size());
#endif
  }


  inline
  Vector(const std::vector<T>& invec):v(invec)
  {
#ifdef ENABLE_MEMORY_TRACKING  
    increment(invec.size());
#endif
  }


  inline
  Vector<T>& operator=(const std::vector<T>& invec)
  {
#ifdef ENABLE_MEMORY_TRACKING  
    decrement(size());
#endif
    v=invec;
#ifdef ENABLE_MEMORY_TRACKING  
    increment(size());
#endif
    return *this;
  }


  inline
  Vector<T>& operator=(const Vector<T>& invec)
  {
#ifdef ENABLE_MEMORY_TRACKING  
    decrement(size());
#endif
    v=invec.v;
#ifdef ENABLE_MEMORY_TRACKING  
    increment(size());
#endif
    return *this;
  }


  inline
  Vector<T>& assign(const T& inval)
  {
    v.assign( size(),inval );
    return *this;
  }


  inline
  Vector(/*long*/ unsigned int isize)
  {
    resize(isize);
  }

 
  

  inline
  void clear()
  {
#ifdef ENABLE_MEMORY_TRACKING  
    decrement(size());
#endif
    v.clear();
  }


  inline
  size_t size() const
  {
    return v.size();
  }


  inline
  Vector(/*long*/ unsigned int isize, const T& value) : v(isize, value)
  {
#ifdef ENABLE_MEMORY_TRACKING  
    increment(isize);
#endif
  }


  inline
  T& operator[] (/*long*/ unsigned int n) 
  { 
    assert(n < size());
    //vector<T>* svec = static_cast<vector<T>* >(this);
    //return  svec->operator[](n);
    //    return  (static_cast<vector<T>* >(this))->operator[](n);
    return v[n];
  } 


  inline
  const T& operator[] (/*long*/ unsigned int n) const
  { 
    assert(n < size());
    //const vector<T>* svec = static_cast<const vector<T>* >(this);
    //return  svec->operator[](n);
    //   return  (static_cast<const vector<T>* >(this))->operator[](n);
    return v[n];
  } 

  inline
  void swap(Vector<T>& other)
  {
        v.swap(other.v);
  }

  inline 
  void push_back(const T& in)
  {
#ifdef ENABLE_MEMORY_TRACKING  
    increment(1);
#endif
    //  (static_cast<vector<T>* >(this))->push_back(in);
    v.push_back(in);
  }


  inline
  void  append(const Vector<T>& invec)
  {
#ifdef ENABLE_MEMORY_TRACKING  
    increment(invec.size());
#endif
    for (int ivec = 0; ivec <  invec.size(); ivec++)
      {
        // (static_cast<vector<T>* >(this))->push_back(invec[ivec]);
        v.push_back(invec[ivec]);
      }
  }


  inline
  void resize(/*long*/ unsigned int isize)
  {
    //    vector<T>* svec = static_cast<vector<T>* >(this);
#ifdef ENABLE_MEMORY_TRACKING  
    if(isize > size()) increment(isize-size());
    else               decrement(size()-isize);
#endif
    unsigned int l= size();
    //    svec->resize(isize);
    v.resize(isize);
    for(; l<isize; ++l)
      // svec->operator[](l) = T();
      v[l] = T();
  }

  inline 
  void reserve(/*long*/ size_t isize)
  {
        v.reserve(isize);
  }

  inline 
  size_t capacity() const
  {
        return v.capacity();
  }

  inline
  void resize(/*long*/ unsigned int isize, const T& value)
  {
    //   vector<T>* svec = static_cast<vector<T>* >(this);
#ifdef ENABLE_MEMORY_TRACKING  
    if(isize > size()) increment(isize-size());
    else               decrement(size()-isize);
#endif
    //    svec->resize(isize, value);
    v.resize(isize, value);
  }


  inline void sort()
  {
    std::sort(v.begin(), v.end());
  }

#ifdef ENABLE_MEMORY_TRACKING  
  // static template memory tracking data
  static long int bytes;
  static long int peak;
  //  static lst*  incrementList;
#endif

private:

#ifdef ENABLE_MEMORY_TRACKING  
  inline
  void increment(unsigned int i)
  {
    // warning: pointless comparison of unsigned integer with zero
    // assert(i>=0);  // commented out (ndk)
    static unsigned int sizzle = initFunc();
    i*=sizzle;
    bytes += i;
    //  incrementList->insert(incrementList->begin(), i);
    if(bytes > peak) peak = bytes;
  }

  inline
  void decrement(unsigned int i)
  {
    if(i==0) return;
    //assert(bytes>=0);
    i*=sizeof(T);
    bytes-=i;
    //  incrementList->insert(incrementList->begin(), -i);
    //  assert(bytes>=0);
  }
#endif

  unsigned int initFunc();
  std::vector<T> v;
};

#ifdef ENABLE_MEMORY_TRACKING  
template <class T>
long int Vector<T>::bytes=0;

template <class T>
long int Vector<T>::peak=0;

//template <class T>
//lst*  Vector<T>::incrementList=NULL;
#endif

//class ostream;

template <class T>
ostream& operator<<(ostream& os, const Vector<T>& vec)
{
  for(int i=0; i<vec.size(); i++) os<<vec[i]<<" ";
  return os;
}

#ifdef ENABLE_MEMORY_TRACKING  

template <class T>
unsigned int  Vector<T>::initFunc()
{
  if(vectorList_ == NULL)
  {
    vectorList_ = new VectorList;
    vectorIncr_ = new incr;
  }
  //  if(incrementList == NULL) incrementList = new lst;
  ppair tmp(&bytes, &peak);
  vectorList_->operator[](typeid(T).name()) = tmp;
  //  vectorIncr_->operator[](typeid(T).name()) = incrementList;
  //  bytes = 0;
  //  peak = 0;
  return sizeof(T);
}

#endif
#endif

---