Vector.hpp

Go to the documentation of this file.

//==============================================================================
//
//  This file is part of GNSSTk, the ARL:UT GNSS Toolkit.
//
//  The GNSSTk 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 3.0 of the License, or
//  any later version.
//
//  The GNSSTk 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 GNSSTk; if not, write to the Free Software Foundation,
//  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin.
//  Copyright 2004-2022, The Board of Regents of The University of Texas System
//
//==============================================================================
 
//==============================================================================
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin, under contract to an agency or agencies
//  within the U.S. Department of Defense. The U.S. Government retains all
//  rights to use, duplicate, distribute, disclose, or release this software.
//
//  Pursuant to DoD Directive 523024
//
//  DISTRIBUTION STATEMENT A: This software has been approved for public
//                            release, distribution is unlimited.
//
//==============================================================================
 
#ifndef GNSSTK_VECTOR_HPP
#define GNSSTK_VECTOR_HPP
 
#include <limits>
#include <vector>
#include "VectorBase.hpp"
 
namespace gnsstk
{
 
 
      // forward declaration
   template <class T> class VectorSlice;
 
   template <class T>
   class Vector : public RefVectorBase<T, Vector<T> >
   {
   public:
      typedef T value_type;
      typedef T& reference;
      typedef const T& const_reference;
      typedef T* iterator;
      typedef const T* const_iterator;
 
      Vector() : v(NULL), s(0)
      {}
      Vector(size_t siz) : v(NULL), s(siz)
      {
         if (siz>0)
         {
            v = new T[siz];
            if(!v) {
               VectorException e("Vector(size_t) failed to allocate");
               GNSSTK_THROW(e);
            }
         }
      }
      Vector(size_t siz, const T defaultValue) : v(NULL), s(siz)
      {
         if (siz>0)
         {
            v = new T[siz];
            if(!v) {
               VectorException e("Vector<T>(size_t, const T) failed to allocate");
               GNSSTK_THROW(e);
            }
            this->assignFrom(defaultValue);
         }
      }
      template <class E>
      Vector(const ConstVectorBase<T, E>& r) : v(NULL), s(r.size())
      {
         if (r.size()>0)
         {
            v = new T[r.size()];
            if(!v) {
               VectorException e("Vector<T>(ConstVectorBase) failed to allocate");
               GNSSTK_THROW(e);
            }
            this->assignFrom(r);
         }
      }
      Vector(const Vector& r) : v(NULL), s(r.s)
      {
         if (r.s>0)
         {
            v = new T[r.s];
            if(!v) {
               VectorException e("Vector(Vector) failed to allocate");
               GNSSTK_THROW(e);
            }
            this->assignFrom(r);
         }
      }
      Vector(const std::valarray<T>& r) : v(NULL), s(r.size())
      {
         if (r.size())
         {
            v = new T[r.size()];
            if(!v) {
               VectorException e("Vector(valarray) failed to allocate");
               GNSSTK_THROW(e);
            }
            this->assignFrom(r);
         }
      }
 
      template <class E>
      Vector(const ConstVectorBase<T, E>& vec,
             size_t top,
             size_t num) : v(NULL), s(0)
      {
            // sanity checks...
         if ( top >= vec.size() ||
              top + num > vec.size())
         {
            VectorException e("Invalid dimensions or size for Vector(VectorBase)");
            GNSSTK_THROW(e);
         }
         if (num>0)
         {
            v = new T[num];
            if(!v) {
               VectorException e("Vector(subvector) failed to allocate");
               GNSSTK_THROW(e);
            }
            size_t i;
            for(i = 0; i < num; i++)
               v[i] = vec(top+i);
            s = num;
         }
      }
 
      ~Vector()
      {
         if (v) delete [] v;
      }
 
      iterator begin() { return v; }
      const_iterator begin() const { return v; }
      iterator end() { return v + s; }
      const_iterator end() const { return v + s; }
      value_type front() { return v[s-1]; }
      const_reference front() const { return v[s-1];}
      bool empty() const { return size() == 0; }
      size_t size() const {return s; }
      size_t max_size() const { return std::numeric_limits<size_t>().max(); }
 
      T& operator[] (size_t i)
      { return v[i]; }
      T operator[] (size_t i) const
      { return v[i]; }
      T& operator() (size_t i)
      { return v[i]; }
      T operator() (size_t i) const
      { return v[i]; }
 
      VectorSlice<T> operator[] (const std::slice& sli)
      { return VectorSlice<T>(*this, sli); }
 
      Vector& operator=(const Vector& x)
      { resize(x.s); return this->assignFrom(x); }
 
      template <class E>
      Vector& operator=(const ConstVectorBase<T, E>& x)
      { resize(x.size()); return this->assignFrom(x); }
 
      Vector& operator=(const std::valarray<T>& x)
      { resize(x.size()); return this->assignFrom(x); }
      Vector& operator=(const T x)
      { return this->assignFrom(x); }
      Vector& operator=(const T* x)
      { return this->assignFrom(x); }
 
      inline Vector& operator=(const std::vector<T>& x)
      {
         size_t i;
         size_t vs = x.size();
         (*this).resize(vs);
 
         for (i = 0; i < vs; i++)
            (*this)[i] = x[i];
 
         return (*this);
      }
 
      Vector& resize(const size_t index)
      {
         if (index > s)
         {
            if (v)
               delete [] v;
            v = new T[index];
            if(!v) {
               VectorException e("Vector.resize(size_t) failed to allocate");
               GNSSTK_THROW(e);
            }
         }
         s = index;
         return *this;
      }
 
      Vector& resize(const size_t index, const T defaultValue)
      {
         resize(index);
         for(size_t i = 0; i < s; i++)
            v[i] = defaultValue;
         return *this;
      }
 
         // convert the gnsstk vector to std vector
      std::vector<T> toStdVector()
      {
         std::vector<T> std_vec;
         for(size_t i = 0; i < s; i++)
            std_vec.push_back(v[i] );
         return std_vec;
      }
 
      inline Vector& operator<<(const Vector& b)
      {
         size_t i;
         size_t vs = this->size();
         size_t bs = b.size();
         size_t rows = vs + bs;
         Vector<T> toReturn(rows);
 
         for (i = 0; i < vs; i++)
            toReturn[i] = (*this)[i];
 
         for (i = 0; i < bs; i++)
            toReturn[i+vs] = b[i];
 
         (*this) = toReturn;
 
         return (*this);
      }
 
      inline Vector& operator<<(const T &b)
      {
         return (*this) << Vector(1,b);
      }
 
      inline Vector operator&&(const Vector &b)
      {
         size_t i;
         size_t vs = this->size();
         size_t bs = b.size();
         size_t rows = vs + bs;
         Vector<T> toReturn(rows);
 
         for (i = 0; i < vs; i++)
            toReturn[i] = (*this)[i];
 
         for (i = 0; i < bs; i++)
            toReturn[i+vs] = b[i];
 
         return toReturn;
      }
 
      inline Vector operator&&(const T &b)
      {
         size_t i;
         size_t vs = this->size();
         size_t rows = vs + 1;
         Vector<T> toReturn(rows);
 
         for (i = 0; i < vs; i++)
            toReturn[i] = (*this)[i];
 
         toReturn[rows - 1] = b;
 
         return toReturn;
      }
 
   private:
 
         // a good optimizer will remove this function call
         // if RANGECHECK isn't defined.  remember that
         // range checking affects EVERY operation
      inline bool rangeCheck(const size_t index) const
      {
#ifdef RANGECHECK
         return (index < s);
#else
         return true;
#endif
      }
 
      T* v;
      size_t s;
   };
      // end class Vector<T>
 
   template <class T>
   class VectorSlice : public RefVectorSliceBase<T, VectorSlice<T> >
   {
   public:
      VectorSlice()
            : v(NULL), s(std::slice(0,0,0))
      {}
 
      VectorSlice(Vector<T>& vv)
            : v(&vv), s(std::slice(0,vv.size(),1))
      {}
 
      VectorSlice(Vector<T>& vv, const std::slice& ss)
            : v(&vv), s(ss)
      { this->vecSliceCheck(vv.size()); }
 
      template <class V>
      VectorSlice& operator=(const ConstVectorBase<T, V>& x)
      { return this->assignFrom(x); }
 
      VectorSlice& operator=(const std::valarray<T>& x)
      { return this->assignFrom(x); }
 
      VectorSlice& operator=(const T x)
      { return this->assignFrom(x); }
 
      VectorSlice& operator=(const T* x)
      { return this->assignFrom(x); }
 
      T& operator[] (size_t i)
      { return (*v)[start() + i * stride()]; }
      T operator[] (size_t i) const
      { return (*v)[start() + i * stride()]; }
      T& operator() (size_t i)
      { return (*v)[start() + i * stride()]; }
      T operator() (size_t i) const
      { return (*v)[start() + i * stride()]; }
 
      inline size_t size() const { return s.size(); }
      inline size_t start() const { return s.start(); }
      inline size_t stride() const { return s.stride(); }
   private:
      Vector<T>* v;
      std::slice s;
   };
 
   template <class T>
   class ConstVectorSlice : public ConstVectorSliceBase<T, ConstVectorSlice<T> >
   {
   public:
      ConstVectorSlice()
            : v(NULL), s(std::slice(0,0,0))
      { }
 
      ConstVectorSlice(const Vector<T>& vv)
            : v(&vv), s(std::slice(0,vv.size(),1))
      { }
 
      ConstVectorSlice(const Vector<T>& vv, const std::slice& ss)
            : v(&vv), s(ss)
      { vecSliceCheck(vv.size()); }
 
      T operator[] (size_t i) const
      { return (*v)[start() + i * stride()]; }
      T operator() (size_t i) const
      { return (*v)[start() + i * stride()]; }
 
      inline size_t size() const { return s.size(); }
      inline size_t start() const { return s.start(); }
      inline size_t stride() const { return s.stride(); }
 
   private:
      const Vector<T>* v;
      std::slice s;
   };
 
 
}  // namespace
 
#include "VectorOperators.hpp"
 
#endif