dae.cpp

Go to the documentation of this file.

// dae.cpp : Implementation of Cdae

#include "stdafx.h"
#include "DAEstatus.h"
#include "dae.h"
#include "variant_utils.h"
#include "isisinstrumentcontrol.h"

static Poco::SingletonHolder<InstrumentControlHolder> g_icp_singleton;

static DAEstatus g_status;

// Cdae

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

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

#if 0
// it is not recommended to use AtlReportError() in a catch() hence we have to copy
// ex.what() to a string and use this function
template <class T>
HRESULT reportError(T* obj, const std::string& errmsg)
{
        if (errmsg.empty())
        {
                return S_OK;
        }
        else
        {
                AtlReportError(obj->GetObjectCLSID(), errmsg.c_str()); 
                return E_FAIL;
        }
}
#endif

template <typename T>
HRESULT Cdae::callICP(BSTR* messages, T& result, boost::function<T(ISISinstrumentControl*, DAEstatus&)> func)
{
        DAEstatus status; 
        std::string exc_mess;
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
        }
        else
        {
                ICPCritical cs(m_critical);
                _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
                try
                {
                        status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
                        result = func(the_icp, boost::ref(status));
                }
                catch(const std::exception& ex)
                {
                        exc_mess = ex.what();
                }
                catch(...)
                {
                        exc_mess = "Unknown Win32 exception";
                }
                the_icp->unregisterStructuredExceptionHandler(old_se_func);
        }
        if (exc_mess.size() > 0)
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Exception caught in Cdae::callICP() %s", exc_mess.c_str());
        }
        return makeResult(status, messages);
}

template <typename T> 
HRESULT Cdae::callICP(BSTR* messages, boost::function<T(ISISinstrumentControl*, DAEstatus&)> func)
{
        T icp_result;
        return callICP<T>(messages, icp_result, func);
}

static int getXML(const BSTR xml_in, std::string& xml_out)
{
        int l, n, i;
        l = SysStringLen(xml_in);       // l is length without NULL terminator
        n = WideCharToMultiByte(CP_ACP, 0, xml_in, l, 0, 0, NULL, NULL);
        char* buffer = new char[n+1];
        WideCharToMultiByte(CP_ACP, 0, xml_in, l, buffer, n, NULL, NULL);
        buffer[n] = '\0';
        for(i=0; i<n; i++)
        {
                if (buffer[i] == '\0')
                {
                        buffer[i] = ' '; // labview can put embedded NULLS into this
                }
        }
        xml_out = buffer;
        delete[] buffer;
        return 0;
}

static void getBSTRValue(const BSTR bstr, std::string& str)
{
        char buffer[1024];
        int n = sizeof(buffer) - 1;
    wcstombs(buffer, bstr, n);
        buffer[n] = '\0';
        str = buffer;
}


static int variantToStringTable(VARIANT* v, string_table_t& string_table)
{
        int dims_array[10], ndims, i, j, k;
        dims_array[0] = dims_array[1] = 0;
        BSTR* bstr_array = NULL;
        arrayVariantDimensions(v, dims_array, ndims);
        accessArrayVariant(v, &bstr_array);
        k = 0;
        string_table.resize(dims_array[0]);
        for(i=0; i<dims_array[0]; i++)
        {
                string_table[i].resize(dims_array[1]);
        }
        // the string table from labview appears to have the column index as the fastest varying
        for(j=0; j<dims_array[1]; j++)
        {
                for(i=0; i<dims_array[0]; i++)
                {
                        getBSTRValue(bstr_array[k], string_table[i][j]);
                        k++;
                }
        }
        unaccessArrayVariant(v);
        return 0;
}

STDMETHODIMP Cdae::updateStatusXML(BSTR* cluster_xml, BSTR* messages)
{
        std::string s;
        if (cluster_xml == NULL || *cluster_xml == NULL)
        {
                return E_FAIL;
        }
        getXML(*cluster_xml, s);
        HRESULT hr = callICP<int>(messages, boost::bind(&ISISinstrumentControl::updateStatusXML, _1, boost::ref(s), _2));
        if (SUCCEEDED(hr))
        {
                reallocBSTR(cluster_xml, s.c_str());
        }
        return hr;
}

BSTR Cdae::makeBSTR(const char* str)
{
        BSTR bstr;
        size_t l;
        wchar_t* wbuffer = NULL;
        l = strlen(str);
        if (l > 0)
        {
                wbuffer = new wchar_t[l + 1];
                mbstowcs(wbuffer, str, l+1);
                bstr = SysAllocString(wbuffer);
                delete[] wbuffer;
        }
        else
        {
                bstr = SysAllocString(L"");
        }
        return bstr;
}


int Cdae::reallocBSTR(BSTR* bstr, const char* str)
{
        size_t l;
        wchar_t* wbuffer = NULL;
        l = strlen(str);
        if (l > 0)
        {
                wbuffer = new wchar_t[l + 1];
                mbstowcs(wbuffer, str, l+1);
                SysReAllocString(bstr, wbuffer);
                delete[] wbuffer;
        }
        else
        {
                SysReAllocString(bstr, L"");
        }
        return 0;
}



HRESULT Cdae::makeResult(DAEstatus& status, BSTR* messages, bool force_success_result)
{
        std::ostringstream info_stream, all_stream;
        status.reportAll(all_stream, false, false);
        std::string all_stream_str(all_stream.str());
        if (force_success_result)
        {
                if (all_stream_str.length() > 0)
                {
                        g_status.addInfo(FAC_DAE, all_stream_str);
                }
                status.reportAll(info_stream);
        }
        else
        {
                if (all_stream_str.length() > 0)
                {
                        g_status.add(FAC_DAE, status.severity(), ERRTYPE_OUTOFMEM, all_stream_str);
                }
                status.report(info_stream, SEV_WARNING, SEV_LE);
        }
        std::string info_string(info_stream.str());
        if (messages != NULL)
        {
                *messages = makeBSTR(info_string.c_str());
        }
        if (status.OK())
        {
                return S_OK;
        }
        else
        {
                std::ostringstream error_stream;
                status.report(error_stream, SEV_ERROR, SEV_GE);
                std::string error_string(error_stream.str());
                return AtlReportError(GetObjectCLSID(), error_string.c_str(), __uuidof(Idae));
        }
}

STDMETHODIMP Cdae::beginRun(BSTR* messages)
{
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::beginRun, _1, _2));
}

STDMETHODIMP Cdae::endRun(BSTR* messages)
{
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::endRun, _1, _2));
}

STDMETHODIMP Cdae::pauseRun(BSTR* messages)
{
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::pauseRun, _1, _2));
}

STDMETHODIMP Cdae::resumeRun(BSTR* messages)
{
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::resumeRun, _1, _2));
}

STDMETHODIMP Cdae::saveRun(BSTR* messages)
{
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::saveRun, _1, _2));
}

STDMETHODIMP Cdae::abortRun(BSTR* messages)
{
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::abortRun, _1, _2));
}

STDMETHODIMP Cdae::startSEWait(BSTR* messages)
{
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::startSEWait, _1, _2));
}

STDMETHODIMP Cdae::endSEWait(BSTR* messages)
{
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::endSEWait, _1, _2));
}

STDMETHODIMP Cdae::getSpectrum(LONG spectrum_number, LONG period, VARIANT* time_channels, VARIANT* signal, LONG as_histogram, LONG as_distribution, LONG* sum, BSTR* messages)
{
        // TODO: Add your implementation code here
        int dims_array[1];
        DAEstatus status;
        VariantInit(time_channels);
        VariantInit(signal);
        double *time_array = 0, *signal_array = 0, *error_array=0;
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                return makeResult(status, messages);
        }
        ICPCritical cs(m_critical);
        _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
        status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
        int ntc = the_icp->getNumberOfTimeChannels(spectrum_number, status);
        dims_array[0] = ntc;
        allocateArrayVariant(signal, VT_R8, dims_array, 1);
        if (as_histogram)
        {
                dims_array[0] = ntc+1;
        }
        allocateArrayVariant(time_channels, VT_R8, dims_array, 1);
        accessArrayVariant(time_channels, &time_array);
        accessArrayVariant(signal, &signal_array);
        if ( (time_array == 0) || (signal_array == 0) )
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                the_icp->unregisterStructuredExceptionHandler(old_se_func);
                return makeResult(status, messages);
        }
        error_array = new double[ntc];
        the_icp->getSpectrum(spectrum_number, period-1, time_array, signal_array, error_array,
                                 (as_histogram != 0 ? true : false), (as_distribution != 0 ? true : false), *sum, status);
        delete[] error_array;
        unaccessArrayVariant(signal);
        unaccessArrayVariant(time_channels);
        the_icp->unregisterStructuredExceptionHandler(old_se_func);
        return makeResult(status, messages);
}

STDMETHODIMP Cdae::changeTCB(BSTR tcb_xml, BSTR* messages)
{
        std::string s;
        getXML(tcb_xml, s);
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::updateTCBXML, _1, boost::cref(s), _2));
}

STDMETHODIMP Cdae::changeDAEsettings(BSTR dae_xml, BSTR* messages)
{
        std::string s;
        getXML(dae_xml, s);
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::updateDAEsettingsXML, _1, boost::cref(s), _2));
}

STDMETHODIMP Cdae::getSpectrumIntegral(LONG spectrum_number, LONG period, FLOAT time_low, FLOAT time_high, LONG* counts, BSTR* messages)
{
        DAEstatus status;
        long max_val;
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                return makeResult(status, messages);
        }
        ICPCritical cs(m_critical);
        _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
        status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
        the_icp->getSpectrumIntegral(spectrum_number, period-1, time_low, time_high, *counts, max_val, status);
        the_icp->unregisterStructuredExceptionHandler(old_se_func);
        return makeResult(status, messages);
}


HRESULT Cdae::getSpectraIntegralHelper(spec_int_func_t func, VARIANT spectrum_numbers, LONG period, VARIANT time_low, VARIANT time_high, VARIANT* counts, BSTR* messages)
{
        DAEstatus status;
        VariantInit(counts);
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                return makeResult(status, messages);
        }
        ICPCritical cs(m_critical);
        _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
        status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
        float *tlow, *thigh;
        long *spec, *cnts;
        int dims_array[1];
        dims_array[0] = arrayVariantLength(&spectrum_numbers);
        long* max_vals = new long[dims_array[0]];
        allocateArrayVariant(counts, VT_I4, dims_array, 1);
        accessArrayVariant(counts, &cnts);
        accessArrayVariant(&time_low, &tlow);
        accessArrayVariant(&time_high, &thigh);
        accessArrayVariant(&spectrum_numbers, &spec);

        (the_icp->*func)(dims_array[0], spec, period-1, tlow, thigh, cnts, max_vals, status);
        unaccessArrayVariant(counts);
        unaccessArrayVariant(&time_low);
        unaccessArrayVariant(&time_high);
        unaccessArrayVariant(&spectrum_numbers);
        delete[] max_vals;
        the_icp->unregisterStructuredExceptionHandler(old_se_func);
        return makeResult(status, messages);
}

STDMETHODIMP Cdae::getSpectraIntegral(VARIANT spectrum_numbers, LONG period, VARIANT time_low, VARIANT time_high, VARIANT* counts, BSTR* messages)
{
        return getSpectraIntegralHelper(&ISISinstrumentControl::getSpectrumIntegral, spectrum_numbers, period, time_low, time_high, counts, messages);
}

STDMETHODIMP Cdae::getSpectraIntegral2(LONG spec_start, LONG nspectra, LONG period, FLOAT time_low, FLOAT time_high, VARIANT* counts, BSTR* messages)
{
        DAEstatus status;
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                return makeResult(status, messages);
        }
        ICPCritical cs(m_critical);
        _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
        VariantInit(counts);
        int dims_array[1];
        long* cnts = NULL;
        dims_array[0] = nspectra;
        allocateArrayVariant(counts, VT_I4, dims_array, 1);
        accessArrayVariant(counts, &cnts);
        status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
// this is not ready yet
//      if (time_low >= time_high)
//      {
//              the_icp->getCRPTSpectrumIntegral(spec_start, nspectra, period-1, cnts, status); 
//      }
//      else
//      {
                the_icp->getCRPTSpectrumIntegral(spec_start, nspectra, period-1, time_low, time_high, cnts, NULL, status); 
//      }
//      HRESULT hr = callICP<int>(messages, boost::bind(&ISISinstrumentControl::getCRPTSpectrumIntegral, _1, spec_start, nspectra, period-1, time_low, time_high, cnts, NULL, _2));
        unaccessArrayVariant(counts);
        the_icp->unregisterStructuredExceptionHandler(old_se_func);
        return makeResult(status, messages);
}


STDMETHODIMP Cdae::getsect(LONG start, LONG length, VARIANT* values, BSTR* messages)
{
        DAEstatus status;
        VariantInit(values);
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                return makeResult(status, messages);
        }
        ICPCritical cs(m_critical);
        _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
        status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
        int dims_array[1];
        dims_array[0] = length;
        long* vals = 0;
        allocateArrayVariant(values, VT_I4, dims_array, 1);
        accessArrayVariant(values, &vals);
//      the_icp->getsect(start, length, vals);
        unaccessArrayVariant(values);
        the_icp->unregisterStructuredExceptionHandler(old_se_func);
        return makeResult(status, messages);
}

STDMETHODIMP Cdae::rio(LONG address, LONG* value, BSTR* messages)
{
        // TODO: Add your implementation code here
        DAEstatus status;
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                return makeResult(status, messages);
        }
        isisU16_t word;
        ICPCritical cs(m_critical);
        _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
        status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
        the_icp->RIO(address, word, status);
        *value = word;
        the_icp->unregisterStructuredExceptionHandler(old_se_func);
        return makeResult(status, messages);
}


STDMETHODIMP Cdae::getValue(BSTR name, BSTR* messages, VARIANT* result)
{
        int i;
        char item_name[64];
        DAEstatus status;
        VariantInit(result); 
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                return makeResult(status, messages);
        }
        ICPCritical cs(m_critical);
        _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
        status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
        wcstombs(item_name, name, sizeof(item_name));
        for(i=0; i<strlen(item_name); i++)
        {
                item_name[i] = toupper(item_name[i]);
        }
    getValueMain(the_icp, item_name, result, status);
        the_icp->unregisterStructuredExceptionHandler(old_se_func);
        return makeResult(status, messages);
}

int Cdae::getArrayValueMain(ISISinstrumentControl* the_icp, const char* item_name, long args[], int nargs, VARIANT* result, DAEstatus& status)
{
//      std::string cvalue;
        char* item_temp;
        const char* name_temp;
        double* darray = 0;
        long* larray = 0;
        VARIANT* varray = 0;
        int i, n, ndims, dims_array[10];
        if (strchr(item_name,',') != NULL)
        {
                dims_array[0] = 1;
                for(i=0; i<strlen(item_name); i++)
                {
                        if (item_name[i] == ',')
                        {
                                ++dims_array[0];
                        }
                }
                allocateArrayVariant(result, VT_VARIANT, dims_array, 1);
                accessArrayVariant(result, &varray);
                item_temp = strdup(item_name);
                name_temp = strtok(item_temp, ",");
                n = 0;
                while(name_temp != NULL)
                {
                        getArrayValueMain(the_icp, name_temp, args, nargs, varray + n, status);
                        name_temp = strtok(NULL, ",");
                        n++;
                }
                free(item_temp);
                // clean up end of array in case strtok and dims_array[0] disagree
                // this should only happen if e.g. ",,," is specified as the initial
                // count will give this a 3 by == but strtok() will only see 1
                if (n < dims_array[0])
                {
                        for(i=n; i<dims_array[0]; i++)
                        {
                                VariantInit(varray + i);
                        }
                }
                unaccessArrayVariant(result);
                return 0;
        }
        if (the_icp->getIntItem(item_name, result->lVal, status) == DAEstatus::Success)
        {
                allocateArrayVariant(result, VT_I4, &nargs, 1);
                accessArrayVariant(result, &larray);
                the_icp->getIntItem(item_name, args, nargs, larray, status);
                unaccessArrayVariant(result);
        }
        else if (the_icp->getRealItem(item_name, result->dblVal, status) == DAEstatus::Success)
        {
                allocateArrayVariant(result, VT_R8, &nargs, 1);
                accessArrayVariant(result, &darray);
                the_icp->getRealItem(item_name, args, nargs, darray, status);
                unaccessArrayVariant(result);
        }
        // use dims_array+1 as C has fastest varying stuff at the end and we need to set
        // num_spectra as the slowest varying index
        else if (the_icp->getIntArrayItemSize(item_name, &dims_array[1], ndims, status) == DAEstatus::Success)
        {
                dims_array[0] = nargs;
                ndims++;
                allocateArrayVariant(result, VT_I4, dims_array, ndims);
                accessArrayVariant(result, &larray);
                the_icp->getIntArrayItem(item_name, args, nargs, larray, status);
                unaccessArrayVariant(result);
        }
        // use dims_array+1 as C has fastest varying stuff at the end and we need to set
        // num_spectra as the slowest varying index
        else if (the_icp->getRealArrayItemSize(item_name, &dims_array[1], ndims, status) == DAEstatus::Success)
        {
                dims_array[0] = nargs;
                ndims++;
                allocateArrayVariant(result, VT_R8, dims_array, ndims);
                accessArrayVariant(result, &darray);
                the_icp->getRealArrayItem(item_name, args, nargs, darray, status);
                unaccessArrayVariant(result);
        }
        else
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Item \"%s\" not found", item_name);
        }
        return 0;
}

int Cdae::getValueMain(ISISinstrumentControl* the_icp, const char* item_name, VARIANT* result, DAEstatus& status)
{
        char* item_temp;
        const char* name_temp;
        double* darray = 0;
        long* larray = 0;
        VARIANT* varray = 0;
        int i, n, ndims, dims_array[10];
        if (strchr(item_name,',') != NULL)
        {
                dims_array[0] = 1;
                for(i=0; i<strlen(item_name); i++)
                {
                        if (item_name[i] == ',')
                        {
                                ++dims_array[0];
                        }
                }
                allocateArrayVariant(result, VT_VARIANT, dims_array, 1);
                accessArrayVariant(result, &varray);
                item_temp = strdup(item_name);
                name_temp = strtok(item_temp, ",");
                n = 0;
                while(name_temp != NULL)
                {
                        getValueMain(the_icp, name_temp, varray + n, status);
                        name_temp = strtok(NULL, ",");
                        n++;
                }
                free(item_temp);
                // clean up end of array in case strtok and dims_array[0] disagree
                // this should only happen if e.g. ",,," is specified as the initial
                // count will give this a 3 by == but strtok() will only see 1
                if (n < dims_array[0])
                {
                        for(i=n; i<dims_array[0]; i++)
                        {
                                VariantInit(varray + i);
                        }
                }
                unaccessArrayVariant(result);
                return 0;
        }
        std::string cvalue;
        if (the_icp->getIntItem(item_name, result->lVal, status) == DAEstatus::Success)
        {
                result->vt = VT_I4;
        }
        else if (the_icp->getRealItem(item_name, result->dblVal, status) == DAEstatus::Success)
        {
                result->vt = VT_R8;
        }
        else if (the_icp->getIntArrayItemSize(item_name, dims_array, ndims, status) == DAEstatus::Success)
        {
                allocateArrayVariant(result, VT_I4, dims_array, ndims);
                accessArrayVariant(result, &larray);
                the_icp->getIntArrayItem(item_name, larray, status);
                unaccessArrayVariant(result);
        }
        else if (the_icp->getRealArrayItemSize(item_name, dims_array, ndims, status) == DAEstatus::Success)
        {
                allocateArrayVariant(result, VT_R8, dims_array, ndims);
                accessArrayVariant(result, &darray);
                the_icp->getRealArrayItem(item_name, darray, status);
                unaccessArrayVariant(result);
        }
        else if (the_icp->getCharItem(item_name, cvalue, status) == DAEstatus::Success)
        {
                CComBSTR b(cvalue.c_str());
                b.CopyTo(result);
        }
        else
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "Item \"%s\" not found", item_name);
        }
        return 0;
}

STDMETHODIMP Cdae::getRawFramesTotal(BSTR* messages, LONG* value)
{
        return callICP<LONG>(messages, *value, boost::bind(&ISISinstrumentControl::getRawFrames, _1, _2)); 
}

STDMETHODIMP Cdae::getGoodFramesTotal(BSTR* messages, LONG* value)
{
        return callICP<LONG>(messages, *value, boost::bind(&ISISinstrumentControl::getGoodFrames, _1, _2)); 
}

STDMETHODIMP Cdae::getGoodUAmpH(BSTR* messages, DOUBLE* value)
{
        return callICP<DOUBLE>(messages, *value, boost::bind(&ISISinstrumentControl::getGoodUAmpH, _1, _2)); 
}

STDMETHODIMP Cdae::getSpectraSum(LONG period, LONG first_spec, LONG num_spec, LONG spec_type, DOUBLE time_low, DOUBLE time_high, VARIANT* sums, VARIANT* max_vals, VARIANT* spec_nums, BSTR* messages)
{
        DAEstatus status;
        int j;
        VariantInit(sums);
        VariantInit(max_vals);
        VariantInit(spec_nums);
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                return makeResult(status, messages);
        }
        ICPCritical cs(m_critical);
        _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
        status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
        long *cnts, *maxs, *nums;
        int nsp = the_icp->getNumberOfSpectra(status);
        int nspec = num_spec;
        allocateArrayVariant(sums, VT_I4, &nspec, 1);
        allocateArrayVariant(max_vals, VT_I4, &nspec, 1);
        allocateArrayVariant(spec_nums, VT_I4, &nspec, 1);
        accessArrayVariant(sums, &cnts);
        accessArrayVariant(max_vals, &maxs);
        accessArrayVariant(spec_nums, &nums);
        j = 0;
        int spec = first_spec;
        while(j < num_spec)
        {
                if (spec > nsp)
                {
                        cnts[j] = maxs[j] = 0;
                        nums[j] = -1;
                        j++;
                }
                else
                {
                        the_icp->getSpectrumIntegral(spec, period-1, time_low, time_high, cnts[j], maxs[j], status);
                        if (  (spec_type == 0)                     || // show all spectra
                         ((spec_type == 1) && (cnts[j] == 0))  || // zero counts only
                             ((spec_type == 2) && (cnts[j] > 0))      // non-zero counts only
                        )
                        {
                                nums[j] = spec;
                                j++;
                        }
                }
                spec++;
        }
        unaccessArrayVariant(sums);
        unaccessArrayVariant(max_vals);
        unaccessArrayVariant(spec_nums);
        the_icp->unregisterStructuredExceptionHandler(old_se_func);
        return makeResult(status, messages);
}

STDMETHODIMP Cdae::changeSample(BSTR sample_xml, BSTR* messages)
{
        std::string s;
        getXML(sample_xml, s);
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::updateSampleXML, _1, boost::cref(s), _2));
}

STDMETHODIMP Cdae::changeUser(BSTR user_xml, BSTR* messages)
{
        std::string s;
        getXML(user_xml, s);
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::updateUserXML, _1, boost::cref(s), _2));
}

STDMETHODIMP Cdae::changeHardwarePeriods(BSTR periods_xml, BSTR* messages)
{
        std::string s;
        getXML(periods_xml, s);
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::updateHardwarePeriodsXML, _1, boost::cref(s), _2));
}

STDMETHODIMP Cdae::changePeriod(LONG period_number, BSTR* messages)
{
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::changePeriod, _1, period_number - 1, _2));
}

STDMETHODIMP Cdae::dumpDebugInfo(BSTR* messages)
{
        DAEstatus status;
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                return makeResult(status, messages);
        }
        std::ostringstream os;
        ICPCritical cs(m_critical);
        _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
        the_icp->printStatus(os, status);
        status.addInfo(FAC_DAE, os.str());
        the_icp->unregisterStructuredExceptionHandler(old_se_func);
        return makeResult(status, messages, true);
}

STDMETHODIMP Cdae::VMEWriteValue(ULONG card_id, ULONG card_address, ULONG word_size, ULONG value, ULONG mode, BSTR* messages)
{
        DAEstatus status;
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                return makeResult(status, messages);
        }
        bool sixteen_bit = (word_size == 0);
        ICPCritical cs(m_critical);
        _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
        status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
        the_icp->VMEWriteValue(card_id, card_address, sixteen_bit, value, mode, status);
        the_icp->unregisterStructuredExceptionHandler(old_se_func);
        return makeResult(status, messages);
}

STDMETHODIMP Cdae::VMEReadValue(ULONG card_id, ULONG card_address, ULONG word_size, ULONG* value, BSTR* messages)
{
        DAEstatus status;
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                return makeResult(status, messages);
        }
        bool sixteen_bit = (word_size == 0);
        ICPCritical cs(m_critical);
        _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
        status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
        the_icp->VMEReadValue(card_id, card_address, sixteen_bit, value, status);
        the_icp->unregisterStructuredExceptionHandler(old_se_func);
        return makeResult(status, messages);
}

STDMETHODIMP Cdae::sumAllSpectra(LONG* counts, LONG* bin0_counts, BSTR* messages)
{
        // TODO: Add your implementation code here
        DAEstatus status;
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                return makeResult(status, messages);
        }
        ICPCritical cs(m_critical);
        _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
        status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
        the_icp->sumAllSpectra(*counts, *bin0_counts, status);
        the_icp->unregisterStructuredExceptionHandler(old_se_func);
        return makeResult(status, messages);
}

STDMETHODIMP Cdae::sumAllHistogramMemory(LONG* counts, BSTR* messages)
{
        DAEstatus status;
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                return makeResult(status, messages);
        }
        ICPCritical cs(m_critical);
        _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
        status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
        the_icp->sumAllHistogramMemory(*counts, status);
        the_icp->unregisterStructuredExceptionHandler(old_se_func);
        return makeResult(status, messages);
}

STDMETHODIMP Cdae::VMEReadArray(ULONG card_id, ULONG card_address, VARIANT* values, ULONG num_values, BSTR* messages)
{
        long* rv;
        int dims_array[1];
        DAEstatus status;
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                return makeResult(status, messages);
        }
        ICPCritical cs(m_critical);
        _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
        status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
        VariantInit(values);
        dims_array[0] = num_values;
        allocateArrayVariant(values, VT_I4, dims_array, 1);
        accessArrayVariant(values, &rv);
        the_icp->VMEReadArray(card_id, card_address, (isisU32_t*)rv, num_values, status);
        unaccessArrayVariant(values);
        the_icp->unregisterStructuredExceptionHandler(old_se_func);
        return makeResult(status, messages);
}

STDMETHODIMP Cdae::VMEWriteArray(ULONG card_id, ULONG card_address, VARIANT values, BSTR* messages)
{
        DAEstatus status;
        int num_values;
        long* rv;
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                return makeResult(status, messages);
        }
        ICPCritical cs(m_critical);
        _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
        status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
        accessArrayVariant(&values, &rv);
        num_values = arrayVariantLength(&values);
        the_icp->VMEWriteArray(card_id, card_address, (isisU32_t*)rv, num_values, status);
        the_icp->unregisterStructuredExceptionHandler(old_se_func);
        return makeResult(status, messages);
}

STDMETHODIMP Cdae::VMEReadValuesToString(ULONG card_id, ULONG card_address, ULONG word_size, ULONG num_values, BSTR* values, BSTR* messages)
{
        DAEstatus status;
        std::string str_values;
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                return makeResult(status, messages);
        }
        bool sixteen_bit = (word_size == 0);
        ICPCritical cs(m_critical);
        _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
        status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
        the_icp->VMEReadValuesToString(card_id, card_address, sixteen_bit, num_values, str_values, status);
        *values = makeBSTR(str_values.c_str());
//      status.addInfo(FAC_DAE, str_values);
        the_icp->unregisterStructuredExceptionHandler(old_se_func);
        return makeResult(status, messages);
}

STDMETHODIMP Cdae::refreshCachedValues(BSTR* messages)
{
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::refreshCachedValues, _1, _2));
}

STDMETHODIMP Cdae::setOptions(BSTR options_xml, BSTR* messages)
{
        std::string s;
        getXML(options_xml, s);
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::setOptions, _1, boost::cref(s), _2));
}

STDMETHODIMP Cdae::getOptions(BSTR* options_xml, BSTR* messages)
{
        if (options_xml == NULL || *options_xml == NULL)
        {
                return E_FAIL;
        }
        std::string s;
        getXML(*options_xml, s);
        HRESULT hr = callICP<int>(messages, boost::bind(&ISISinstrumentControl::getOptions, _1, boost::ref(s), _2));
        reallocBSTR(options_xml, s.c_str());
        return hr;
}

STDMETHODIMP Cdae::getArrayValue(BSTR name, VARIANT arg, BSTR* messages, VARIANT* result)
{
        int i;
        char item_name[64];
        DAEstatus status;
        VariantInit(result); 
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                return makeResult(status, messages);
        }
        ICPCritical cs(m_critical);
        _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
        status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
        wcstombs(item_name, name, sizeof(item_name));
        for(i=0; i<strlen(item_name); i++)
        {
                item_name[i] = toupper(item_name[i]);
        }
        long* larray = NULL;
        int n = arrayVariantLength(&arg);
        accessArrayVariant(&arg, &larray);
        if (larray != NULL)
        {
                getArrayValueMain(the_icp, item_name, larray, n, result, status);
        }
        unaccessArrayVariant(&arg);
        the_icp->unregisterStructuredExceptionHandler(old_se_func);
        return makeResult(status, messages);
}

STDMETHODIMP Cdae::updateCRPT(BSTR* messages)
{
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::updateCRPTWithDAE, _1, false, _2));
}

STDMETHODIMP Cdae::storeCRPT(BSTR* messages)
{
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::storeCRPT, _1, _2));
}

STDMETHODIMP Cdae::setICPValueLong(BSTR name, LONG value, BSTR* messages)
{
        char item_name[128];
        DAEstatus status;
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
        }
        else
        {
                ICPCritical cs(m_critical);
                _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
                status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
                wcstombs(item_name, name, sizeof(item_name));
                if (!stricmp(item_name, "RUN_NUMBER"))
                {
                        the_icp->setRunNumber(value, status);
                }
                if (!stricmp(item_name, "RUN_STATUS"))
                {
                        the_icp->setRunStatus(value, status);
                }
                the_icp->unregisterStructuredExceptionHandler(old_se_func);
        }
        return makeResult(status, messages);
}

STDMETHODIMP Cdae::notifyICP(LONG event_id, BSTR param, BSTR* messages)
{
    char notify_param[256];
        wcstombs(notify_param, param, sizeof(notify_param));
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::notifyICP, _1, event_id, notify_param, _2));
}

STDMETHODIMP Cdae::setBlocksTable(VARIANT table, BSTR* messages)
{
        string_table_t string_table;
        variantToStringTable(&table, string_table);
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::setBlockTable, _1, boost::cref(string_table), _2));
}

STDMETHODIMP Cdae::setSampleParameters(VARIANT table, BSTR* messages)
{
        string_table_t string_table;
        variantToStringTable(&table, string_table);
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::setSampleParameters, _1, boost::cref(string_table), _2));
}

STDMETHODIMP Cdae::setBeamlineParameters(VARIANT table, BSTR* messages)
{
        string_table_t string_table;
        variantToStringTable(&table, string_table);
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::setBeamlineParameters, _1, boost::cref(string_table), _2));
}

STDMETHODIMP Cdae::setUserParameters(LONG rbno, VARIANT table, BSTR* messages)
{
        string_table_t string_table;
        variantToStringTable(&table, string_table);
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::setUserParameters, _1, rbno, boost::cref(string_table), _2));
}

STDMETHODIMP Cdae::areYouThere(void)
{
        HRESULT ret;
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                ret = E_FAIL;
        }
        else
        {
                ret = S_OK;
        }
        return ret;
}

STDMETHODIMP Cdae::changeUpdateSettings(BSTR update_xml, BSTR* messages)
{
        std::string s;
        getXML(update_xml, s);
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::changeUpdateSettingsXML, _1, boost::cref(s), _2));
}

STDMETHODIMP Cdae::getNPRatio(FLOAT* current, FLOAT* average, BSTR* messages)
{
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::getNPRatio, _1, current, average, _2));
}

STDMETHODIMP Cdae::getTotalCounts(BSTR* messages, LONG* counts)
{
        int64_t counts64 = 0;
        HRESULT hr = callICP<int>(messages, boost::bind(&ISISinstrumentControl::getTotalCounts, _1, boost::ref(counts64), _2));
        if ( counts64 < std::numeric_limits<LONG>::max() )
        {
                *counts = static_cast<LONG>(counts64);
        }
        else
        {
                *counts = std::numeric_limits<LONG>::max();
        }
        return hr;
}

STDMETHODIMP Cdae::getMEvents(BSTR* messages, DOUBLE* mevents)
{
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::getMEvents, _1, boost::ref(*mevents), _2));
}

STDMETHODIMP Cdae::getMEventsPeriod(LONG period, BSTR* messages, DOUBLE* mevents)
{
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::getMEventsPeriod, _1, boost::ref(*mevents), period - 1, _2));
}

STDMETHODIMP Cdae::getCurrentPeriodNumber(LONG* period, LONG* daq_period, BSTR* messages)
{
        int p, dp;
        HRESULT hr = callICP<int>(messages, boost::bind(&ISISinstrumentControl::getCurrentPeriodNumber, _1, boost::ref(p), boost::ref(dp), _2));
        *period = p + 1;
        *daq_period = dp + 1;
        return hr;
}

STDMETHODIMP Cdae::snapshotCRPT(BSTR filename, LONG do_update, LONG do_pause, BSTR* messages)
{
        char fname[256];
        wcstombs(fname, filename, sizeof(fname));
        NULL_TERMINATE(fname);
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::snapshotCRPT, _1, fname, (do_update != 0), (do_pause != 0), _2)); 
}

STDMETHODIMP Cdae::changePeriodWhileRunning(LONG period, LONG pause_first, BSTR* messages)
{
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::changePeriodWhileRunning, _1, period-1, (pause_first != 0), _2)); 
}

HRESULT Cdae::getSettings(BSTR xml_in, BSTR* xml_out, BSTR* messages, xml_get_func_t func)
{
        *xml_out = NULL;
        std::string xml_s_in, xml_s_out;
        getXML(xml_in, xml_s_in);
        HRESULT hr = callICP<int>(messages, boost::bind(func, _1, boost::cref(xml_s_in), boost::ref(xml_s_out), _2)); 
//              std::string xml_s_out_unescaped = unescapeXML(xml_s_out.c_str());
//              *xml_out = makeBSTR(xml_s_out_unescaped.c_str());
        if (SUCCEEDED(hr))
        {
                *xml_out = makeBSTR(xml_s_out.c_str());
        }
        return hr;
}

HRESULT Cdae::updateSettings(BSTR xml_in, BSTR* messages, xml_set_func_t func)
{
        std::string xml_s;
        getXML(xml_in, xml_s);
        return callICP<int>(messages, boost::bind(func, _1, boost::cref(xml_s), _2)); 
}


STDMETHODIMP Cdae::getDAEsettings(BSTR dae_xml_in, BSTR* dae_xml_out, BSTR* messages)
{
        return getSettings(dae_xml_in, dae_xml_out, messages, &ISISinstrumentControl::getDAEsettingsXML);
}

STDMETHODIMP Cdae::getHardwarePeriods(BSTR periods_xml_in, BSTR* periods_xml_out, BSTR* messages)
{
        return getSettings(periods_xml_in, periods_xml_out, messages, &ISISinstrumentControl::getHardwarePeriodsXML);
}

STDMETHODIMP Cdae::getTCB(BSTR tcb_xml_in, BSTR* tcb_xml_out, BSTR* messages)
{
        return getSettings(tcb_xml_in, tcb_xml_out, messages, &ISISinstrumentControl::getTCBXML);
}

STDMETHODIMP Cdae::getUpdateSettings(BSTR update_xml_in, BSTR* update_xml_out, BSTR* messages)
{
        return getSettings(update_xml_in, update_xml_out, messages, &ISISinstrumentControl::getUpdateSettingsXML);
}

STDMETHODIMP Cdae::changeNumberOfSoftwarePeriods(LONG nperiod, BSTR* messages)
{
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::changeNumberOfSoftwarePeriods, _1, nperiod, _2)); 
}

STDMETHODIMP Cdae::getRunState(BSTR* messages, LONG* state)
{
        DAEstatus status;
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                return makeResult(status, messages);
        }
        ICPCritical cs(m_critical);
        _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
        status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
        *state = the_icp->getRunState();
        the_icp->unregisterStructuredExceptionHandler(old_se_func);
        return makeResult(status, messages);
}

STDMETHODIMP Cdae::beginRunEx(LONG options, LONG period, BSTR* messages)
{
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::beginRunEx, _1, ((options & 0x1) != 0), ((options & 0x2) != 0), period - 1, _2)); 
}

STDMETHODIMP Cdae::fillWithTestPattern(ULONG pattern, BSTR* messages)
{
        DAEstatus status;
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
        }
        else
        {
                ICPCritical cs(m_critical);
                _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
                status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
                the_icp->fillWithTestPattern(pattern, status);
                the_icp->unregisterStructuredExceptionHandler(old_se_func);
        }
        return makeResult(status, messages);
}

STDMETHODIMP Cdae::getVetoStatus(BSTR* veto_status, BSTR* messages)
{
        DAEstatus status;
        time_t timer;
        std::string veto_text1, veto_text2;
        char time_stamp[128];
        *veto_status = NULL;
        HRESULT hr = callICP<int>(messages, boost::bind(&ISISinstrumentControl::getVetoStatus, _1, boost::ref(veto_text1), _2));
        if (SUCCEEDED(hr))
        {
                hr = callICP<int>(messages, boost::bind(&ISISinstrumentControl::whichVeto, _1, boost::ref(veto_text2), _2));
        }
        time(&timer);
        strftime(time_stamp, sizeof(time_stamp), "Last Updated: %H:%M:%S", localtime(&timer));
        *veto_status = makeBSTR((veto_text1 + "\n" + veto_text2 + "\n" + time_stamp).c_str());
        return hr;
}

STDMETHODIMP Cdae::loadDAEWithData(BSTR file_name, LONG options, BSTR* messages)
{
        std::string fname;
        getBSTRValue(file_name, fname);
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::loadDAEWithData, _1, boost::cref(fname), options, _2));
}

STDMETHODIMP Cdae::setVeto(BSTR name, LONG enable, BSTR* messages)
{
        std::string veto_name;
        getBSTRValue(name, veto_name);
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::setVeto, _1, boost::cref(veto_name), enable, _2));
}

STDMETHODIMP Cdae::checkTestPattern(ULONG pattern, BSTR* messages)
{
        DAEstatus status;
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
        }
        else
        {
                ICPCritical cs(m_critical);
                _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
                status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
                the_icp->checkTestPattern(pattern, status);
                the_icp->unregisterStructuredExceptionHandler(old_se_func);
        }
        return makeResult(status, messages);
}

STDMETHODIMP Cdae::getRunNumber(BSTR* messages, LONG* run_number)
{
        DAEstatus status;
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                return makeResult(status, messages);
        }
        ICPCritical cs(m_critical);
        _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
        status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
        *run_number = the_icp->getRunNumber();
        the_icp->unregisterStructuredExceptionHandler(old_se_func);
        return makeResult(status, messages);
}

STDMETHODIMP Cdae::changeMonitoringSettings(BSTR monitor_xml, BSTR* messages)
{
        return updateSettings(monitor_xml, messages, &ISISinstrumentControl::updateMonitoringXML);
}

STDMETHODIMP Cdae::getMonitoringSettings(BSTR monitor_xml_in, BSTR* monitor_xml_out, BSTR* messages)
{
        return getSettings(monitor_xml_in, monitor_xml_out, messages, &ISISinstrumentControl::getMonitoringXML);
}


struct report_struct
{
        int i;
        int n;
        BSTR* messages_bstr;
        report_struct() : i(0), n(0), messages_bstr(NULL) {}
        report_struct(BSTR* messages, int _n) : i(0), n(_n), messages_bstr(messages) {}
};

static int status_reporter(const DAEstatus_message& mess, void* arg)
{
        report_struct* rs = (report_struct*)arg;
        if (rs->i < rs->n)
        {
                rs->messages_bstr[rs->i] = Cdae::makeBSTR(mess.str().c_str());
                ++(rs->i);
        }
        return 0;
}

STDMETHODIMP Cdae::getStatusMessages(LONG stream, VARIANT* messages)
{
        VariantInit(messages);
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                return S_OK;
        }
        int dims_array[1] = { 0 };
        if (g_status.size() == 0)
        {
                allocateArrayVariant(messages, VT_BSTR, dims_array, 1);
                return S_OK;
        }
        ICPCritical cs(m_critical);
        dims_array[0] = g_status.size();   // need to get this after ICPcritical created to be sure of correct value
        allocateArrayVariant(messages, VT_BSTR, dims_array, 1);
        BSTR* messages_bstr = NULL;
        accessArrayVariant(messages, &messages_bstr);
        report_struct rs(messages_bstr, dims_array[0]);
        bool stat_ok = g_status.OK();   // make note as reportAll() will clear this
        g_status.reportAll(status_reporter, &rs);
        unaccessArrayVariant(messages);
        if (stat_ok)
        {
                return S_OK;
        }
        else
        {
//              status.report(error_stream, SEV_ERROR, SEV_GE);
//              error_string = error_stream.str();
//              return AtlReportError(GetObjectCLSID(), error_string.c_str(), __uuidof(Idae));
                return S_OK;
        }
}


STDMETHODIMP Cdae::getGoodFramesPeriod(BSTR* messages, LONG* value)
{
        return callICP<LONG>(messages, *value, boost::bind(&ISISinstrumentControl::getCurrentPeriodGoodFrames, _1, _2));
}

STDMETHODIMP Cdae::getGoodUAmpHPeriod(BSTR* messages, DOUBLE* value)
{
        return callICP<DOUBLE>(messages, *value, boost::bind(&ISISinstrumentControl::getCurrentPeriodGoodUAmpH, _1, _2));
}

STDMETHODIMP Cdae::getFramesAllPeriods(VARIANT* good_frames, VARIANT* raw_frames, BSTR* messages)
{
        int nper = 1;
        HRESULT hr = callICP<int>(messages, nper, boost::bind(&ISISinstrumentControl::getNumberOfPeriods, _1, _2));
        if (FAILED(hr))
        {
                return hr;
        }
        int dims_array[1] = { nper };
        allocateArrayVariant(good_frames, VT_I4, dims_array, 1);
        allocateArrayVariant(raw_frames, VT_I4, dims_array, 1);
        long* good = NULL;
        long* raw = NULL;
        accessArrayVariant(good_frames, &good);
        accessArrayVariant(raw_frames, &raw);
        hr = callICP<int>(messages, boost::bind(&ISISinstrumentControl::getFramesAllPeriods, _1, good, raw, nper, _2));
        unaccessArrayVariant(good_frames);
        unaccessArrayVariant(raw_frames);
        return hr;
}

STDMETHODIMP Cdae::getUAmpHAllPeriods(VARIANT* good_uamph, VARIANT* raw_uamph, BSTR* messages)
{
        int nper = 1;
        HRESULT hr = callICP<int>(messages, nper, boost::bind(&ISISinstrumentControl::getNumberOfPeriods, _1, _2));
        if (FAILED(hr))
        {
                return hr;
        }
        int dims_array[1] = { nper };
        allocateArrayVariant(good_uamph, VT_R4, dims_array, 1);
        allocateArrayVariant(raw_uamph, VT_R4, dims_array, 1);
        float* good = NULL;
        float* raw = NULL;
        accessArrayVariant(good_uamph, &good);
        accessArrayVariant(raw_uamph, &raw);
        hr = callICP<int>(messages, boost::bind(&ISISinstrumentControl::getUAmpHAllPeriods, _1, good, raw, nper, _2));
        unaccessArrayVariant(good_uamph);
        unaccessArrayVariant(raw_uamph);
        return hr;
}

void Cdae::registerICPCallbacks()
{
 // ISISinstrumentControl* the_icp = g_icp_singleton.get();  // not sure we want to do this from FinalConstruct() - may delay DCOM registration?
 //     m_connection.push_back(the_icp->registerOnRunStateChange(boost::bind(&Cdae::Fire_OnRunStateChange, this, _1)));
}

void Cdae::unregisterICPCallbacks()
{
//      BOOST_FOREACH(boost::signals2::connection conn, m_connection)
//      {
//              conn.disconnect();
//      }
//      m_connection.clear();
}

CRITICAL_SECTION* Cdae::m_critical = NULL;



STDMETHODIMP Cdae::updateCRPTSpectra(LONG period, LONG spec_start, LONG nspec, BSTR* messages)
{
        return callICP<int>(messages, boost::bind(static_cast<int(ISISinstrumentControl::*)(int,long,int,DAEstatus&)>(&ISISinstrumentControl::updateCRPTSpectra), _1, period - 1, spec_start, nspec, _2));
}

STDMETHODIMP Cdae::getCRPTSpectraIntegral(VARIANT spectrum_numbers, LONG period, VARIANT time_low, VARIANT time_high, VARIANT* counts, BSTR* messages)
{
        return getSpectraIntegralHelper(&ISISinstrumentControl::getCRPTSpectrumIntegral, spectrum_numbers, period, time_low, time_high, counts, messages);
}


STDMETHODIMP Cdae::quit(BSTR* messages)
{
        DAEstatus status;
        ISISinstrumentControl* the_icp = g_icp_singleton.get();
        if (the_icp == NULL)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "ICP is NULL");
                return makeResult(status, messages);
        }
        ICPCritical cs(m_critical);
        _se_translator_function old_se_func = the_icp->registerStructuredExceptionHandler();
        status.setReportCopyFunction(&ISISinstrumentControl::allReportFunc, the_icp);
        the_icp->exitProgram("", false);
        the_icp->unregisterStructuredExceptionHandler(old_se_func);
        return makeResult(status, messages);
}


STDMETHODIMP Cdae::requestEndRunAfterNextSequenceCompletes(BSTR* messages)
{
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::requestEndRunAfterNextSequenceCompletes, _1, _2));
}


STDMETHODIMP Cdae::isFinalSequenceComplete(BSTR* messages, LONG* complete)
{
        bool is_complete = false;
        HRESULT hr = callICP<bool>(messages, is_complete, boost::bind(&ISISinstrumentControl::isFinalSequenceComplete, _1, _2));
        *complete = (is_complete ? 1 : 0);
        return hr;
}


STDMETHODIMP Cdae::getSpectrumNumbersForTR(LONG time_regime, LONG* spec_min, LONG* spec_max, BSTR* messages)
{
        return callICP<int>(messages, boost::bind(&ISISinstrumentControl::getSpectrumNumbersForTimeRegime, _1, time_regime, boost::ref(*spec_min), boost::ref(*spec_max), _2));
}


STDMETHODIMP Cdae::getNumberOfPeriods(BSTR* messages, LONG* nperiod)
{
        return callICP<LONG>(messages, *nperiod, boost::bind(&ISISinstrumentControl::getNumberOfPeriods, _1, _2));
}


STDMETHODIMP Cdae::updateStatusXML2(BSTR status_xml_in, BSTR* status_xml_out, BSTR* messages)
{
        *status_xml_out = CComBSTR(status_xml_in).Detach();
    return updateStatusXML(status_xml_out, messages);
}