selogger.h

Go to the documentation of this file.

// The following ifdef block is the standard way of creating macros which make exporting 
// from a DLL simpler. All files within this DLL are compiled with the SELOGGER_EXPORTS
// symbol defined on the command line. this symbol should not be defined on any project
// that uses this DLL. This way any other project whose source files include this file see 
// SELOGGER_API functions as being imported from a DLL, whereas this DLL sees symbols
// defined with this macro as being exported.

#ifndef SELOGGER_H
#define SELOGGER_H

#ifdef SELOGGER_EXPORTS
#define SELOGGER_API __declspec(dllexport)
#else
#define SELOGGER_API __declspec(dllimport)
#endif

//#include "ci_string.h"

enum BlockOptions { Enabled=0x1, RunControl=0x2, LogAtBegin=0x4, LogAtEnd=0x8 };

#include <Poco/Tuple.h>

typedef Poco::Tuple<std::string, std::string, std::string, std::string, 
                                               std::string, std::string, int, std::string, 
                                                                                   float, float, std::string, std::string,
                                                                                   int, std::string, std::string, std::string> SEBLOCK_DETAILS_tuple;

class SEBLOCK_DETAILS : public SEBLOCK_DETAILS_tuple
{
public:
        SEBLOCK_DETAILS_tuple& tuple() { return *this; }
        std::string& block_name() { return this->get<0>(); }
        std::string& setpoint_value() { return this->get<1>(); }
        std::string& vi_name() { return this->get<2>(); }
        std::string& read_control() { return this->get<3>(); }
        std::string& set_control() { return this->get<4>(); }
        std::string& button_control() { return this->get<5>(); }
        int& options() { return this->get<6>(); }
        std::string& nexus_name() { return this->get<7>(); }
        float& low_limit() { return this->get<8>(); }
        float& high_limit() { return this->get<9>(); }
        std::string& units() { return this->get<10>(); }
        std::string& block_value() { return this->get<11>(); }
        int& is_real() { return this->get<12>(); }
        std::string& source() { return this->get<13>(); }
        std::string& setpoint_time() { return this->get<14>(); }
        std::string& value_time() { return this->get<15>(); }
        SEBLOCK_DETAILS(const std::string& block_name, const std::string& setpoint_value, 
                const std::string& vi_name, const std::string& read_control, const std::string& set_control,
                const std::string& button_control, int options, const std::string& nexus_name, 
                float low_limit, float high_limit, const std::string& units, const std::string& block_value,
                int is_real, const std::string& source, const std::string& setpoint_time, const std::string& value_time)
                : SEBLOCK_DETAILS_tuple(block_name, setpoint_value, vi_name, read_control, set_control,
                      button_control, options, nexus_name, low_limit, high_limit, units, block_value,
                          is_real, source, setpoint_time, value_time)
        {
        }
        SEBLOCK_DETAILS() : SEBLOCK_DETAILS_tuple()
        {
        }
        SEBLOCK_DETAILS(const SEBLOCK_DETAILS& block) : SEBLOCK_DETAILS_tuple(block)
        {
        }
        SEBLOCK_DETAILS& operator=(const SEBLOCK_DETAILS& block)
        {
                if (this != &block)
                {
                        SEBLOCK_DETAILS_tuple::operator=(block);
                }
                return *this;
        }
};

struct SEBLOCK
{
        time_t ref_time;
        std::vector<std::string> setpoint_value; 
        std::vector<float> fsetpoint_value; 
        std::vector<float> fsetpoint_spread; 
        std::string vi_name;
        std::string read_control;
        std::string set_control;
        std::string button_control;
        unsigned options;
        std::string nexus_name;
        float low_limit;
        float high_limit;
        std::string units;
        std::vector<std::string> current_value;  
        std::vector<float> fcurrent_value;  
        std::vector<float> fcurrent_spread;  
        bool is_real;

        std::vector<float> time;
        std::vector<float> fvalues;
        std::vector<std::string> svalues;
        SEBLOCK() : ref_time(0), is_real(false), options(0), nexus_name(""), low_limit(0.0), high_limit(0.0) {}
};

struct RUNBLOCK
{
        time_t ref_time;
        std::vector<float> time;
        std::vector<int> period;
        std::vector<int> run_status;
        std::vector<int> is_running;
        std::vector<int> is_waiting;
        std::vector<int> good_frames;
        std::vector<int> raw_frames;
        std::vector<float> good_uamps;
        std::vector<float> raw_uamps;
        std::vector<int64_t> monitor1_sum;
        std::vector<float> dae_beam_current;
        std::vector<int64_t> total_counts;
        std::vector<float> count_rate;
        std::vector<float> np_ratio;
        RUNBLOCK() : ref_time(0) {}
};

struct epics_thread_data_t
{
        int* run_number;
        char* inst_name;
        char* lastread_iso;
        unsigned lastread_nano;
};

typedef std::map<std::string, SEBLOCK> seblock_map_t;

// all routines return 0 on success, -1 on error
// if there is an error, call   se_get_errmsg()  to retrieve the text of the error message
//
// the database is opened automatically on a   se_log_value()
// if possible you should call   se_close()  during a shutdown
extern "C" {
        SELOGGER_API int __stdcall se_log_value(long run_number, const char* source, const char* iso_time, const char* block_name, const char* block_value);
        SELOGGER_API int __stdcall se_start_epics_thread(epics_thread_data_t* arg);

        SELOGGER_API int __stdcall se_close();

        SELOGGER_API const char* __stdcall se_get_errmsg();

        SELOGGER_API int __stdcall se_set_block_details(const char* block_name, const char* setpoint_value, 
                const char* vi_name, const char* read_control_label, const char* set_control_label, const char* button_control_label, 
                unsigned options, const char* nexus_name, float low_limit, float high_limit, 
                const char* units, const char* current_value);


        SELOGGER_API int __stdcall se_get_block_details(const char* block_name, SEBLOCK_DETAILS& details);

        SELOGGER_API int __stdcall se_new_seci_config(const char* config_name);

        SELOGGER_API int __stdcall se_log_run(int run_number, const char* source, const char* iso_time, int period,
                                int run_status, int is_running, int is_waiting,
                                int good_frames, int raw_frames, 
                                float good_uamph, float raw_uamph,
                        int64_t monitor_sum0, float dae_beam_current, int64_t total_counts,
                                float count_rate, float npratio_current);

        SELOGGER_API int __stdcall se_get_num_blocks();

        SELOGGER_API int __stdcall se_get_seci_config(std::string& seci_config);

        SELOGGER_API int __stdcall se_set_block_value(const char* block_name, const char* block_value);

        SELOGGER_API int __stdcall se_get_blocks(int run_number, time_t ref_time, seblock_map_t& blocks);

        SELOGGER_API int __stdcall se_get_run_status(int run_number, time_t ref_time, RUNBLOCK& blocks);

        SELOGGER_API int __stdcall se_set_run_state(int run_number, const char* state, int is_start);

        SELOGGER_API int __stdcall se_set_run_state_async(int run_number, const char* state, int is_start);

        SELOGGER_API int __stdcall se_set_run_number(int run_number);

        SELOGGER_API int __stdcall se_set_period(int period);

        SELOGGER_API int __stdcall se_set_period_async(int period);

        SELOGGER_API int __stdcall se_new_measurement(const char* label, std::string& res);

        SELOGGER_API int __stdcall se_get_measurement_label(const char* measurement_id, std::string& res);

        SELOGGER_API int __stdcall se_set_measurement_label(const char* measurement_id, const char* label);

        SELOGGER_API int __stdcall se_get_measurement_id(const char* label, std::string& measurement_id);

        SELOGGER_API int __stdcall se_clear_values(int run_start, int run_finish);

        SELOGGER_API int __stdcall se_profile(const char* filename);

        SELOGGER_API int __stdcall se_log_values(long run_number, const char* source, const std::vector<std::string>& iso_times, const std::vector<std::string>& block_names, const std::vector<std::string>& block_values);

        SELOGGER_API int __stdcall se_log_fvalues(long run_number, const char* source, const std::vector<std::string>& iso_times, const std::vector<std::string>& block_names, const std::vector<float>& block_values);

        SELOGGER_API int __stdcall se_set_block_values(const std::vector<std::string>& block_names, const std::vector<std::string>& block_values);

        SELOGGER_API int __stdcall se_log_value_async(long run_number, const char* source, const char* iso_time, const char* block_name, const char* block_value);

        SELOGGER_API int __stdcall se_log_values_async(long run_number, const char* source, const std::vector<std::string>& iso_times, const std::vector<std::string>& block_names, const std::vector<std::string>& block_values);

        SELOGGER_API int __stdcall se_wait_for_async();

        SELOGGER_API int __stdcall se_get_measurement_first_run(const char* measurement_id, long& run_number);

        SELOGGER_API int __stdcall se_get_block_values(seblock_map_t& blocks);

        SELOGGER_API int __stdcall se_set_block_setpoint(const char* block_name, const char* block_setpoint);

        SELOGGER_API int __stdcall se_set_block_setpoints(const std::vector<std::string>& block_names, const std::vector<std::string>& block_setpoints);

        SELOGGER_API const char* __stdcall se_version(); 

        SELOGGER_API int __stdcall se_get_values(long run_number, const char* source, const char* block_name, std::vector<std::string>& iso_times, std::vector<std::string>& block_values);

        SELOGGER_API int __stdcall se_exec_sql(const char* sql, std::string& result);
};

#endif /* SELOGGER_H */