instapi_lib.cpp

Go to the documentation of this file.

// instapi_lib.cpp : Defines the exported functions for the DLL application.
//

// instapi.cpp : Implementation of Cinstapi
#include <time.h>
#include "stdafx.h"
#include "instapi_lib.h"
#include "atlsafe.h"
#include <iostream>
#include "../selogger/selogger.h"
#include "../comutils/variant_utils.h"


// Cinstapi

//#import "progid:isisicp.Idae" named_guids
#import "..\\isisicp\\isisicp.tlb" named_guids
#import "..\\tlb\\Seci.tlb" named_guids
#import "..\\tlb\\LabVIEW.tlb" named_guids

void InstAPILib::createSession(BSTR instrument, BSTR user_name, BSTR password, ULONG* session_id)
{
        *session_id = 1;
        m_session[*session_id] = "";
}

void InstAPILib::deleteSession(ULONG session_id)
{
        m_session[session_id] = "";
}

void InstAPILib::getRole(ULONG session_id, BSTR* role)
{
}

void InstAPILib::setRole(ULONG session_id, BSTR role)
{
}

COAUTHIDENTITY* InstAPILib::createIdentity(const std::string& user, const std::string&  domain, const std::string& pass)
{
    COAUTHIDENTITY* pidentity = new COAUTHIDENTITY;
    pidentity->Domain = (USHORT*)strdup(domain.c_str());
    pidentity->DomainLength = strlen((const char*)pidentity->Domain);
    pidentity->Flags = SEC_WINNT_AUTH_IDENTITY_ANSI;
    pidentity->Password = (USHORT*)strdup(pass.c_str());
    pidentity->PasswordLength = strlen((const char*)pidentity->Password);
    pidentity->User = (USHORT*)strdup(user.c_str());
    pidentity->UserLength = strlen((const char*)pidentity->User);
    return pidentity;
}

HRESULT InstAPILib::setIdentity(COAUTHIDENTITY* pidentity, IUnknown* pUnk)
{
    HRESULT hr;
    if (pidentity != NULL)
    {
       hr = CoSetProxyBlanket(pUnk, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, NULL, 
            RPC_C_AUTHN_LEVEL_DEFAULT, RPC_C_IMP_LEVEL_IMPERSONATE, pidentity, EOAC_NONE);
        if (FAILED(hr))
        {
            return hr;
        }
    }
    return S_OK;
}


HRESULT InstAPILib::test(void)
{
        // TODO: Add your implementation code here
        CComPtr<isisicpLib::Idae> icp;
        COSERVERINFO server_info;
        memset(&server_info, 0, sizeof(server_info));
        MULTI_QI multi_qi[1];
        memset(multi_qi, 0, sizeof(multi_qi));
        server_info.pwszName = L"ndxtest";
        COAUTHIDENTITY* pidentity = createIdentity("spudulike", "ndxtest", "reliablebeam");
        COAUTHINFO* pauth = new COAUTHINFO;
    pauth->dwAuthnSvc = RPC_C_AUTHN_WINNT;
    pauth->dwAuthnLevel = RPC_C_AUTHN_LEVEL_DEFAULT;
    pauth->dwAuthzSvc = RPC_C_AUTHZ_NONE;
    pauth->dwCapabilities = EOAC_NONE;
    pauth->dwImpersonationLevel = RPC_C_IMP_LEVEL_IMPERSONATE;
    pauth->pAuthIdentityData = pidentity;
    pauth->pwszServerPrincName = NULL;
        server_info.pAuthInfo = pauth;

        multi_qi[0].pIID = &isisicpLib::IID_Idae;
        HRESULT hr = ::CoCreateInstanceEx(isisicpLib::CLSID_dae, NULL, CLSCTX_ALL, 
                                                        &server_info, (sizeof(multi_qi) / sizeof(MULTI_QI)), multi_qi);
        if (FAILED(hr))
        {
//              AtlReportError(GetObjectCLSID(), "failed1"); 
                return hr;
        }
        if (FAILED(multi_qi[0].hr))
        {
//              AtlReportError(GetObjectCLSID(), "failed2"); 
                return multi_qi[0].hr;
        }
        setIdentity(pidentity, multi_qi[0].pItf);
        icp.Attach(reinterpret_cast<isisicpLib::Idae*>(multi_qi[0].pItf));
        hr = icp->areYouThere();
        if (FAILED(hr))
        {
//              AtlReportError(GetObjectCLSID(), "failed3"); 
                return hr;
        }

        return hr;
}

HRESULT InstAPILib::testicp(void)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
//              AtlReportError(GetObjectCLSID(), "CoCreateInstance failed"); 
                return hr;
        }

        hr = icp->areYouThere();

        if (FAILED(hr))
        {
//              AtlReportError(GetObjectCLSID(), "Failed to communicate with ICP"); 
                return hr;
        }

        return S_OK;
}

HRESULT InstAPILib::testlv(void)
{
        CComPtr<LabVIEW::_Application> lv;
        HRESULT hr = lv.CoCreateInstance(LabVIEW::CLSID_Application, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
//              AtlReportError(GetObjectCLSID(), "CoCreateInstance failed"); 
                return hr;
        }

        CComBSTR ccombstr((char *)lv->GetVersion());

        if (ccombstr.Length() == 0)
        {
                //Did not talk to LabVIEW
//              AtlReportError(GetObjectCLSID(), "Failed to communicate with LabVIEW"); 
                return E_FAIL;
        }
        
        return S_OK;
}

static int test()
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);       
}

//junk<isisicp::Idae,isisicp::CLSID_Cdae,isisicp::IID_Idae>
template <class OBJ>
static int junk(const std::string& hostname, GUID C, GUID G)
{
        // TODO: Add your implementation code here
        CComPtr<OBJ> icp;
        COSERVERINFO server_info;
        memset(&server_info, 0, sizeof(server_info));
        MULTI_QI multi_qi[1];
        memset(multi_qi, 0, sizeof(multi_qi));
        server_info.pwszName = hostname;
        COAUTHIDENTITY* pidentity = createIdentity("spudulike", "ndxtest", "reliablebeam");
        COAUTHINFO* pauth = new COAUTHINFO;
    pauth->dwAuthnSvc = RPC_C_AUTHN_WINNT;
    pauth->dwAuthnLevel = RPC_C_AUTHN_LEVEL_DEFAULT;
    pauth->dwAuthzSvc = RPC_C_AUTHZ_NONE;
    pauth->dwCapabilities = EOAC_NONE;
    pauth->dwImpersonationLevel = RPC_C_IMP_LEVEL_IMPERSONATE;
    pauth->pAuthIdentityData = pidentity;
    pauth->pwszServerPrincName = NULL;
        server_info.pAuthInfo = pauth;

        multi_qi[0].pIID = &G;
        HRESULT hr = ::CoCreateInstanceEx(C, NULL, CLSCTX_ALL, 
                                                        &server_info, (sizeof(multi_qi) / sizeof(MULTI_QI)), multi_qi);
        if (FAILED(hr))
        {
//              AtlReportError(GetObjectCLSID(), "failed1"); 
                return hr;
        }
        if (FAILED(multi_qi[0].hr))
        {
//              AtlReportError(GetObjectCLSID(), "failed2"); 
                return multi_qi[0].hr;
        }
        setIdentity(pidentity, multi_qi[0].pItf);
        icp.Attach(reinterpret_cast<OBJ*>(multi_qi[0].pItf));
}

void InstAPILib::putMessage(ULONG session_id, BSTR time, BSTR severity, BSTR message)
{
}

void InstAPILib::getMessages(ULONG session_id, LONG start_index, BSTR min_severity, VARIANT* times, VARIANT* severities, VARIANT* messages, LONG* end_index)
{
}

void InstAPILib::getViRef(BSTR vi_name, bool reentrant, LabVIEW::VirtualInstrumentPtr &vi)
{
        UINT len = SysStringLen(vi_name);
        std::wstring ws(vi_name, SysStringLen(vi_name));

        vi_map_t::iterator it = m_vimap.find(ws);
        if(it != m_vimap.end())
        {
                try
                {
                        vi = it->second.vi_ref;
                        vi->GetExecState();
                }
                catch(...)
                {
                        //Gets here if VI ref is not longer valid
                        createViRef(vi_name, reentrant, vi);
                }
        }
        else
        {
                createViRef(vi_name, reentrant, vi);
        }
}

void InstAPILib::createViRef(BSTR vi_name, bool reentrant, LabVIEW::VirtualInstrumentPtr &vi)
{
        std::wstring ws(vi_name, SysStringLen(vi_name));

        CComPtr<LabVIEW::_Application> lv;
        HRESULT hr = lv.CoCreateInstance(LabVIEW::CLSID_Application, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("getViRef failed (could not connect to LabVIEW)");
        }

        if (reentrant)
        {
                vi = lv->GetVIReference(vi_name, "", 1, 8);
        }
        else
        {
                //If a VI is reentrant then always get it as reentrant
                vi = lv->GetVIReference(vi_name, "", 0, 0);
                if (vi->IsReentrant)
                {
                        vi = lv->GetVIReference(vi_name, "", 1, 8);
                        reentrant = true;
                }
        }

        ViRef viref;
        viref.vi_ref = vi;
        viref.reentrant = reentrant;
        m_vimap[ws] = viref;
}

void InstAPILib::getLabviewValue(ULONG session_id, BSTR vi_name, BSTR control_name, VARIANT* value)
{
        try
        {
                LabVIEW::VirtualInstrumentPtr vi;
                getViRef(vi_name, false, vi);
        
                *value = vi->GetControlValue(control_name).Detach();

                vi.Detach();
        }
        catch(...)
        {
        }
}

void InstAPILib::sendBlockSetpoint(ULONG session_id, BSTR block_name, VARIANT setpoint_value, bool push_button, bool use_external, VARIANT* results)
{
        results->vt = VT_EMPTY;
        setBlockSetpoint(session_id, block_name, setpoint_value, push_button, use_external, results);
}

void InstAPILib::logBlocksNow(ULONG session_id, BSTR source)
{
        CComVariant names;
        getBlockNames(session_id, &names);
        CComSafeArray<BSTR> sab;
        sab.CopyFrom(names.parray);

        UINT d = sab.GetDimensions(); //should be 1

        if (d != 1)
        {
                throw std::runtime_error("getBlockNames returned an array of the wrong dimensions");
        }

        LONG numPars = sab.GetUpperBound(0); //this is inclusive, i.e. if it is 2 this means [2] is valid
        LONG aIndex[1];

        std::vector<std::string> blocknames;
        std::vector<std::string> blockvalues;
        std::vector<std::string> times;
        long runNum = 0;
        CComBSTR messages;
        getRunNumber(session_id, &messages, &runNum);

        //Convert source to char*
        int len = (int) SysStringLen(source);
    char* char_source = (char *) malloc(1+len);
    WideCharToMultiByte( CP_ACP, 0, source, -1, char_source, len, NULL, NULL );
    char_source[len] = '\0';

        for (UINT i = 0; i <= numPars; ++i)
        {
                bstr_t bname;
                aIndex[0] = i;
                sab.MultiDimGetAt(aIndex, bname.GetBSTR());

                //Convert the block name to std::string
                UINT len = SysStringLen(bname);
                std::wstring ws_name(bname, len);
                std::string s_name;
                s_name.assign(ws_name.begin(), ws_name.end());
                blocknames.push_back(s_name);

                //Get the current value and convert to std::string
                CComVariant currVal;
                getBlockValue(session_id, bname, &currVal);
                currVal.ChangeType(VT_BSTR);
                bstr_t bstrVal;
                currVal.CopyTo(&(bstrVal.GetBSTR()));
                std::wstring ws_curr(bstrVal, SysStringLen(bstrVal));
                std::string s_curr;
                s_curr.assign(ws_curr.begin(), ws_curr.end());
                blockvalues.push_back(s_curr);

                time_t rawtime;
                struct tm * timeinfo;
                time ( &rawtime );
                timeinfo = localtime ( &rawtime );
                int year = timeinfo->tm_year + 1900;
                int month = timeinfo->tm_mon + 1;
                char buffer[20];
                sprintf (buffer, "%d-%02d-%02dT%02d:%02d:%02d", year, month, timeinfo->tm_mday, timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
                times.push_back(buffer);
        }

        if (se_log_values_async(runNum, char_source, times, blocknames, blockvalues) != 0)
        {
                throw std::runtime_error(se_get_errmsg());
        }

        free(char_source); 
}

void InstAPILib::setBlockSetpoint(ULONG session_id, BSTR block_name, VARIANT setpoint_value, bool push_button, bool use_external, VARIANT* results)
{
        SEBLOCK_DETAILS details;
        if (se_get_block_details(COLE2CT(block_name), details) != 0)
        {
                throw std::runtime_error(se_get_errmsg());
        }

        _bstr_t vi(details.vi_name().c_str());
        
        if (details.set_control() != std::string(""))
        {
                _bstr_t setcontrol(details.set_control().c_str());

                if (use_external)
                {
                        setLabviewValueExt(session_id, vi, setcontrol, setpoint_value, results);
                }
                else
                {
                        setLabviewValue(session_id, vi, setcontrol, setpoint_value);
                }               
        }

        if (push_button)
        {
                if (details.button_control() != std::string(""))
                {
                        VARIANT* pushResults = new VARIANT;
                        _bstr_t gocontrol(details.button_control().c_str());
                        _variant_t button(true);
                        if (use_external)
                        {
                                
                                pushResults->vt = VT_EMPTY;
                                setLabviewValueExt(session_id, vi, gocontrol, button, pushResults);
                        }
                        else
                        {
                                setLabviewValue(session_id, vi, gocontrol, button);
                        }
                }
        }

        VARIANT v;
        VariantInit(&v);
        VariantChangeType(&v, &setpoint_value, 0, VT_BSTR);
        se_set_block_value(COLE2CT(block_name), COLE2CT(v.bstrVal));
        VariantClear(&v);
}

void InstAPILib::setLabviewValue(ULONG session_id, BSTR vi_name, BSTR control_name, VARIANT value)
{
        HRESULT hr = S_OK();
        
        try
        {
                LabVIEW::VirtualInstrumentPtr vi;
                getViRef(vi_name, false, vi);
                hr = vi->SetControlValue(control_name, value);
                vi.Detach();
        }
        catch(...)
        {
                hr = -1;
        }

        if (FAILED(hr))
        {
                throw std::runtime_error("SetLabviewValue failed");
        }
}

void InstAPILib::setLabviewValueExt(ULONG session_id, BSTR vi_name, BSTR control_name, VARIANT value, VARIANT* results)
{
        _bstr_t path(L"C:\\LabVIEW Modules\\Common\\External Interface\\External Interface.llb\\External Interface - Set Value.vi");

        CComSafeArray<BSTR> names(6);
        names[0].AssignBSTR(_bstr_t(L"VI Name"));
        names[1].AssignBSTR(_bstr_t(L"Control Name"));
        names[2].AssignBSTR(_bstr_t(L"String Control Value"));
        names[3].AssignBSTR(_bstr_t(L"Variant Control Value"));
        names[4].AssignBSTR(_bstr_t(L"Machine Name"));
        names[5].AssignBSTR(_bstr_t(L"Return Message"));

        _variant_t n;
        n.vt = VT_ARRAY | VT_BSTR;
        n.parray = names.Detach();

        CComSafeArray<VARIANT> values(6);
        values[0] = vi_name;
        values[1] = control_name;
        //values[2] = 
        values[3] = value;
        //values[4] = 
        //values[5] = 

        _variant_t v;
        v.vt = VT_ARRAY | VT_VARIANT;
        v.parray = values.Detach();

        //Must be called as reentrant!
        callLabview(session_id, path, n, v, true, results);
}

void InstAPILib::callLabview(ULONG session_id, BSTR vi_name, VARIANT names, VARIANT values, VARIANT_BOOL reentrant, VARIANT* results)
{
        HRESULT hr = S_OK;

        try
        {
                LabVIEW::VirtualInstrumentPtr vi;

                if (reentrant)
                {
                        getViRef(vi_name, true, vi);
                }
                else
                {
                        getViRef(vi_name, false, vi);
                }

                hr = vi->Call(&names, &values);
                vi.Detach();

                CComVariant var(values);
                var.Detach(results);
        }
        catch(...)
        {
                hr = -1;
        }

        if (FAILED(hr))
        {
                throw std::runtime_error("CallLabviewValue failed");
        }
}

void InstAPILib::pushBlockButton(ULONG session_id, BSTR block_name, bool use_external, VARIANT* results)
{
        results = new VARIANT;
        results->vt = VT_EMPTY;

        SEBLOCK_DETAILS details;
        if (se_get_block_details(COLE2CT(block_name), details) != 0)
        {
                throw std::runtime_error(se_get_errmsg());
        }

        _bstr_t vi(details.vi_name().c_str());

        if (details.button_control() != std::string(""))
        {
                _bstr_t gocontrol(details.button_control().c_str());
                _variant_t button(true);

                if (use_external)
                {
                        setLabviewValueExt(session_id, vi, gocontrol, button, results);
                }
                else
                {
                        setLabviewValue(session_id, vi, gocontrol, button);
                }
        }
}

void InstAPILib::toggleViVisibility(ULONG session_id, BSTR vi_name, VARIANT_BOOL show)
{
        HRESULT hr = S_OK;

        try
        {
                LabVIEW::VirtualInstrumentPtr vi;
                getViRef(vi_name, false, vi);
                vi->FPWinOpen = show;
                vi.Detach();
        }
        catch(...)
        {
                hr = -1;
        }

        if (FAILED(hr))
        {
                throw std::runtime_error("toggleViVisibility failed");
        }
}

void InstAPILib::getViState(ULONG session_id, BSTR vi_name, VARIANT* value)
{
        HRESULT hr = S_OK();

        try
        {
                LabVIEW::VirtualInstrumentPtr vi;
                getViRef(vi_name, false, vi);
                CComVariant wrapper;
                wrapper.ChangeType(VT_INT);
                wrapper.Detach(value);
                value->intVal = vi->ExecState;
                vi.Detach();
        }
        catch(...)
        {
                hr = -1;
        }

        if (FAILED(hr))
        {
                throw std::runtime_error("GetViState failed");
        }
}

void InstAPILib::startVi(ULONG session_id, BSTR vi_name)
{
        HRESULT hr = S_OK;

        try
        {
                LabVIEW::VirtualInstrumentPtr vi;
                getViRef(vi_name, false, vi);
                // LabVIEW::ExecStateEnum.eIdle = 1
                if (vi->ExecState == 1)
                {
                        vi->Run(true);
                }
                vi.Detach();
        }
        catch(...)
        {
                hr = -1;
        }

        if (FAILED(hr))
        {
                throw std::runtime_error("StartVi failed");
        }
}

void InstAPILib::stopVi(ULONG session_id, BSTR vi_name)
{
        HRESULT hr = S_OK;

        try
        {
                LabVIEW::VirtualInstrumentPtr vi;
                getViRef(vi_name, false, vi);
                // LabVIEW::ExecStateEnum.eIdle = 1
                // LabVIEW::ExecStateEnum.eRunTopLevel = 2
                if (vi->ExecState == 1 || vi->ExecState == 2)
                {
                        vi->Abort();
                }
                vi.Detach();
        }
        catch(...)
        {
                hr = -1;
        }

        if (FAILED(hr))
        {
                throw std::runtime_error("StopVi failed");
        }
}

void InstAPILib::closeViFrontPanel(ULONG session_id, BSTR vi_name)
{
        HRESULT hr = S_OK;

        try
        {
                LabVIEW::VirtualInstrumentPtr vi;
                getViRef(vi_name, false, vi);
                hr = vi->CloseFrontPanel();
                vi.Detach();
        }
        catch(...)
        {
                hr = -1;
        }

        if (FAILED(hr))
        {
                throw std::runtime_error("CloseViFrontPanel failed");
        }
}

void InstAPILib::getViNames(ULONG session_id, VARIANT* names)
{
        CComPtr<Seci::IComInterface> seci;
        HRESULT hr = seci.CoCreateInstance(Seci::CLSID_ComInterface, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("GetViNames failed (could not connect to SECI)");
        }

        try
        {
                SAFEARRAY* temp = seci->GetVIsFullpath();
                CComSafeArray<BSTR> saBstr(temp);
                CComVariant varArrayWrapper (saBstr);
                varArrayWrapper.Detach(names);
        }
        catch(...)
        {
                hr = -1;
        }

        if (FAILED(hr))
        {
                throw std::runtime_error("GetViNames failed");
        }
}

void InstAPILib::getBlockValue(ULONG session_id, BSTR block_name, VARIANT* block_value)
{
        SEBLOCK_DETAILS details;
        if (se_get_block_details(COLE2CT(block_name), details) != 0)
        {
                throw std::runtime_error(se_get_errmsg());
        }

        _bstr_t vi(details.vi_name().c_str());

        if (details.read_control() == std::string(""))
        {
                return;
        }

        _bstr_t control(details.read_control().c_str());

        getLabviewValue(session_id, vi, control, block_value);
}

void InstAPILib::getBlockSetpoint(ULONG session_id, BSTR block_name, VARIANT* setpoint_value)
{
        SEBLOCK_DETAILS details;
        if (se_get_block_details(COLE2CT(block_name), details) != 0)
        {
                throw std::runtime_error(se_get_errmsg());
        }

        _bstr_t vi(details.vi_name().c_str());

        if (details.set_control() == std::string(""))
        {
                return;
        }

        _bstr_t control(details.set_control().c_str());
        getLabviewValue(session_id, vi, control, setpoint_value);
}

void InstAPILib::getRunControl(ULONG session_id, BSTR block_name, VARIANT_BOOL* rc_value)
{
        accessRuncontrol(session_id, block_name, NULL, rc_value, false);
}

void InstAPILib::setRunControl(ULONG session_id, BSTR block_name, VARIANT_BOOL rc_value)
{
        accessRuncontrol(session_id, block_name, rc_value, NULL, true);
}

void InstAPILib::accessRuncontrol(ULONG session_id, BSTR block_name, VARIANT_BOOL new_value, VARIANT_BOOL* value, bool setvalue)
{
        CComBSTR path(L"C:\\Labview modules\\dae\\monitor\\dae_monitor.vi");
        CComBSTR control(L"Parameter details");

        CComVariant val;

        getLabviewValue(session_id, path, control, &val);

        CComSafeArray<BSTR> sab;
        sab.CopyFrom(val.parray);
        UINT d = sab.GetDimensions();
        LONG numPars = sab.GetUpperBound(0); //this is inclusive, i.e. if it is 2 this means [2] is valid
        LONG aIndex[2];
        bstr_t bname;

        for (UINT i = 0; i <= numPars; ++i)
        {
                aIndex[0] = i;
                aIndex[1] = 0;
                sab.MultiDimGetAt(aIndex, bname.GetBSTR());

                if (wcscmp(bname, block_name) == 0)
                {
                        if (setvalue)
                        {
                                //The runcontrol setting is found at the 7 column of the 2d array in LabVIEW.
                                aIndex[1] = 7;

                                if (new_value)
                                {
                                        CComBSTR bnew(L"1");
                                        sab.MultiDimSetAt(aIndex, bnew);
                                }
                                else
                                {
                                        CComBSTR bnew(L"0");
                                        sab.MultiDimSetAt(aIndex, bnew);
                                }
                                CComVariant vnew(sab);
                                setLabviewValue(session_id, path, control, vnew);
                                break;
                        }
                        else
                        {
                                bstr_t bvalue;
                                aIndex[1] = 7;
                                sab.MultiDimGetAt(aIndex, bvalue.GetBSTR());

                                if (wcscmp(bvalue, L"1") == 0)
                                {
                                        *value = true;
                                }
                                else
                                {
                                        *value = false;
                                }

                                break;
                        }
                }
        }
}

void InstAPILib::accessLimits(ULONG session_id, BSTR block_name, VARIANT new_value, BSTR* value, bool setvalue, bool low)
{
        CComBSTR path(L"C:\\Labview modules\\dae\\monitor\\dae_monitor.vi");
        CComBSTR control(L"Parameter details");

        CComVariant val;

        getLabviewValue(session_id, path, control, &val);

        CComSafeArray<BSTR> sab;
        sab.CopyFrom(val.parray);
        UINT d = sab.GetDimensions();
        LONG numPars = sab.GetUpperBound(0); //this is inclusive, i.e. if it is 2 this means [2] is valid
        LONG aIndex[2];
        bstr_t bname;

        for (UINT i = 0; i <= numPars; ++i)
        {
                aIndex[0] = i;
                aIndex[1] = 0;
                sab.MultiDimGetAt(aIndex, bname.GetBSTR());

                if (wcscmp(bname, block_name) == 0)
                {
                        if (setvalue)
                        {
                                CComVariant vWrapper(new_value);
                                vWrapper.ChangeType(VT_BSTR);

                                if (low)
                                {
                                        //The low limit is found at the 8 column of the 2d array in LabVIEW.
                                        aIndex[1] = 8;
                                        bstr_t bnew(vWrapper.bstrVal);
                                        sab.MultiDimSetAt(aIndex, bnew);
                                }
                                else
                                {
                                        //The high limit is found at the 9 column of the 2d array in LabVIEW.
                                        aIndex[1] = 9;
                                        bstr_t bnew(vWrapper.bstrVal);
                                        sab.MultiDimSetAt(aIndex, bnew);
                                }
                                CComVariant vnew(sab);
                                setLabviewValue(session_id, path, control, vnew);
                                return;
                        }
                        else
                        {
                                if (low)
                                {
                                        aIndex[1] = 8;
                                        sab.MultiDimGetAt(aIndex, *value);
                                }
                                else
                                {
                                        aIndex[1] = 9;
                                        sab.MultiDimGetAt(aIndex, *value);
                                }

                                return;
                        }
                }
        }
}

void InstAPILib::getRunControlLimit(ULONG session_id, BSTR block_name, VARIANT* limit_value, bool low)
{
        VARIANT null = VARIANT();
        null.vt = VT_ERROR;
        null.scode = DISP_E_PARAMNOTFOUND;

        CComBSTR result;
        accessLimits(session_id, block_name, null, &result, false, low);

        CComVariant wrapper = CComVariant(result);

        //Try to convert the result to a double
        HRESULT hr = wrapper.ChangeType(VT_R8);

        if (hr != 0)
        {
                //Conversion failed so change it back to a string
                wrapper.ChangeType(VT_BSTR);
        }

        wrapper.Detach(limit_value);    
}

void InstAPILib::setRunControlLimit(ULONG session_id, BSTR block_name, VARIANT new_value, bool low)
{
        accessLimits(session_id, block_name, new_value, NULL, true, low);
}

void InstAPILib::getRunState(ULONG session_id, BSTR* messages, LONG* status)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        *status = icp->getRunState(messages);
}

void InstAPILib::beginRun(ULONG session_id, LONG period, VARIANT_BOOL wait, VARIANT_BOOL quiet, VARIANT_BOOL paused, BSTR* messages)
{
        //Do we need to proprogate "quiet" this far?
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        long options = 0;
        if (paused) options += 1;
        if (wait) options += 2;

        icp->beginRunEx(options, period, messages);
}

void InstAPILib::abortRun(ULONG session_id, BSTR* messages)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        icp->abortRun(messages);
}

void InstAPILib::endRun(ULONG session_id, BSTR* messages)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        icp->endRun(messages);
}

void InstAPILib::pauseRun(ULONG session_id, BSTR* messages)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        icp->pauseRun(messages);
}

void InstAPILib::resumeRun(ULONG session_id, BSTR* messages)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        icp->resumeRun(messages);
}

void InstAPILib::recoverRun(ULONG session_id, BSTR* messages)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        icp->setICPValueLong(L"RUN_STATUS", 3, messages);
}

void InstAPILib::saveRun(ULONG session_id, BSTR* messages)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        icp->saveRun(messages);
}

void InstAPILib::updateCRPT(ULONG session_id, BSTR* messages)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        icp->updateCRPT(messages);
}

void InstAPILib::storeCRPT(ULONG session_id, BSTR* messages)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        icp->storeCRPT(messages);
}

void InstAPILib::getGoodFrames(ULONG session_id, VARIANT_BOOL curr_period, BSTR* messages, LONG* frames)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        if (curr_period)
        {
                *frames = icp->getGoodFramesPeriod(messages);           
        }
        else
        {
                *frames = icp->getGoodFramesTotal(messages);
        }
}

void InstAPILib::getUamps(ULONG session_id, VARIANT_BOOL curr_period, BSTR* messages, DOUBLE* uamps)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        if (curr_period)
        {
                *uamps = icp->getGoodUAmpHPeriod(messages);             
        }
        else
        {
                *uamps = icp->getGoodUAmpH(messages);
        }
}

void InstAPILib::getMEvents(ULONG session_id, BSTR* messages, DOUBLE* mev)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        *mev = icp->getMEvents(messages);
}

void InstAPILib::getCurrentPeriod(ULONG session_id, BSTR* messages, LONG* period, LONG* daq_period)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        hr = icp->getCurrentPeriodNumber(period, daq_period, messages);
}

void InstAPILib::getRunNumber(ULONG session_id, BSTR* messages, LONG* run_no)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        *run_no = icp->getRunNumber(messages);
}

void InstAPILib::getTotalCounts(ULONG session_id, BSTR* messages, LONG* counts)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        *counts = icp->getTotalCounts(messages);
}

void InstAPILib::snapshotCRPT(ULONG session_id, BSTR filename, LONG do_update, LONG do_pause, BSTR* messages)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        hr = icp->snapshotCRPT(filename, do_update, do_pause, messages);
}

void InstAPILib::sumAllHistogramMemory(ULONG session_id, BSTR* messages, LONG* counts)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        hr = icp->sumAllHistogramMemory(counts, messages);
}

void InstAPILib::sumAllSpectra(ULONG session_id, BSTR* messages, LONG* counts, LONG* bin_counts)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        try
        {
                //This method appears to throw though it does return values
                hr = icp->sumAllSpectra(counts, bin_counts, messages);
        }
        catch(...)
        {
        }
}

void InstAPILib::setRbNumber(ULONG session_id, VARIANT rb_no)
{
        _bstr_t path(L"C:\\Labview modules\\Common\\User Details\\User Details.vi");
        _bstr_t control(L"RB Number");

        setLabviewValue(session_id, path, control, rb_no);
}

void InstAPILib::getRbNumber(ULONG session_id, VARIANT* rb_no)
{
        _bstr_t path(L"C:\\Labview modules\\Common\\User Details\\User Details.vi");
        _bstr_t control(L"RB Number");

        getLabviewValue(session_id, path, control, rb_no);
}

void InstAPILib::setPeriod(ULONG session_id, LONG period_number, BSTR* messages)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        try
        {
                //This method throws if the period number is invalid
                hr = icp->changePeriod(period_number, messages);
        }
        catch(...)
        {
                CComBSTR tmpbstr(L"Could not change period - is the number entered valid?");
                tmpbstr.CopyTo(messages);
        }
}

void InstAPILib::setTitle(ULONG session_id, VARIANT title)
{
        _bstr_t path(L"C:\\Labview modules\\dae\\DAE Control.vi");
        _bstr_t title_control(L"New Run Title");
        _bstr_t button_control(L"Set Title");

        //Set the title
        setLabviewValue(session_id, path, title_control, title);

        _variant_t ans(true);
        setLabviewValue(session_id, path, button_control, ans);
}

void InstAPILib::getSpectrum(ULONG session_id, LONG spectrum_no, LONG period, VARIANT_BOOL as_dist, VARIANT* time_channels, VARIANT* signal, LONG* sum, BSTR* messages)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        if (as_dist != 0)
        {
                //Get a dist
                hr = icp->getSpectrum(spectrum_no, period, time_channels, signal, 0, 1, sum, messages);
        }
        else
        {
                hr = icp->getSpectrum(spectrum_no, period, time_channels, signal, 1, 0, sum, messages);
        }
}

void InstAPILib::changeNumberOfSoftwarePeriods(ULONG session_id, LONG num_periods, BSTR* messages)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        try
        {
                hr = icp->changeNumberOfSoftwarePeriods(num_periods, messages);
        }
        catch(...)
        {
                CComBSTR tmpbstr(L"Could not change number of software periods - is the DAE set to use software periods?");
                tmpbstr.CopyTo(messages);
        }
}

void InstAPILib::getNumberOfPeriods(ULONG session_id, BSTR* messages, LONG* num_periods)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        *num_periods = icp->getNumberOfPeriods(messages);
}

void InstAPILib::setBeamlineParameter(ULONG session_id, VARIANT name, VARIANT value, VARIANT units)
{
        _bstr_t path(L"C:\\Labview modules\\Common\\Experiment Parameters\\Beamline Parameters.vi");
        _bstr_t name_ctrl(L"Custom Parameter Name");
        _bstr_t value_ctrl(L"Custom Parameter Value");
        _bstr_t units_ctrl(L"Custom Parameter Units "); //Note extra space
        _bstr_t set_ctrl(L"Add Custom parameter");

        setLabviewValue(session_id, path, name_ctrl, name);
        setLabviewValue(session_id, path, value_ctrl, value);
        setLabviewValue(session_id, path, units_ctrl, units);

        _variant_t ans(true);
        setLabviewValue(session_id, path, set_ctrl, ans);
}

void InstAPILib::deleteBeamlineParameter(ULONG session_id, VARIANT name)
{
        _bstr_t path(L"C:\\Labview modules\\Common\\Experiment Parameters\\Beamline Parameters.vi");
        _bstr_t name_ctrl(L"Custom Parameter Name");
        _bstr_t set_ctrl(L"Remove Custom Parameter");

        setLabviewValue(session_id, path, name_ctrl, name);

        _variant_t ans(true);
        setLabviewValue(session_id, path, set_ctrl, ans);
}

void InstAPILib::deleteAllBeamlineParameters(ULONG session_id)
{
        _bstr_t path(L"C:\\Labview modules\\Common\\Experiment Parameters\\Beamline Parameters.vi");
        _bstr_t del_ctrl(L"Clear Parameters");
        _variant_t ans(true);
        setLabviewValue(session_id, path, del_ctrl, ans);
}

void InstAPILib::getBeamlineParameterNames(ULONG session_id, VARIANT* names)
{
        _bstr_t path(L"C:\\Labview modules\\Common\\Experiment Parameters\\Beamline Parameters.vi");
        _bstr_t name_ctrl(L"Additional Parameters");

        CComVariant val;

        getLabviewValue(session_id, path, name_ctrl, &val);

        int dims[2];
        int n = 2;
        arrayVariantDimensions(&val, dims, n);

        // Get a pointer to the elements of the array.
        bool changed = false;
        BSTR HUGEP *pbstr;
        HRESULT hr = SafeArrayAccessData(val.parray, (void HUGEP**)&pbstr);

        if (FAILED(hr))
        {
                return;
        }

        CComSafeArray<BSTR> saBstr(dims[0], 0);

        //dims[0] gives the number of entries (rows)
        for (int x = 0; x < dims[0]; ++x)
        {
                //Add the name
                LONG index[1];
                index[0] = x;
                HRESULT hr = saBstr.MultiDimSetAt(index, pbstr[x]);
        }

        CComVariant varArrayWrapper(saBstr);
        varArrayWrapper.Detach(names);

        SafeArrayUnaccessData(val.parray);
}

void InstAPILib::getBeamlineParameter(ULONG session_id, BSTR name, BSTR* value, BSTR* units, BSTR* type)
{
        _bstr_t path(L"C:\\Labview modules\\Common\\Experiment Parameters\\Beamline Parameters.vi");
        _bstr_t name_ctrl(L"Additional Parameters");

        CComVariant val;
        getLabviewValue(session_id, path, name_ctrl, &val);

        CComSafeArray<BSTR> sab;
        sab.CopyFrom(val.parray);
        UINT d = sab.GetDimensions();
        LONG numPars = sab.GetUpperBound(0); //this is inclusive, i.e. if it is 2 this means [2] is valid

        LONG aIndex[2];
        bstr_t bname;

        for (LONG i = 0; i <= numPars; ++i)
        {
                aIndex[0] = i;
                aIndex[1] = 0;
                sab.MultiDimGetAt(aIndex, bname.GetBSTR());

                if (wcscmp(bname, name) == 0)
                {
                        aIndex[1] = 3;
                        sab.MultiDimGetAt(aIndex, *value); 
                        aIndex[1] = 2;
                        sab.MultiDimGetAt(aIndex, *units);
                        aIndex[1] = 1;
                        sab.MultiDimGetAt(aIndex, *type); 
                        break;
                }
        }
}

void InstAPILib::setSampleParameter(ULONG session_id, VARIANT name, VARIANT value, VARIANT units)
{
        _bstr_t path(L"C:\\Labview modules\\Common\\Experiment Parameters\\Sample Parameters.vi");
        _bstr_t name_ctrl(L"Custom Parameter Name");
        _bstr_t value_ctrl(L"Custom Parameter Value");
        _bstr_t units_ctrl(L"Custom Parameter Units "); //Note extra space
        _bstr_t set_ctrl(L"Add Custom parameter");

        setLabviewValue(session_id, path, name_ctrl, name);
        setLabviewValue(session_id, path, value_ctrl, value);
        setLabviewValue(session_id, path, units_ctrl, units);

        _variant_t ans(true);
        setLabviewValue(session_id, path, set_ctrl, ans);
}

void InstAPILib::deleteSampleParameter(ULONG session_id, VARIANT name)
{
        _bstr_t path(L"C:\\Labview modules\\Common\\Experiment Parameters\\Sample Parameters.vi");
        _bstr_t name_ctrl(L"Custom Parameter Name");
        _bstr_t set_ctrl(L"Remove Custom Parameter");

        setLabviewValue(session_id, path, name_ctrl, name);

        _variant_t ans(true);
        setLabviewValue(session_id, path, set_ctrl, ans);
}

void InstAPILib::deleteAllSampleParameters(ULONG session_id)
{
        _bstr_t path(L"C:\\Labview modules\\Common\\Experiment Parameters\\Sample Parameters.vi");
        _bstr_t del_ctrl(L"Clear Parameters");
        _variant_t ans(true);
        setLabviewValue(session_id, path, del_ctrl, ans);
}

void InstAPILib::getSampleParameterNames(ULONG session_id, VARIANT* names)
{
        _bstr_t path(L"C:\\Labview modules\\Common\\Experiment Parameters\\Sample Parameters.vi");
        _bstr_t name_ctrl(L"Additional Parameters");

        CComVariant val;

        getLabviewValue(session_id, path, name_ctrl, &val);

        int dims[2];
        int n = 2;
        arrayVariantDimensions(&val, dims, n);

        // Get a pointer to the elements of the array.
        bool changed = false;
        BSTR HUGEP *pbstr;
        HRESULT hr = SafeArrayAccessData(val.parray, (void HUGEP**)&pbstr);

        if (FAILED(hr))
        {
                return;
        }

        CComSafeArray<BSTR> saBstr(dims[0], 0);

        //dims[0] gives the number of entries (rows)
        for (int x = 0; x < dims[0]; ++x)
        {
                //Add the name
                LONG index[1];
                index[0] = x;
                HRESULT hr = saBstr.MultiDimSetAt(index, pbstr[x]);
        }

        CComVariant varArrayWrapper (saBstr);
        varArrayWrapper.Detach(names);

        SafeArrayUnaccessData(val.parray);
}

void InstAPILib::getSampleParameter(ULONG session_id, BSTR name, BSTR* value, BSTR* units, BSTR* type)
{
        _bstr_t path(L"C:\\Labview modules\\Common\\Experiment Parameters\\Sample Parameters.vi");
        _bstr_t name_ctrl(L"Additional Parameters");

        CComVariant val;
        getLabviewValue(session_id, path, name_ctrl, &val);

        CComSafeArray<BSTR> sab;
        sab.CopyFrom(val.parray);
        UINT d = sab.GetDimensions();
        LONG numPars = sab.GetUpperBound(0); //this is inclusive, i.e. if it is 2 this means [2] is valid

        LONG aIndex[2];
        bstr_t bname;

        for (LONG i = 0; i <= numPars; ++i)
        {
                aIndex[0] = i;
                aIndex[1] = 0;
                sab.MultiDimGetAt(aIndex, bname.GetBSTR());

                if (wcscmp(bname, name) == 0)
                {
                        aIndex[1] = 3;
                        sab.MultiDimGetAt(aIndex, *value); 
                        aIndex[1] = 2;
                        sab.MultiDimGetAt(aIndex, *units);
                        aIndex[1] = 1;
                        sab.MultiDimGetAt(aIndex, *type); 
                        break;
                }
        }
}

void InstAPILib::vmeWriteValue(ULONG session_id, ULONG card_id, ULONG card_address, ULONG word_size, ULONG value, ULONG mode, BSTR* messages)
{
        CComPtr<isisicpLib::Idae> icp;
        HRESULT hr;
        hr = icp.CoCreateInstance(isisicpLib::CLSID_dae, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to icp");
        }

        hr = icp->VMEWriteValue(card_id, card_address, word_size, value, mode, messages);

        if (FAILED(hr))
        {
                throw std::runtime_error("Problem writing value to VME");
        }
}

void InstAPILib::getSeciConfig(ULONG session_id, BSTR* name)
{
        std::string config = "";
        se_get_seci_config(config);
        CComBSTR tmpbstr(config.c_str());
        tmpbstr.CopyTo(name);
}

void InstAPILib::clearDatabaseLogs(ULONG session_id, int run_num)
{
        //If the run-number is 0 then the current run-number is used
        se_clear_values(run_num, run_num);
}

void InstAPILib::clearLogFiles(ULONG session_id, int run_num, BSTR path)
{
        _bstr_t myb(path);
        std::string dir(myb);

        Poco::File logDir(dir);

        std::string s = boost::lexical_cast<std::string>(run_num);

        std::string nameformat("^[a-z]+\\w*[a-z]+0*" + s + "(_(\\w|_)+.txt|.log)");

        if (logDir.exists() && logDir.isDirectory())
        {
                Poco::RegularExpression re(nameformat, Poco::RegularExpression::RE_CASELESS);

                std::vector<std::string> files;
                logDir.list(files);
                std::vector<std::string>::iterator it = files.begin();
                for (; it != files.end(); ++it)
                {       
                        if (re.match(*it))
                        {
                                //Delete it
                                std::string fullname(dir + "\\" + *it);
                                Poco::File temp(fullname);
                                temp.remove();
                        }
                }
        }
}

void InstAPILib::getMeasurementLabel(ULONG session_id, BSTR id, BSTR* label)
{
        _bstr_t temp(id);
        const size_t newsize = (temp.length()+1)*2;
    char *nstring = new char[newsize];
    strcpy_s(nstring, newsize, (char *)temp);
        std::string ans;
        se_get_measurement_label(temp, ans);
        *label = CComBSTR(ans.c_str()).Detach();
}

void InstAPILib::setMeasurementLabel(ULONG session_id, BSTR id, BSTR label)
{
        _bstr_t b_id(id);
        size_t newsize = (b_id.length()+1)*2;
    char *id_string = new char[newsize];
    strcpy_s(id_string, newsize, (char *)b_id);

        _bstr_t b_label(label);
        newsize = (b_label.length()+1)*2;
    char *label_string = new char[newsize];
    strcpy_s(label_string, newsize, (char *)b_label);

        se_set_measurement_label(id_string, label_string);
}

void InstAPILib::getMeasurementId(ULONG session_id, BSTR label, VARIANT_BOOL newId, BSTR* id)
{
        _bstr_t temp(label);
        const size_t newsize = (temp.length()+1)*2;
    char *nstring = new char[newsize];
    strcpy_s(nstring, newsize, (char *)temp);
        std::string ans;
        
        if (newId)
        {
                se_new_measurement(nstring, ans); 
        }
        else
        {
                se_get_measurement_id(nstring, ans);
        }

        *id = CComBSTR(ans.c_str()).Detach();
}

void InstAPILib::getBlockNames(ULONG session_id, VARIANT* block_names)
{
        //For now we will get the values from Seci, but this will be changed at some point
        CComPtr<Seci::IComInterface> seci;
        HRESULT hr = seci.CoCreateInstance(Seci::CLSID_ComInterface, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to Seci");
        }

        block_names->vt = VT_ARRAY | VT_BSTR;
        block_names->parray = seci->GetBlockNames(true);
}

void InstAPILib::clearSeciGraphs(ULONG session_id)
{
        CComPtr<Seci::IComInterface> seci;
        HRESULT hr = seci.CoCreateInstance(Seci::CLSID_ComInterface, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to Seci");
        }

        seci->ClearGraphs();
}

void InstAPILib::changeSeciConfiguration(ULONG session_id, BSTR name, VARIANT_BOOL* result)
{
        CComPtr<Seci::IComInterface> seci;
        HRESULT hr = seci.CoCreateInstance(Seci::CLSID_ComInterface, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to Seci");
        }

        *result = seci->ChangeConfiguration(name);
}

void InstAPILib::isSeciBusy(ULONG session_id, VARIANT_BOOL* result)
{
        CComPtr<Seci::IComInterface> seci;
        HRESULT hr = seci.CoCreateInstance(Seci::CLSID_ComInterface, 0, CLSCTX_LOCAL_SERVER);

        if (FAILED(hr))
        {
                throw std::runtime_error("Could not connect to Seci");
        }

        *result = seci->IsSeciBusy();
}