RepCheckReq does not actually process the repository but rather check each sample for compliance with some requirment, and adjust the sample's corresponding attribute. More...

#include <RepProcess.h>

Inheritance diagram for RepCheckReq:

Public Member Functions
	RepCheckReq ()
	constructor

int	init (map< string, string > &mapper)

void	set_signal_ids (MedSignals &sigs)
	Set signal id.

void	init_lists ()
	Fill req- and aff-signals vectors.

void	init_tables (MedDictionarySections &dict, MedSignals &sigs)
	initialize time-nits

void	init_attributes ()
	Init attributes information : Should be implemented for inheriting classes that have attributes.

int	_apply (PidDynamicRec &rec, vector< int > &time_points, vector< vector< float > > &attributes_mat)
	apply processing on a single PidDynamicRec at a set of time-points : Should be implemented for all inheriting classes

Public Member Functions inherited from RepProcessor
virtual void	clear ()

virtual int	init (void *params)
	initialize from a params object : Should be implemented for inheriting classes that have parameters

virtual void	init_defaults ()
	initialize to default values : Should be implemented for inheriting classes that have parameters

virtual void	set_signal (const string &_signalName)
	set signal-name : Should be implemented for inheriting classes that have signalName

virtual void	get_required_signal_names (unordered_set< string > &signalNames)
	Append required signal names to set : parent function just uses req_signals.

virtual void	get_required_signal_names (unordered_set< string > &signalNames, unordered_set< string > preReqSignals)
	Append required signal names to set only if processor is actually required to produce any of preReqSignals : parent function just uses req_signals.

virtual void	set_required_signal_ids (MedDictionarySections &dict)
	Fill req_signal_ids : parent function just fills from req_signals.

virtual void	add_virtual_signals (map< string, int > &_virtual_signals, map< string, string > &_virtual_signals_generic) const
	rep processors CREATING virtual signals need to implement this: adding their signals to the pile

virtual void	get_required_signal_ids (unordered_set< int > &signalIds)
	Append required signal names to set : parent function just uses req_signals.

virtual void	get_required_signal_ids (unordered_set< int > &signalIds, unordered_set< int > preReqSignals)
	Append required signal names to set only if processor is actually required to produce any of preReqSignals : parent function just uses req_signals.

virtual void	set_affected_signal_ids (MedDictionarySections &dict)
	Fill aff_signal_ids : parent function just fills from aff_signals.

bool	is_signal_affected (int signalId)
	Check if a signal is affected by processor </summray> Returns true if affected, false if not

bool	is_signal_affected (string &signalName)

virtual void	fit_for_repository (MedPidRepository &rep)
	make changes to RepProcessor according to available signals in Repository

virtual void	register_virtual_section_name_id (MedDictionarySections &dict)
	Register section id to section name of new virtual signals.

virtual bool	filter (unordered_set< string > &reqSignals)
	Check if processor (and 'sub'-processors within) should be applied according to set of required signals </summray> Returns true if processor is not required and can be filtered, false otherwise

virtual int	_learn (MedPidRepository &rep, MedSamples &samples, vector< RepProcessor * > &prev_processors)
	learn processing model on a subset of samples. Apply set of preceeding processors on DynamicPidRec before learning :

virtual int	_conditional_learn (MedPidRepository &rep, MedSamples &samples, vector< RepProcessor * > &prev_processors, unordered_set< int > &neededSignalIds)
	learn processing model on a subset of samples only if required. Apply set of preceeding processors on DynamicPidRec before learning :

int	learn (MedPidRepository &rep, MedSamples &samples, vector< RepProcessor * > &prev_processors)
	learn processing model on a subset of ids. Apply set of preceeding processors on DynamicPidRec before learning

int	learn (MedPidRepository &rep)
	learn on all pids in repository, using fake samples - works only for repProcessors that ignore sample dates

int	learn (MedPidRepository &rep, MedSamples &samples)
	learn on subset of samples without preceesing processors

virtual int	conditional_learn (MedPidRepository &rep, MedSamples &samples, vector< RepProcessor * > &prev_processors, unordered_set< int > &neededSignalIds)
	learn processing model on a subset of samples only if required. Apply set of preceeding processors on DynamicPidRec before learning :

int	conditional_learn (MedPidRepository &rep, MedSamples &samples, unordered_set< int > &neededSignalIds)
	learn processing model on a subset of ids only if required without preceesing processors

virtual int	_conditional_apply (PidDynamicRec &rec, vector< int > &time_points, unordered_set< int > &neededSignalIds, vector< vector< float > > &attributes_vals)
	apply processing on a single PidDynamicRec at a set of time-points only if required : May be implemented for inheriting classes

virtual int	_apply_simple (PidDynamicRec &rec, vector< int > &time_points)

int	apply (PidDynamicRec &rec, vector< int > &time_points, vector< vector< float > > &attributes_vals)
	apply processing on a single PidDynamicRec at a set of time-points

int	conditional_apply (PidDynamicRec &rec, vector< int > &time_points, unordered_set< int > &neededSignalIds, vector< vector< float > > &attributes_vals)
	apply processing on a single PidDynamicRec at a set of time-points only if required : if any of the signals in neededSignalIds is actually affected by processor

int	apply (PidDynamicRec &rec, MedIdSamples &samples)
	apply processing on a single PidDynamicRec at a set of time-points given by samples

int	conditional_apply (PidDynamicRec &rec, MedIdSamples &samples, unordered_set< int > &neededSignalIds)
	apply processing on a single PidDynamicRec at a set of time-points given by samples only if required

int	conditional_apply_without_attributes (PidDynamicRec &rec, const MedIdSamples &samples, unordered_set< int > &neededSignalIds)
	apply processing on a single PidDynamicRec at a set of time-points given by samples only if required, not affecting attributes

virtual void	dprint (const string &pref, int rp_flag)
	used for debug prints, each inheriting class can overload this one to get a more precise debug print.

virtual void	make_summary ()

virtual void	get_required_signal_categories (unordered_map< string, vector< string > > &signal_categories_in_use) const
	returns for each used signal it's used categories

void *	new_polymorphic (string derived_class_name)
	for polymorphic classes that want to be able to serialize/deserialize a pointer * to the derived class given its type one needs to implement this function to return a new to the derived class given its type (as in my_type)

size_t	get_processor_size ()
	get size of processor + processor_type

size_t	processor_serialize (unsigned char *blob)
	seialize processor + processor_type

virtual void	print ()
	optional printing of processor

Public Member Functions inherited from SerializableObject
virtual int	version () const
	Relevant for serializations.

virtual string	my_class_name () const
	For better handling of serializations it is highly recommended that each SerializableObject inheriting class will implement the next method.

virtual void	serialized_fields_name (vector< string > &field_names) const
	The names of the serialized fields.

virtual void	pre_serialization ()

virtual void	post_deserialization ()

virtual size_t	get_size ()
	Gets bytes sizes for serializations.

virtual size_t	serialize (unsigned char *blob)
	Serialiazing object to blob memory. return number ob bytes wrote to memory.

virtual size_t	deserialize (unsigned char *blob)
	Deserialiazing blob to object. returns number of bytes read.

size_t	serialize_vec (vector< unsigned char > &blob)

size_t	deserialize_vec (vector< unsigned char > &blob)

virtual size_t	serialize (vector< unsigned char > &blob)

virtual size_t	deserialize (vector< unsigned char > &blob)

virtual int	read_from_file (const string &fname)
	read and deserialize model

virtual int	write_to_file (const string &fname)
	serialize model and write to file

virtual int	read_from_file_unsafe (const string &fname)
	read and deserialize model without checking version number - unsafe read

int	init_from_string (string init_string)
	Init from string.

int	init_params_from_file (string init_file)

int	init_param_from_file (string file_str, string &param)

int	update_from_string (const string &init_string)

virtual int	update (map< string, string > &map)
	Virtual to update object from parsed fields.

virtual string	object_json () const

Data Fields
vector< string >	signalNames
	Required signals.

vector< int >	signalIds
	Required signals ids.

vector< int >	time_channels
	signals' time channels

int	win_from = 0

int	win_to = 0
	window to consider ;

int	window_time_unit = MedTime::Days
	window time-unit

string	attrName = "MissingReq"
	attribute name (set to 1 if compliant)

vector< int >	sig_time_units

Data Fields inherited from RepProcessor
RepProcessorTypes	processor_type = REP_PROCESS_LAST
	type of repository processor

unordered_set< string >	req_signals
	names of signals required for processsing

unordered_set< int >	req_signal_ids
	ids of signals required for processing

unordered_set< string >	aff_signals
	names of signals affected by processing

unordered_set< int >	aff_signal_ids
	ids of signals affected by processing

bool	unconditional = false
	indicated that processor should ALWAYS be applied

vector< string >	attributes
	attributes generated by the processor (optional)

vector< pair< string, int > >	virtual_signals
	virtual signals are created only in rep processors but can be used by any rep processor that comes after or any feture generator as a regular signal.

vector< pair< string, string > >	virtual_signals_generic

Additional Inherited Members
Static Public Member Functions inherited from RepProcessor
static RepProcessor *	make_processor (string name)
	create a new repository processor from name

static RepProcessor *	make_processor (string type, string params)
	create a new repository processor from name and a parameters string

static RepProcessor *	make_processor (RepProcessorTypes type)
	create a new repository processor from type

static RepProcessor *	make_processor (RepProcessorTypes type, string params)
	create a new repository processor from type and a parameters string

static RepProcessor *	create_processor (string &params)
	create a new repository processor from parameters string which contains rp_type

Detailed Description

RepCheckReq does not actually process the repository but rather check each sample for compliance with some requirment, and adjust the sample's corresponding attribute.

Currently, possible minimal requirements are -

Given a set of signals and a time window, return how many signals do not appear within the window prior to the sample time

Member Function Documentation

◆ _apply()

int RepCheckReq::_apply	(	PidDynamicRec &	rec,
		vector< int > &	time_points,
		vector< vector< float > > &	attributes_mat
	)

virtual

apply processing on a single PidDynamicRec at a set of time-points : Should be implemented for all inheriting classes

Reimplemented from RepProcessor.

◆ init()

int RepCheckReq::init ( map< string, string > & mapper )

virtual

        if (field == "signals")
            boost::split(signalNames, entry.second, boost::is_any_of(","));
        else if (field == "time_channels")
        {
            vector<string> channels;
            boost::split(channels, entry.second, boost::is_any_of(","));
            for (string &channel : channels)
                time_channels.push_back(stoi(channel));
        }
        else if (field == "time_unit")
            window_time_unit = med_time_converter.string_to_type(entry.second);
        else if (field == "win_from")
            win_from = med_stoi(entry.second);
        else if (field == "win_to")
            win_to = med_stoi(entry.second);
        else if (field == "attr")
            attrName = entry.second;

[RepCheckReq::init]

Reimplemented from RepProcessor.

◆ init_attributes()

void RepCheckReq::init_attributes ( )

inlinevirtual

Init attributes information : Should be implemented for inheriting classes that have attributes.

Reimplemented from RepProcessor.

◆ init_tables()

void RepCheckReq::init_tables	(	MedDictionarySections &	dict,
		MedSignals &	sigs
	)

virtual

initialize time-nits

Reimplemented from RepProcessor.

◆ set_signal_ids()

void RepCheckReq::set_signal_ids ( MedSignals & sigs )

virtual

Set signal id.

Reimplemented from RepProcessor.

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

Internal/MedProcessTools/MedProcessTools/RepProcess.h
Internal/MedProcessTools/MedProcessTools/RepProcess.cpp

Public Member Functions

Data Fields

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ _apply()

◆ init()

◆ init_attributes()

◆ init_tables()

◆ set_signal_ids()