RDM::TIME_SERIES::mean< N, AGGREGATE_T, AGG_ELEMENT_T, NEXT > Class Template Reference

Template Class for doing an arithmetic mean. More...

#include "rdm_time_series_mean.h"

Inheritance diagram for RDM::TIME_SERIES::mean< N, AGGREGATE_T, AGG_ELEMENT_T, NEXT >:

Public Member Functions
uint8_t *	serialize (uint8_t *buffer)
uint8_t *	unserialize (uint8_t *buffer)
RDM_RETCODE	init (RDM_DB p_db)
	Initialize this object. More...
void	reset (void)
	Reset this object. More...
RDM_RETCODE	flush_value (uint32_t threshold=1, RDM::DB::TRANSACTIONAL_T transactional=RDM::DB::NOT_TRANSACTIONAL)
	Flush this object. More...
RDM_RETCODE	flush_range (uint32_t threshold=1, RDM::DB::TRANSACTIONAL_T transactional=RDM::DB::NOT_TRANSACTIONAL)
	Flush this object. More...
template<class SOURCE_VALUE_T >
RDM_RETCODE	put_value (SOURCE_VALUE_T *source_value, RDM::DB::TRANSACTIONAL_T transactional=RDM::DB::NOT_TRANSACTIONAL)
	Template method for receiving a data values. More...
template<class SOURCE_AGGREGATE_T >
RDM_RETCODE	put_range (SOURCE_AGGREGATE_T *source_range, RDM::DB::TRANSACTIONAL_T transactional=RDM::DB::NOT_TRANSACTIONAL)
	Template method for receiving ranges. More...

Static Public Member Functions
constexpr static int	get_serialize_size (void)
	Get the size of a buffer for serialization to hold its state. More...

Friends
template<class ANY_NEXT >
class	RDM::DB::transaction
template<class ANY_NEXT_1 , class ANY_NEXT_2 >
class	split
template<uint32_t ANY_N, class ANY_RANGE_T , class ANY_NEXT >
class	collect
template<uint32_t ANY_N, class ANY_RANGE_T , class ANY_INDATA_T , class ANY_NEXT >
class	fft
template<uint32_t ANY_N, class ANY_AGGREGATE_T , class ANY_AGG_ELEMENT_T , class ANY_NEXT >
class	mean
template<class ANY_RATIO , class ANY_NEXT >
class	scale
template<uint32_t ANY_N, class ANY_STATS_T , class ANY_NEXT >
class	stats
template<uint32_t ANY_N, class ANY_NEXT >
class	downsample
template<class ANY_NEXT >
class	custom

Detailed Description

template<uint32_t N, class AGGREGATE_T, class AGG_ELEMENT_T, class NEXT>
class RDM::TIME_SERIES::mean< N, AGGREGATE_T, AGG_ELEMENT_T, NEXT >

Template Class for doing an arithmetic mean.

Template class for taking the arithmetic means of data values or ranges. What is received will be collected and used for taking arithmetic means. The result of those arithmetic means will be forwarded to the next class in the chain.

This class is incomplete as it does not have the code for doing the actual FFT computation. Use one of the following derived classes:

• arithmetic_mean
• geometric_mean
• harmonic_mean

Template Parameters

N	The number of receved RANGE calculations for each arithmetic mean.
AGGREGATE_T	The aggregate range or stats class for which objects will be passed to the next class.
AGG_ELEMENT_T	The type for the elements that must be aggregated to compute the mean.
NEXT	The class in the chain to receive arithmetic means.

Member Function Documentation

flush_range()

template<uint32_t N, class AGGREGATE_T , class AGG_ELEMENT_T , class NEXT >

RDM_RETCODE RDM::TIME_SERIES::mean< N, AGGREGATE_T, AGG_ELEMENT_T, NEXT >::flush_range ( uint32_t threshold = 1, RDM::DB::TRANSACTIONAL_T transactional = RDM::DB::NOT_TRANSACTIONAL )

inline

Flush this object.

Call this method to flush what has been collected so far. A threshold can also be provided. All the data collected for those ranges will be kept as is. The same is the case where the threshold has not been reached.

This operation can be specified as being transactional. However, if the caller always rolls back the transaction in the case of a failure, there is no need to specify single operations to be transactional.

Return values

sOKAY	Normal, successful return.
eNOSTARTUPDATE	An update operation was attempted when no rdm_dbStartUpdate() is active.
eNOTLOCKED	Attempt to access a table for reading or update without proper locks.
eCURSORDB	Cursor is associated with a different database.
eDBNOTOPEN	Database not open.
ePRECOMMITTED	A precommitted transaction must be committed or rolled back before further operations on this database are allowed.
eDUPLICATE	Attempt to insert a duplicate value as a unique/primary key.
eREADONLY	Database is read-only and cannot be updated.
eREFINTEGRITY	Integrity constraint violation.
eROWLIMIT	Table row limit reached.
eINVARG	Invalid argument.

Parameters

threshold	[IN] Only flush objects where at least this many elements have been collected
transactional	[IN] Is the flush required to be transactional

 {
RDM_RETCODE rc = sOKAY;


if (n >= threshold && n > 0)
 {
 AGGREGATE_T scaled_aggregate = aggregate;


for (uint32_t i = 0; i < RDM_LEN(aggregate.value_range); i++)
 {
 agg_scale (n, scaled_aggregate.value_range[i]);
 }


RDM_TRANS trans{};


if (transactional == RDM::DB::TRANSACTIONAL)
 {
 rc = rdm_dbStartUpdate (db, NULL, 0, NULL, 0, &trans);
 }


if (rc == sOKAY)
 {
 rc = next.put_range (&scaled_aggregate, RDM::DB::NOT_TRANSACTIONAL);
if (rc == sOKAY)
 {
 n_just_before_last_flush = n;
 rc = next.flush_range (threshold, RDM::DB::NOT_TRANSACTIONAL);
if (rc == sOKAY)
 {
 n = 0;
 }
else

 {
 next.unput ();
 }
 }
if (transactional == RDM::DB::TRANSACTIONAL)
 {
if (rc == sOKAY)
 {
 rc = rdm_transEnd (trans);
 }
else

 {
rdm_transEndRollback (trans);
 }
 }
 }
 }
else

 {
if (n == 0)
 {
 n_just_before_last_flush = 0;
 }
 rc = next.flush_range (threshold, transactional);
 }


return rc;
 }

References RDM::DB::NOT_TRANSACTIONAL, rdm_dbStartUpdate(), RDM_LEN, rdm_transEnd(), rdm_transEndRollback(), sOKAY, and RDM::DB::TRANSACTIONAL.

Here is the call graph for this function:

flush_value()

template<uint32_t N, class AGGREGATE_T , class AGG_ELEMENT_T , class NEXT >

RDM_RETCODE RDM::TIME_SERIES::mean< N, AGGREGATE_T, AGG_ELEMENT_T, NEXT >::flush_value ( uint32_t threshold = 1, RDM::DB::TRANSACTIONAL_T transactional = RDM::DB::NOT_TRANSACTIONAL )

inline

Flush this object.

Call this method to flush what has been collected so far. A threshold can also be provided. All the data collected for those values will be kept as is. The same is the case where the threshold has not been reached.

This operation can be specified as being transactional. However, if the caller always rolls back the transaction in the case of a failure, there is no need to specify single operations to be transactional.

Return values

sOKAY	Normal, successful return.
eNOSTARTUPDATE	An update operation was attempted when no rdm_dbStartUpdate() is active.
eNOTLOCKED	Attempt to access a table for reading or update without proper locks.
eCURSORDB	Cursor is associated with a different database.
eDBNOTOPEN	Database not open.
ePRECOMMITTED	A precommitted transaction must be committed or rolled back before further operations on this database are allowed.
eDUPLICATE	Attempt to insert a duplicate value as a unique/primary key.
eREADONLY	Database is read-only and cannot be updated.
eREFINTEGRITY	Integrity constraint violation.
eROWLIMIT	Table row limit reached.
eINVARG	Invalid argument.

Parameters

threshold	[IN] Only flush objects where at least this many elements have been collected
transactional	[IN] Is the flush required to be transactional

 {
RDM_RETCODE rc = sOKAY;


if (n >= threshold && n > 0)
 {
 AGGREGATE_T scaled_aggregate = aggregate;


 agg_scale (n, scaled_aggregate.value_range[0]);


RDM_TRANS trans{};


if (transactional == RDM::DB::TRANSACTIONAL)
 {
 rc = rdm_dbStartUpdate (db, NULL, 0, NULL, 0, &trans);
 }


if (rc == sOKAY)
 {
 rc = next.put_range (&scaled_aggregate, RDM::DB::NOT_TRANSACTIONAL);
if (rc == sOKAY)
 {
 n_just_before_last_flush = n;
 rc = next.flush_range (threshold, RDM::DB::NOT_TRANSACTIONAL);
if (rc == sOKAY)
 {
 n = 0;
 }
else

 {
 next.unput ();
 }
 }
if (transactional == RDM::DB::TRANSACTIONAL)
 {
if (rc == sOKAY)
 {
 rc = rdm_transEnd (trans);
 }
else

 {
rdm_transEndRollback (trans);
 }
 }
 }
 }
else

 {
if (n == 0)
 {
 n_just_before_last_flush = 0;
 }
 rc = next.flush_range (threshold, transactional);
 }


return rc;
 }

References RDM::DB::NOT_TRANSACTIONAL, rdm_dbStartUpdate(), rdm_transEnd(), rdm_transEndRollback(), sOKAY, and RDM::DB::TRANSACTIONAL.

Here is the call graph for this function:

get_serialize_size()

template<uint32_t N, class AGGREGATE_T , class AGG_ELEMENT_T , class NEXT >

constexpr static int RDM::TIME_SERIES::mean< N, AGGREGATE_T, AGG_ELEMENT_T, NEXT >::get_serialize_size ( void )

inlinestaticconstexpr

Get the size of a buffer for serialization to hold its state.

Get the size needed for a buffer to hold the state of this object.

 {
return sizeof(prev_aggregate) + sizeof(aggregate) + sizeof(n) + sizeof(n_just_before_last_put) + sizeof(n_just_before_last_flush) + NEXT::get_serialize_size ();
 }

init()

template<uint32_t N, class AGGREGATE_T , class AGG_ELEMENT_T , class NEXT >

RDM_RETCODE RDM::TIME_SERIES::mean< N, AGGREGATE_T, AGG_ELEMENT_T, NEXT >::init ( RDM_DB p_db )

inline

Initialize this object.

Call this method before sending it any ranges or statistics.

Return values

sOKAY	Normal, successful return.
eINVARG	Invalid argument.
eDBNOTOPEN	Database not open.
eCURSORDB	Cursor is associated with a different database.
ePRECOMMITTED	A precommitted transaction must be committed or rolled back before further operations on this database are allowed.

Parameters

p_db	[IN] Use this database for chained classes that need to insert rows

 {
RDM_RETCODE rc = next.init (p_db);
 n = 0;


return rc;
 }

put_range()

template<uint32_t N, class AGGREGATE_T , class AGG_ELEMENT_T , class NEXT >

template<class SOURCE_AGGREGATE_T >

RDM_RETCODE RDM::TIME_SERIES::mean< N, AGGREGATE_T, AGG_ELEMENT_T, NEXT >::put_range ( SOURCE_AGGREGATE_T * source_range, RDM::DB::TRANSACTIONAL_T transactional = RDM::DB::NOT_TRANSACTIONAL )

inline

Template method for receiving ranges.

Receive one range and process it accordingly.

The type for the value provided is required to have columns for 'time_stamp_first', 'time_stamp_last', and 'value_range' with appropriate types. The column 'value_range' must be an array that is able to hold a static number of elements. Such a type can be generated using rdm-compile with a schema including a table similar to this:

CREATE TABLE range
(
 value_range DOUBLE ARRAY [32] NOT NULL,
 time_stamp_first UINT64 NOT NULL,
 time_stamp_last UINT64 PRIMARY KEY
);

This operation can be specified as being transactional. However, if the caller always rolls back the transaction in the case of a failure, there is no need to specify single operations to be transactional.

Template Parameters

SOURCE_AGGREGATE_T

The actual type of the range received.

Return values

sOKAY	Normal, successful return.
eNOSTARTUPDATE	An update operation was attempted when no rdm_dbStartUpdate() is active.
eNOTLOCKED	Attempt to access a table for reading or update without proper locks.
eCURSORDB	Cursor is associated with a different database.
eDBNOTOPEN	Database not open.
ePRECOMMITTED	A precommitted transaction must be committed or rolled back before further operations on this database are allowed.
eDUPLICATE	Attempt to insert a duplicate value as a unique/primary key.
eREADONLY	Database is read-only and cannot be updated.
eREFINTEGRITY	Integrity constraint violation.
eROWLIMIT	Table row limit reached.
eINVARG	Invalid argument.

Parameters

[in]	source_range	The source range sent to this class
	transactional	[IN] Is the put required to be transactional

 {
RDM_RETCODE rc = sOKAY;


 prev_aggregate = aggregate;


if (n == 0)
 {
 aggregate.time_stamp_first =
 source_range->time_stamp_first;
for (uint32_t i = 0; i < RDM_LEN(aggregate.value_range); i++)
 {
 agg_set (source_range->value_range[i], aggregate.value_range[i]);
 }
 }
else

 {
for (uint32_t i = 0; i < RDM_LEN(aggregate.value_range); i++)
 {
 agg_add (source_range->value_range[i], aggregate.value_range[i]);
 }
 }
 aggregate.time_stamp_last =
 source_range->time_stamp_last;


if (n == N - 1)
 {
 AGGREGATE_T scaled_aggregate = aggregate;


for (uint32_t i = 0; i < RDM_LEN(aggregate.value_range); i++)
 {
 agg_scale (N, scaled_aggregate.value_range[i]);
 }


 rc = next.put_range (&scaled_aggregate, transactional);
if (rc == sOKAY)
 {
 n_just_before_last_put = n;
 n = 0;
 }
else

 {
 aggregate = prev_aggregate;
 }
 }
else

 {
 n++;
 }


return rc;
 }

References RDM_LEN, and sOKAY.

put_value()

template<uint32_t N, class AGGREGATE_T , class AGG_ELEMENT_T , class NEXT >

template<class SOURCE_VALUE_T >

RDM_RETCODE RDM::TIME_SERIES::mean< N, AGGREGATE_T, AGG_ELEMENT_T, NEXT >::put_value ( SOURCE_VALUE_T * source_value, RDM::DB::TRANSACTIONAL_T transactional = RDM::DB::NOT_TRANSACTIONAL )

inline

Template method for receiving a data values.

Receive one data value and return an error.

The type for the value provided is required to have columns for 'time_stamp_current' and 'value_current' with appropriate types. Such a type can be generated using rdm-compile with a schema including a table similar to this:

CREATE TABLE measurement
(
 time_stamp_current UINT64 PRIMARY KEY,
 value_current DOUBLE NOT NULL
);

This operation can be specified as being transactional. However, if the caller always rolls back the transaction in the case of a failure, there is no need to specify single operations to be transactional.

Template Parameters

SOURCE_VALUE_T

The actual type of the source values received

Return values

sOKAY	Normal, successful return.
eNOSTARTUPDATE	An update operation was attempted when no rdm_dbStartUpdate() is active.
eNOTLOCKED	Attempt to access a table for reading or update without proper locks.
eCURSORDB	Cursor is associated with a different database.
eDBNOTOPEN	Database not open.
ePRECOMMITTED	A precommitted transaction must be committed or rolled back before further operations on this database are allowed.
eDUPLICATE	Attempt to insert a duplicate value as a unique/primary key.
eREADONLY	Database is read-only and cannot be updated.
eREFINTEGRITY	Integrity constraint violation.
eROWLIMIT	Table row limit reached.
eINVARG	Invalid argument.

Parameters

[in]	source_value	The source value sent to this class
	transactional	[IN] Is the put required to be transactional

 {
RDM_RETCODE rc = sOKAY;


 prev_aggregate = aggregate;


if (n == 0)
 {
 aggregate.time_stamp_first =
 source_value->time_stamp_current;
 agg_set (source_value->value_current, aggregate.value_range[0]);
 }
else

 {
 agg_add (source_value->value_current, aggregate.value_range[0]);
 }
 aggregate.time_stamp_last =
 source_value->time_stamp_current;


if (n == N - 1)
 {
 AGGREGATE_T scaled_aggregate = aggregate;


 agg_scale (N, scaled_aggregate.value_range[0]);


 rc = next.put_range (&scaled_aggregate, transactional);
if (rc == sOKAY)
 {
 n_just_before_last_put = n;
 n = 0;
 }
else

 {
 aggregate = prev_aggregate;
 }
 }
else

 {
 n++;
 }


return rc;
 }

References sOKAY.

reset()

template<uint32_t N, class AGGREGATE_T , class AGG_ELEMENT_T , class NEXT >

void RDM::TIME_SERIES::mean< N, AGGREGATE_T, AGG_ELEMENT_T, NEXT >::reset ( void )

inline

Reset this object.

Call this method to discard all internally kept data values, ranges, and statistics that have not yet been persisted and start over from scratch.

 {
 next.reset ();
 n = 0;
 }

serialize()

template<uint32_t N, class AGGREGATE_T , class AGG_ELEMENT_T , class NEXT >

uint8_t* RDM::TIME_SERIES::mean< N, AGGREGATE_T, AGG_ELEMENT_T, NEXT >::serialize ( uint8_t * buffer )

inline

 {
 memcpy (buffer, &prev_aggregate, sizeof (prev_aggregate));
 buffer += sizeof (prev_aggregate);
 memcpy (buffer, &aggregate, sizeof (aggregate));
 buffer += sizeof (aggregate);
 memcpy (buffer, &n, sizeof (n));
 buffer += sizeof (n);
 memcpy (buffer, &n_just_before_last_put, sizeof (n_just_before_last_put));
 buffer += sizeof (n_just_before_last_put);
 memcpy (buffer, &n_just_before_last_flush, sizeof (n_just_before_last_flush));
 buffer += sizeof (n_just_before_last_flush);
return next.serialize (buffer);
 }

unserialize()

template<uint32_t N, class AGGREGATE_T , class AGG_ELEMENT_T , class NEXT >

uint8_t* RDM::TIME_SERIES::mean< N, AGGREGATE_T, AGG_ELEMENT_T, NEXT >::unserialize ( uint8_t * buffer )

inline

 {
 memcpy (&prev_aggregate, buffer, sizeof (prev_aggregate));
 buffer += sizeof (prev_aggregate);
 memcpy (&aggregate, buffer, sizeof (aggregate));
 buffer += sizeof (aggregate);
 memcpy (&n, buffer, sizeof (n));
 buffer += sizeof (n);
 memcpy (&n_just_before_last_put, buffer, sizeof (n_just_before_last_put));
 buffer += sizeof (n_just_before_last_put);
 memcpy (&n_just_before_last_flush, buffer, sizeof (n_just_before_last_flush));
 buffer += sizeof (n_just_before_last_flush);
return next.unserialize (buffer);
 }

Friends And Related Function Documentation

collect

template<uint32_t N, class AGGREGATE_T , class AGG_ELEMENT_T , class NEXT >

template<uint32_t ANY_N, class ANY_RANGE_T , class ANY_NEXT >

friend class collect

friend

custom

template<uint32_t N, class AGGREGATE_T , class AGG_ELEMENT_T , class NEXT >

template<class ANY_NEXT >

friend class custom

friend

downsample

template<uint32_t N, class AGGREGATE_T , class AGG_ELEMENT_T , class NEXT >

template<uint32_t ANY_N, class ANY_NEXT >

friend class downsample

friend

fft

template<uint32_t N, class AGGREGATE_T , class AGG_ELEMENT_T , class NEXT >

template<uint32_t ANY_N, class ANY_RANGE_T , class ANY_INDATA_T , class ANY_NEXT >

friend class fft

friend

mean

template<uint32_t N, class AGGREGATE_T , class AGG_ELEMENT_T , class NEXT >

template<uint32_t ANY_N, class ANY_AGGREGATE_T , class ANY_AGG_ELEMENT_T , class ANY_NEXT >

friend class mean

friend

RDM::DB::transaction

template<uint32_t N, class AGGREGATE_T , class AGG_ELEMENT_T , class NEXT >

template<class ANY_NEXT >

friend class RDM::DB::transaction

friend

scale

template<uint32_t N, class AGGREGATE_T , class AGG_ELEMENT_T , class NEXT >

template<class ANY_RATIO , class ANY_NEXT >

friend class scale

friend

split

template<uint32_t N, class AGGREGATE_T , class AGG_ELEMENT_T , class NEXT >

template<class ANY_NEXT_1 , class ANY_NEXT_2 >

friend class split

friend

stats

template<uint32_t N, class AGGREGATE_T , class AGG_ELEMENT_T , class NEXT >

template<uint32_t ANY_N, class ANY_STATS_T , class ANY_NEXT >

friend class stats

friend

---

The documentation for this class was generated from the following files:

• rdm_time_series.h
• rdm_time_series_mean.h