ThreadSafeVector.cpp

Go to the documentation of this file.

/* -*- C++ -*- */
#ifndef _MADARA_THREADSAFE_VECTOR_CPP_
#define _MADARA_THREADSAFE_VECTOR_CPP_
 
#include "madara/utility/ThreadSafeVector.h"
 
template<typename T>
madara::utility::ThreadSafeVector<T>::ThreadSafeVector(void)
{
}
 
template<typename T>
madara::utility::ThreadSafeVector<T>::ThreadSafeVector(
    const ThreadSafeVector& rhs)
{
  MADARA_GUARD_TYPE rhs_guard(rhs.mutex_);
  vector_ = rhs.vector_;
}
 
template<typename T>
madara::utility::ThreadSafeVector<T>::ThreadSafeVector(
    const std::vector<T>& rhs)
{
  vector_ = rhs;
}
 
template<typename T>
madara::utility::ThreadSafeVector<T>::~ThreadSafeVector<T>(void)
{
  clear();
}
 
template<typename T>
void madara::utility::ThreadSafeVector<T>::operator=(
    const ThreadSafeVector<T>& rhs)
{
  MADARA_GUARD_TYPE guard(mutex_);
  MADARA_GUARD_TYPE rhs_guard(rhs.mutex_);
 
  if (this != &rhs)
  {
    vector_ = rhs.vector_;
  }
}
 
template<typename T>
void madara::utility::ThreadSafeVector<T>::operator=(const std::vector<T>& rhs)
{
  MADARA_GUARD_TYPE guard(mutex_);
 
  if (this->vector_ != &rhs)
  {
    vector_ = rhs;
  }
}
 
template<typename T>
T& madara::utility::ThreadSafeVector<T>::operator[](size_t index)
{
  MADARA_GUARD_TYPE guard(mutex_);
  return vector_[index];
}
 
template<typename T>
const T& madara::utility::ThreadSafeVector<T>::operator[](size_t index) const
{
  MADARA_GUARD_TYPE guard(mutex_);
  return vector_[index];
}
 
template<typename T>
void madara::utility::ThreadSafeVector<T>::push_back(T& value)
{
  MADARA_GUARD_TYPE guard(mutex_);
  vector_.push_back(value);
}
 
template<typename T>
const T& madara::utility::ThreadSafeVector<T>::back(void) const
{
  MADARA_GUARD_TYPE guard(mutex_);
  return vector_.back();
}
 
template<typename T>
T madara::utility::ThreadSafeVector<T>::pop_back(void)
{
  MADARA_GUARD_TYPE guard(mutex_);
  T result(vector_.back());
 
  vector_.pop_back();
  return result;
}
 
template<typename T>
size_t madara::utility::ThreadSafeVector<T>::erase(size_t index)
{
  MADARA_GUARD_TYPE guard(mutex_);
 
  if (index < vector_.size())
    vector_.erase(vector_.begin() + index);
 
  return vector_.size();
}
 
template<typename T>
T& madara::utility::ThreadSafeVector<T>::back(void)
{
  MADARA_GUARD_TYPE guard(mutex_);
  return vector_.back();
}
 
template<typename T>
void madara::utility::ThreadSafeVector<T>::resize(size_t new_size) const
{
  MADARA_GUARD_TYPE guard(mutex_);
  vector_.resize(new_size);
}
 
template<typename T>
void madara::utility::ThreadSafeVector<T>::reserve(size_t new_size) const
{
  MADARA_GUARD_TYPE guard(mutex_);
  vector_.reserve(new_size);
}
 
template<typename T>
size_t madara::utility::ThreadSafeVector<T>::size(void) const
{
  MADARA_GUARD_TYPE guard(mutex_);
  return vector_.size();
}
 
template<typename T>
size_t madara::utility::ThreadSafeVector<T>::max_size(void) const
{
  MADARA_GUARD_TYPE guard(mutex_);
  return vector_.max_size();
}
 
template<typename T>
void madara::utility::ThreadSafeVector<T>::clear(void)
{
  MADARA_GUARD_TYPE guard(mutex_);
  vector_.clear();
}
 
template<typename T>
void madara::utility::ThreadSafeVector<T>::lock(void) const
{
  mutex_.MADARA_LOCK_LOCK();
}
 
template<typename T>
void madara::utility::ThreadSafeVector<T>::acquire(void) const
{
  mutex_.MADARA_LOCK_LOCK();
}
 
template<typename T>
void madara::utility::ThreadSafeVector<T>::unlock(void) const
{
  mutex_.MADARA_LOCK_UNLOCK();
}
 
template<typename T>
void madara::utility::ThreadSafeVector<T>::release(void) const
{
  mutex_.MADARA_LOCK_UNLOCK();
}
 
#endif /* _MADARA_THREADSAFE_VECTOR_CPP_ */