Permalink
Cannot retrieve contributors at this time
/** | |
@file | |
@author Nicholas Gillian <ngillian@media.mit.edu> | |
@version 1.0 | |
@brief The Vector class is a basic class for storing any type of data. The default Vector is an interface for std::vector, but the idea is | |
this can easily be changed when needed (e.g., when running the GRT on an embedded device with limited STL support). This class is a template and can therefore be used with any generic data type. | |
*/ | |
/* | |
GRT MIT License | |
Copyright (c) <2012> <Nicholas Gillian, Media Lab, MIT> | |
Permission is hereby granted, free of charge, to any person obtaining a copy of this software | |
and associated documentation files (the "Software"), to deal in the Software without restriction, | |
including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, | |
subject to the following conditions: | |
The above copyright notice and this permission notice shall be included in all copies or substantial | |
portions of the Software. | |
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT | |
LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. | |
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, | |
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE | |
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
*/ | |
#ifndef GRT_VECTOR_HEADER | |
#define GRT_VECTOR_HEADER | |
#include <iostream> | |
#include <iterator> // std::front_inserter | |
#include <algorithm> // std::copy | |
#include <vector> | |
#include "../Util/GRTTypedefs.h" | |
GRT_BEGIN_NAMESPACE | |
template <class T> class Vector : public std::vector< T >{ | |
public: | |
/** | |
Default Constructor | |
*/ | |
//Vector(){} | |
/** | |
Constructor, sets the size of the vector | |
@param size: the size of the vector | |
*/ | |
Vector( const unsigned int size = 0 ):std::vector< T >(size){} | |
/** | |
Constructor, sets the size of the vector and sets all elements to value | |
@param size: the size of the vector | |
*/ | |
Vector( const unsigned int size, const T &value ):std::vector< T >(size, value){} | |
/** | |
Copy Constructor, copies the values from the rhs Vector to this Vector instance | |
@param rhs: the Vector from which the values will be copied | |
*/ | |
Vector( const Vector &rhs ){ | |
unsigned int N = rhs.getSize(); | |
if( N > 0 ){ | |
this->resize( N ); | |
std::copy( rhs.begin(), rhs.end(), this->begin() ); | |
}else this->clear(); | |
} | |
/** | |
Copy Constructor, copies the values from the rhs std::vector to this Vector instance | |
@param rhs: the base class instance from which the values will be copied | |
*/ | |
Vector( const std::vector< T > &rhs ){ | |
unsigned int N = rhs.size(); | |
if( N > 0 ){ | |
this->resize( N ); | |
std::copy( rhs.begin(), rhs.end(), this->begin() ); | |
}else this->clear(); | |
} | |
/** | |
Destructor, cleans up any memory | |
*/ | |
virtual ~Vector(){ } | |
/** | |
Defines how the data from the rhs Vector should be copied to this Vector | |
@param rhs: another instance of a Vector | |
@return returns a reference to this instance of the Vector | |
*/ | |
Vector& operator=(const Vector &rhs){ | |
if(this!=&rhs){ | |
unsigned int N = rhs.getSize(); | |
if( N > 0 ){ | |
this->resize( N ); | |
std::copy( rhs.begin(), rhs.end(), this->begin() ); | |
}else this->clear(); | |
} | |
return *this; | |
} | |
/** | |
Defines how the data from the rhs std::vector instance should be copied to this Vector | |
@param rhs: another instance of a Vector | |
@return returns a reference to this instance of the Vector | |
*/ | |
Vector& operator=(const std::vector< T > &rhs){ | |
if(this!=&rhs){ | |
unsigned int N = rhs.size(); | |
if( N > 0 ){ | |
this->resize( N ); | |
std::copy( rhs.begin(), rhs.end(), this->begin() ); | |
}else this->clear(); | |
} | |
return *this; | |
} | |
/** | |
Defines how the vector should be resized | |
@param size: the new size of the vector | |
@return returns true if the vector was resized correctly, false otherwise | |
*/ | |
virtual bool resize( const unsigned int size ){ | |
std::vector< T >::resize( size ); | |
return getSize() == size; | |
} | |
/** | |
Defines how the vector should be resized, this will also set all the values in the vector to [value] | |
@param size: the new size of the vector | |
@param value: the value that will be copied to all elements in the vector | |
@return returns true if the vector was resized correctly, false otherwise | |
*/ | |
virtual bool resize( const unsigned int size, const T& value ){ | |
std::vector< T >::resize( size, value ); | |
return getSize() == size; | |
} | |
/** | |
Copies the data from the rhs vector to this vector. | |
@param rhs: the vector you want to copy into this vector | |
@return returns true or false, indicating if the copy was successful | |
*/ | |
virtual bool copy( const Vector<T> &rhs ){ | |
if( this != &rhs ){ | |
unsigned int N = rhs.getSize(); | |
if( N > 0 ){ | |
this->resize( N ); | |
std::copy( rhs.begin(), rhs.end(), this->begin() ); | |
} | |
} | |
return true; | |
} | |
/** | |
Sets all the values in the Vector to the input value | |
@param value: the value you want to set all the Vector values to | |
@return returns true or false, indicating if the set was successful | |
*/ | |
bool fill(const T &value){ | |
const unsigned int N = this->size(); | |
if( N == 0 ) return false; | |
std::fill(this->begin(),this->end(),value); | |
return true; | |
} | |
/** | |
Sets all the values in the Vector to the input value | |
@param value: the value you want to set all the Vector values to | |
@return returns true or false, indicating if the set was successful | |
*/ | |
bool setAll(const T &value){ | |
return fill(value); | |
} | |
/** | |
Gets the size of the Vector | |
@return returns the size of the Vector | |
*/ | |
inline UINT getSize() const{ return static_cast<UINT>(this->size()); } | |
/** | |
Gets a pointer to the first element in the vector | |
@return returns a pointer to the raw data | |
*/ | |
T* getData() { | |
if( this->size() == 0 ) return NULL; | |
return &(*this)[0]; | |
} | |
/** | |
Gets a pointer to the first element in the vector | |
@return returns a pointer to the raw data | |
*/ | |
const T* getData() const { | |
if( this->size() == 0 ) return NULL; | |
return &(*this)[0]; | |
} | |
protected: | |
}; | |
GRT_END_NAMESPACE | |
#endif //GRT_VECTOR_HEADER |