selog.cpp

Go to the documentation of this file.

// selog.cpp : Implementation of Cselog

#include "stdafx.h"
#include "selog.h"
#include "..\selogger\selogger.h"


// Cselog

STDMETHODIMP Cselog::InterfaceSupportsErrorInfo(REFIID riid)
{
        static const IID* arr[] = 
        {
                &IID_Iselog
        };

        for (int i=0; i < sizeof(arr) / sizeof(arr[0]); i++)
        {
                if (InlineIsEqualGUID(*arr[i],riid))
                        return S_OK;
        }
        return S_FALSE;
}

STDMETHODIMP Cselog::SELogValue(LONG run_number, BSTR source, BSTR iso_time, BSTR block_name, BSTR block_value)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState());
        COLE2CT c_source(source), c_iso_time(iso_time), c_block_name(block_name), c_block_value(block_value);
        if (se_log_value(run_number, c_source, c_iso_time, c_block_name, c_block_value) == 0)
        {
                return S_OK;
        }
        else
        {
                return AtlReportError(GetObjectCLSID(), se_get_errmsg());
        }
}

STDMETHODIMP Cselog::SEClose(void)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState());
        if (se_close() == 0)
        {
                return S_OK;
        }
        else
        {
                return AtlReportError(GetObjectCLSID(), se_get_errmsg());
        }
}

STDMETHODIMP Cselog::SENewSECIConfig(BSTR config_name)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState());
        COLE2CT config_name_c(config_name);
        if (se_new_seci_config(config_name_c) == 0)
        {
                return S_OK;
        }
        else
        {
                return AtlReportError(GetObjectCLSID(), se_get_errmsg());
        }
}

STDMETHODIMP Cselog::SESetBlockValue(BSTR block_name, BSTR block_value)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState());
        COLE2CT block_name_c(block_name), block_value_c(block_value);
        if (se_set_block_value(block_name_c, block_value_c) == 0)
        {
                return S_OK;
        }
        else
        {
                return AtlReportError(GetObjectCLSID(), se_get_errmsg());
        }
}

STDMETHODIMP Cselog::SESetBlockDetails(BSTR block_name, BSTR setpoint_value, BSTR vi_name, 
                                                                           BSTR read_control_label, BSTR set_control_label, 
                                                                           BSTR button_control_label, LONG options, BSTR nexus_name, 
                                                                           FLOAT low_limit, FLOAT high_limit, BSTR units, BSTR current_value)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState());
        if (se_set_block_details(COLE2CT(block_name), COLE2CT(setpoint_value), 
                COLE2CT(vi_name), COLE2CT(read_control_label), COLE2CT(set_control_label), 
                COLE2CT(button_control_label), (BlockOptions)options, COLE2CT(nexus_name), 
                low_limit, high_limit, COLE2CT(units), COLE2CT(current_value)) == 0)
        {
                return S_OK;
        }
        else
        {
                return AtlReportError(GetObjectCLSID(), se_get_errmsg());
        }
}

STDMETHODIMP Cselog::SENewMeasurement(BSTR label, BSTR* id)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState());
        std::string id_s;
        *id = NULL;
        if (se_new_measurement(COLE2CT(label), id_s) == 0)
        {
                CComBSTR bstr_wrapper(id_s.c_str());
                *id = bstr_wrapper.Detach();
                return S_OK;
        }
        else
        {
                return AtlReportError(GetObjectCLSID(), se_get_errmsg());
        }
}

STDMETHODIMP Cselog::SEGetMeasurementLabel(BSTR id, BSTR* label)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState());
        std::string label_s;
        *label = NULL;
        if (se_get_measurement_label(COLE2CT(id), label_s) == 0)
        {
                CComBSTR bstr_wrapper(label_s.c_str());
                *label = bstr_wrapper.Detach();
                return S_OK;
        }
        else
        {
                return AtlReportError(GetObjectCLSID(), se_get_errmsg());
        }
}

#include "variant_utils.h"

static int build_string_vector(VARIANT& v, std::vector<std::string>& sv)
{
        BSTR* bstr_values = NULL;
        VARIANT* variant_values = NULL;
        int n = arrayVariantLength(&v);
// we could get an array of BSTR or an array of variants
        if (accessArrayVariant(&v, &bstr_values) != 0)
        {
                accessArrayVariant(&v, &variant_values);
        }
        // use resize() rather than reserve() so we get n blank items and [i] reference is valid
        sv.resize(n);
        for(int i=0; i<n; i++)
        {
                if (bstr_values != NULL)
                {
                        sv[i] = COLE2CT(bstr_values[i]);
                }
                else if (variant_values != NULL)
                {
                        sv[i] = COLE2CT(variant_values[i].bstrVal);
                }
        }
        unaccessArrayVariant(&v);
        return 0;
}

STDMETHODIMP Cselog::SESetBlockValues(VARIANT block_names, VARIANT block_values)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState());
        std::vector<std::string> names_list;
        std::vector<std::string> values_list;
        build_string_vector(block_names, names_list);
        build_string_vector(block_values, values_list);
        if (se_set_block_values(names_list, values_list) == 0)
        {
                return S_OK;
        }
        else
        {
                return AtlReportError(GetObjectCLSID(), se_get_errmsg());
        }
}

STDMETHODIMP Cselog::SELogValues(LONG run_number, BSTR source, VARIANT iso_times, VARIANT block_names, VARIANT block_values)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState());
        std::vector<std::string> names_list;
        std::vector<std::string> values_list;
        std::vector<std::string> times_list;
        build_string_vector(block_names, names_list);
        build_string_vector(block_values, values_list);
        build_string_vector(iso_times, times_list);
        if (se_log_values(run_number, COLE2CT(source), times_list, names_list, values_list) == 0)
        {
                return S_OK;
        }
        else
        {
                return AtlReportError(GetObjectCLSID(), se_get_errmsg());
        }
}

STDMETHODIMP Cselog::SEGetMeasurementID(BSTR label, BSTR* measurement_id)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState());
        std::string id_s;
        *measurement_id = NULL;
        if (se_get_measurement_id(COLE2CT(label), id_s) == 0)
        {
                CComBSTR bstr_wrapper(id_s.c_str());
                *measurement_id = bstr_wrapper.Detach();
                return S_OK;
        }
        else
        {
                return AtlReportError(GetObjectCLSID(), se_get_errmsg());
        }
}

STDMETHODIMP Cselog::SESetMeasurementLabel(BSTR measurement_id, BSTR label)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState());
        if (se_set_measurement_label(COLE2CT(measurement_id), COLE2CT(label)) == 0)
        {
                return S_OK;
        }
        else
        {
                return AtlReportError(GetObjectCLSID(), se_get_errmsg());
        }
        return S_OK;
}

STDMETHODIMP Cselog::SESetBlockSetpoint(BSTR block_name, BSTR block_setpoint)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState());
        COLE2CT block_name_c(block_name), block_setpoint_c(block_setpoint);
        if (se_set_block_setpoint(block_name_c, block_setpoint_c) == 0)
        {
                return S_OK;
        }
        else
        {
                return AtlReportError(GetObjectCLSID(), se_get_errmsg());
        }
        return S_OK;
}


STDMETHODIMP Cselog::SESetBlockSetpoints(VARIANT block_names, VARIANT block_setpoints)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState());
        std::vector<std::string> names_list;
        std::vector<std::string> setpoints_list;
        build_string_vector(block_names, names_list);
        build_string_vector(block_setpoints, setpoints_list);
        if (se_set_block_setpoints(names_list, setpoints_list) == 0)
        {
                return S_OK;
        }
        else
        {
                return AtlReportError(GetObjectCLSID(), se_get_errmsg());
        }
}

STDMETHODIMP Cselog::SEGetSECIConfig(BSTR* seci_config)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState());
        std::string seci_config_s;
        *seci_config = NULL;
        if (se_get_seci_config(seci_config_s) == 0)
        {
                CComBSTR bstr_wrapper(seci_config_s.c_str());
                *seci_config = bstr_wrapper.Detach();
                return S_OK;
        }
        else
        {
                return AtlReportError(GetObjectCLSID(), se_get_errmsg());
        }
}


STDMETHODIMP Cselog::SELogValuesAsync(LONG run_number, BSTR source, VARIANT iso_times, VARIANT block_names, VARIANT block_values)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState());
        std::vector<std::string> names_list;
        std::vector<std::string> values_list;
        std::vector<std::string> times_list;
        build_string_vector(block_names, names_list);
        build_string_vector(block_values, values_list);
        build_string_vector(iso_times, times_list);
        if (se_log_values_async(run_number, COLE2CT(source), times_list, names_list, values_list) == 0)
        {
                return S_OK;
        }
        else
        {
                return AtlReportError(GetObjectCLSID(), se_get_errmsg());
        }
}


STDMETHODIMP Cselog::SEGetValues(LONG run_number, BSTR source, BSTR block_name, VARIANT* iso_times, VARIANT* block_values)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState());
        std::vector<std::string> block_values_v;
        std::vector<std::string> iso_times_v;
        if (se_get_values(run_number, COLE2CT(source), COLE2CT(block_name), iso_times_v, block_values_v) != 0)
        {
                return AtlReportError(GetObjectCLSID(), se_get_errmsg());
        }
        makeVariantFromArray(iso_times, iso_times_v);
        makeVariantFromArray(block_values, block_values_v);
        return S_OK;
}


STDMETHODIMP Cselog::SEClearLoggedValues(LONG run_number)
{
        AFX_MANAGE_STATE(AfxGetStaticModuleState());
        if (se_clear_values(run_number, run_number) != 0)
        {
                return AtlReportError(GetObjectCLSID(), se_get_errmsg());
        }
        return S_OK;
}


STDMETHODIMP Cselog::SEExecSQL(BSTR sql, BSTR* result)
{
        std::string result_s;
        AFX_MANAGE_STATE(AfxGetStaticModuleState());
        *result = NULL;
        if (se_exec_sql(COLE2CT(sql), result_s) == 0)
        {
                CComBSTR bstr_wrapper(result_s.c_str());
                *result = bstr_wrapper.Detach();
                return S_OK;
        }
        else
        {
                return AtlReportError(GetObjectCLSID(), se_get_errmsg());
        }
}