DRCEStatVariables.cpp

Go to the documentation of this file.

#include <utility>

#include "DRCEStatVariables.hpp"

namespace HCE
{
namespace drce
{
//-----------------------------------------------------------------------------
template <class T> StatVariableData<T>::StatVariableData(void)
: min(), avg(), max()
{
}
//-----------------------------------------------------------------------------
template <class T> StatVariableData<T>::StatVariableData(const StatVariableData& rhs)
: min(), avg(), max()
{
  (*this) = rhs;
}
//-----------------------------------------------------------------------------
template <class T> StatVariableData<T>::StatVariableData(StatVariableData&& rhs)
: min(), avg(), max()
{
  (*this) = std::forward<StatVariableData>(rhs);
}
//-----------------------------------------------------------------------------
template <class T> StatVariableData<T>& StatVariableData<T>::operator=(const StatVariableData& rhs)
{
  if (this!=&rhs)
  {
    min = rhs.min;
    avg = rhs.avg;
    max = rhs.max;
  }
  return *this;
}
//-----------------------------------------------------------------------------
template <class T> StatVariableData<T>& StatVariableData<T>::operator=(StatVariableData&& rhs)
{
  if (this!=&rhs)
  {
    min = std::move(rhs.min);
    avg = std::move(rhs.avg);
    max = std::move(rhs.max);
  }
  return *this;
}
//-----------------------------------------------------------------------------
template <class T> void StatVariableData<T>::clear(void)
{
  min = T();
  avg = T();
  max = T();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
StatVariables::StatVariables(void)
: timeAsyncTask(), timeSyncTask(), sizeInputBufferSyncTasks(), sizeOutputBufferSyncTasks(),
  sizeInputBufferAsyncTasks(), sizeOutputBufferAsyncTasks(),  cpuUsageAsyncTasks(), memoryUsageAsyncTasks(),
  countSyncTasksForMinute(), countAsyncTasksForMinute(), countSyncTasks(0), countAsyncTasks(0),
  countSyncTasksFail(0), countAsyncTasksFail(0)
{
}
//-----------------------------------------------------------------------------
StatVariables::StatVariables(const StatVariables& rhs)
: timeAsyncTask(), timeSyncTask(), sizeInputBufferSyncTasks(), sizeOutputBufferSyncTasks(),
  sizeInputBufferAsyncTasks(), sizeOutputBufferAsyncTasks(),  cpuUsageAsyncTasks(), memoryUsageAsyncTasks(),
  countSyncTasksForMinute(), countAsyncTasksForMinute(), countSyncTasks(0), countAsyncTasks(0),
  countSyncTasksFail(0), countAsyncTasksFail(0)
{
  (*this) = rhs;
}
//-----------------------------------------------------------------------------
StatVariables::StatVariables(StatVariables&& rhs)
: timeAsyncTask(), timeSyncTask(), sizeInputBufferSyncTasks(), sizeOutputBufferSyncTasks(),
  sizeInputBufferAsyncTasks(), sizeOutputBufferAsyncTasks(),  cpuUsageAsyncTasks(), memoryUsageAsyncTasks(),
  countSyncTasksForMinute(), countAsyncTasksForMinute(), countSyncTasks(0), countAsyncTasks(0),
  countSyncTasksFail(0), countAsyncTasksFail(0)
{
  (*this) = std::forward<StatVariables>(rhs);
}
//-----------------------------------------------------------------------------
StatVariables& StatVariables::operator=(const StatVariables& rhs)
{
  if (this!=&rhs)
  {
    timeAsyncTask = rhs.timeAsyncTask;
    timeSyncTask = rhs.timeSyncTask;
    sizeInputBufferSyncTasks = rhs.sizeInputBufferSyncTasks;
    sizeOutputBufferSyncTasks = rhs.sizeOutputBufferSyncTasks;
    sizeInputBufferAsyncTasks = rhs.sizeInputBufferAsyncTasks;
    sizeOutputBufferAsyncTasks = rhs.sizeOutputBufferAsyncTasks;
    cpuUsageAsyncTasks = rhs.cpuUsageAsyncTasks;
    memoryUsageAsyncTasks = rhs.memoryUsageAsyncTasks;
    countSyncTasksForMinute = rhs.countSyncTasksForMinute;
    countAsyncTasksForMinute = rhs.countAsyncTasksForMinute;
    countSyncTasks = rhs.countSyncTasks;
    countAsyncTasks = rhs.countAsyncTasks;
    countSyncTasksFail = rhs.countSyncTasksFail;
    countAsyncTasksFail = rhs.countAsyncTasksFail;
  }
  return *this;
}
//-----------------------------------------------------------------------------
StatVariables& StatVariables::operator=(StatVariables&& rhs)
{
  if (this!=&rhs)
  {
    timeAsyncTask = std::move(rhs.timeAsyncTask);
    timeSyncTask = std::move(rhs.timeSyncTask);
    sizeInputBufferSyncTasks = std::move(rhs.sizeInputBufferSyncTasks);
    sizeOutputBufferSyncTasks = std::move(rhs.sizeOutputBufferSyncTasks);
    sizeInputBufferAsyncTasks = std::move(rhs.sizeInputBufferAsyncTasks);
    sizeOutputBufferAsyncTasks = std::move(rhs.sizeOutputBufferAsyncTasks);
    cpuUsageAsyncTasks = std::move(rhs.cpuUsageAsyncTasks);
    memoryUsageAsyncTasks = std::move(rhs.memoryUsageAsyncTasks);
    countSyncTasksForMinute = std::move(rhs.countSyncTasksForMinute);
    countAsyncTasksForMinute = std::move(rhs.countAsyncTasksForMinute);
    countSyncTasks = std::move(rhs.countSyncTasks);
    countAsyncTasks = std::move(rhs.countAsyncTasks);
    countSyncTasksFail = std::move(rhs.countSyncTasksFail);
    countAsyncTasksFail = std::move(rhs.countAsyncTasksFail);
  }
  return *this;
}
//-----------------------------------------------------------------------------
void StatVariables::clear(void)
{
  timeAsyncTask = StatVariableData<double>();
  timeSyncTask = StatVariableData<double>();
  sizeInputBufferSyncTasks = StatVariableData<size_t>();
  sizeOutputBufferSyncTasks = StatVariableData<size_t>();
  sizeInputBufferAsyncTasks = StatVariableData<size_t>();
  sizeOutputBufferAsyncTasks = StatVariableData<size_t>();
  cpuUsageAsyncTasks = StatVariableData<double>();
  memoryUsageAsyncTasks = StatVariableData<size_t>();
  countSyncTasksForMinute = StatVariableData<double>();
  countAsyncTasksForMinute = StatVariableData<double>();
  countSyncTasks = 0;
  countAsyncTasks = 0;
  countSyncTasksFail = 0;
  countAsyncTasksFail = 0;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace drce 
} // end namespace HCE