/*
 * MinMaxMeanStatisticProcess.cc
 *
 *  Created on: Nov 06, 2014
 *      Author: AKKA
 */


#include "MinMaxMeanStatisticProcess.hh"

#include "MinMaxMeanStatistic.hh"

namespace AMDA {
namespace Statistic {
namespace MinMaxMean {

MinStatisticProcess::MinStatisticProcess(AMDA::Parameters::Parameter &parameter, const int& index) :
		AMDA::Parameters::StatisticProcess(parameter, false, index)
{
}

MinStatisticProcess::~MinStatisticProcess(void)
{
}

void MinStatisticProcess::createOperation(void)
{
	AMDA::Parameters::ParamData *paramInput = _parameter.getParamData(this).get();
	CreateMinMaxMeanStatistic lCreateMinStatistic( *this, _timeIntervalList, *paramInput, FUNC_TYPE::FT_MIN);
	_operation = lCreateMinStatistic.getStatisticOperation();
}

std::string MinStatisticProcess::getUCD(void)
{
	return "stat.min";
}

MaxStatisticProcess::MaxStatisticProcess(AMDA::Parameters::Parameter &parameter, const int& index) :
		AMDA::Parameters::StatisticProcess(parameter, false, index)
{
}

MaxStatisticProcess::~MaxStatisticProcess(void)
{
}

void MaxStatisticProcess::createOperation(void)
{
	AMDA::Parameters::ParamData *paramInput = _parameter.getParamData(this).get();
	CreateMinMaxMeanStatistic lCreateMaxStatistic( *this, _timeIntervalList, *paramInput, FUNC_TYPE::FT_MAX);
	_operation = lCreateMaxStatistic.getStatisticOperation();
}

std::string MaxStatisticProcess::getUCD(void)
{
	return "stat.max";
}

MeanStatisticProcess::MeanStatisticProcess(AMDA::Parameters::Parameter &parameter, const int& index) :
		AMDA::Parameters::StatisticProcess(parameter, false,index)
{
}

MeanStatisticProcess::~MeanStatisticProcess(void)
{
}

void MeanStatisticProcess::createOperation(void)
{
	AMDA::Parameters::ParamData *paramInput = _parameter.getParamData(this).get();
	CreateMinMaxMeanStatistic lCreateMeanStatistic( *this, _timeIntervalList, *paramInput, FUNC_TYPE::FT_MEAN);
	_operation = lCreateMeanStatistic.getStatisticOperation();
}

std::string MeanStatisticProcess::getUCD(void)
{
	return "stat.mean";
}

RMSStatisticProcess::RMSStatisticProcess(AMDA::Parameters::Parameter &parameter, const int& index) :
		AMDA::Parameters::StatisticProcess(parameter, false,index)
{
}

RMSStatisticProcess::~RMSStatisticProcess(void)
{
}

void RMSStatisticProcess::createOperation(void)
{
	AMDA::Parameters::ParamData *paramInput = _parameter.getParamData(this).get();
	CreateMinMaxMeanStatistic lCreateRMSStatistic( *this, _timeIntervalList, *paramInput, FUNC_TYPE::FT_RMS);
	_operation = lCreateRMSStatistic.getStatisticOperation();
}

std::string RMSStatisticProcess::getUCD(void)
{
	return "stat.RMS";
}

MedianStatisticProcess::MedianStatisticProcess(AMDA::Parameters::Parameter &parameter, const int& index) :
		AMDA::Parameters::StatisticProcess(parameter, false,index)
{
}

MedianStatisticProcess::~MedianStatisticProcess(void)
{
}

void MedianStatisticProcess::createOperation(void)
{
	AMDA::Parameters::ParamData *paramInput = _parameter.getParamData(this).get();
	CreateMinMaxMeanStatistic lCreateMedianStatistic( *this, _timeIntervalList, *paramInput, FUNC_TYPE::FT_MEDIAN);
	_operation = lCreateMedianStatistic.getStatisticOperation();
}

std::string MedianStatisticProcess::getUCD(void)
{
	return "stat.median";
}

VarianceStatisticProcess::VarianceStatisticProcess(AMDA::Parameters::Parameter &parameter, const int& index) :
		AMDA::Parameters::StatisticProcess(parameter, false,index)
{
}

VarianceStatisticProcess::~VarianceStatisticProcess(void)
{
}

void VarianceStatisticProcess::createOperation(void)
{
	AMDA::Parameters::ParamData *paramInput = _parameter.getParamData(this).get();
	CreateMinMaxMeanStatistic lCreateVarianceStatistic( *this, _timeIntervalList, *paramInput, FUNC_TYPE::FT_VARIANCE);
	_operation = lCreateVarianceStatistic.getStatisticOperation();
}

std::string VarianceStatisticProcess::getUCD(void)
{
	return "stat.variance";
}


SkewnessStatisticProcess::SkewnessStatisticProcess(AMDA::Parameters::Parameter &parameter, const int& index) :
		AMDA::Parameters::StatisticProcess(parameter, false,index)
{
}

SkewnessStatisticProcess::~SkewnessStatisticProcess(void)
{
}

void SkewnessStatisticProcess::createOperation(void)
{
	AMDA::Parameters::ParamData *paramInput = _parameter.getParamData(this).get();
	CreateMinMaxMeanStatistic lCreateSkewnessStatistic( *this, _timeIntervalList, *paramInput, FUNC_TYPE::FT_SKEWNESS);
	_operation = lCreateSkewnessStatistic.getStatisticOperation();
}

std::string SkewnessStatisticProcess::getUCD(void)
{
	return "stat.skewness";
}

KurtosisStatisticProcess::KurtosisStatisticProcess(AMDA::Parameters::Parameter &parameter, const int& index) :
		AMDA::Parameters::StatisticProcess(parameter, false,index)
{
}

KurtosisStatisticProcess::~KurtosisStatisticProcess(void)
{
}

void KurtosisStatisticProcess::createOperation(void)
{
	AMDA::Parameters::ParamData *paramInput = _parameter.getParamData(this).get();
	CreateMinMaxMeanStatistic lCreateKurtosisStatistic( *this, _timeIntervalList, *paramInput, FUNC_TYPE::FT_KURTOSIS);
	_operation = lCreateKurtosisStatistic.getStatisticOperation();
}

std::string KurtosisStatisticProcess::getUCD(void)
{
	return "stat.kurtosis";
}

FirstValueStatisticProcess::FirstValueStatisticProcess(AMDA::Parameters::Parameter &parameter, const int& index) :
		AMDA::Parameters::StatisticProcess(parameter, false,index)
{
}

FirstValueStatisticProcess::~FirstValueStatisticProcess(void)
{
}

void FirstValueStatisticProcess::createOperation(void)
{
	AMDA::Parameters::ParamData *paramInput = _parameter.getParamData(this).get();
	CreateMinMaxMeanStatistic lCreateFirstValueStatistic( *this, _timeIntervalList, *paramInput, FUNC_TYPE::FT_FIRST_VALUE);
	_operation = lCreateFirstValueStatistic.getStatisticOperation();
}

std::string FirstValueStatisticProcess::getUCD(void)
{
	return "stat.firstValue";
}

/**
 * Middle Value
 */

MiddleValueStatisticProcess::MiddleValueStatisticProcess(AMDA::Parameters::Parameter &parameter, const int& index) :
		AMDA::Parameters::StatisticProcess(parameter, false,index)
{
}

MiddleValueStatisticProcess::~MiddleValueStatisticProcess(void)
{
}

void MiddleValueStatisticProcess::createOperation(void)
{
	AMDA::Parameters::ParamData *paramInput = _parameter.getParamData(this).get();
	CreateMinMaxMeanStatistic lCreateMiddleValueStatistic( *this, _timeIntervalList, *paramInput, FUNC_TYPE::FT_MIDDLE_VALUE);
	_operation = lCreateMiddleValueStatistic.getStatisticOperation();
}

std::string MiddleValueStatisticProcess::getUCD(void)
{
	return "stat.middleValue";
}

/**
 *  Last Value
 */

LastValueStatisticProcess::LastValueStatisticProcess(AMDA::Parameters::Parameter &parameter, const int& index) :
		AMDA::Parameters::StatisticProcess(parameter, false,index)
{
}

LastValueStatisticProcess::~LastValueStatisticProcess(void)
{
}

void LastValueStatisticProcess::createOperation(void)
{
	AMDA::Parameters::ParamData *paramInput = _parameter.getParamData(this).get();
	CreateMinMaxMeanStatistic lCreateLastValueStatistic( *this, _timeIntervalList, *paramInput, FUNC_TYPE::FT_LAST_VALUE);
	_operation = lCreateLastValueStatistic.getStatisticOperation();
}

std::string LastValueStatisticProcess::getUCD(void)
{
	return "stat.lastValue";
}
} /* namespace MinMaxMean */
} /* namespace Statistic */
} /* namespace AMDA */