---

Vector.H

Go to the documentation of this file.

/*   _______              __
    / ___/ /  ___  __ _  / /  ___
   / /__/ _ \/ _ \/  V \/ _ \/ _ \
   \___/_//_/\___/_/_/_/_.__/\___/
*/
// CHOMBO Copyright (c) 2000-2004, The Regents of the University of
// California, through Lawrence Berkeley National Laboratory (subject to
// receipt of any required approvals from U.S. Dept. of Energy).  All
// rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// (1) Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// (2) Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// (3) Neither the name of Lawrence Berkeley National Laboratory, U.S.
// Dept. of Energy nor the names of its contributors may be used to endorse
// or promote products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// You are under no obligation whatsoever to provide any bug fixes,
// patches, or upgrades to the features, functionality or performance of
// the source code ("Enhancements") to anyone; however, if you choose to
// make your Enhancements available either publicly, or directly to
// Lawrence Berkeley National Laboratory, without imposing a separate
// written license agreement for such Enhancements, then you hereby grant
// the following license: a non-exclusive, royalty-free perpetual license
// to install, use, modify, prepare derivative works, incorporate into
// other computer software, distribute, and sublicense such Enhancements or
// derivative works thereof, in binary and source code form.
//
// TRADEMARKS. Product and company names mentioned herein may be the
// trademarks of their respective owners.  Any rights not expressly granted
// herein are reserved.
//

#ifndef _VECTOR_H_
#define _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
  const T& back() const
  {
    return v.back();
  }

  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

---