labview_xml.cpp

Go to the documentation of this file.

#include "stdafx.h"

#include "labview_xml.h"

//implement filestream that derives from IStream
class MemoryStream : public IStream
{
private:
    char* m_buffer;
        int m_pos;
        int m_nbuffer;
    LONG m_refcount;

public:

        int toString(std::string& s) 
        {
                m_buffer[m_pos] = '\0';
                m_buffer[m_nbuffer-1] = '\0';
                s = m_buffer;
                return 0;
        }

        MemoryStream() 
    {
        m_refcount = 1;
                m_nbuffer = 50000;
                m_buffer = new char[m_nbuffer+1];
                reset();
    }

        void reset()
        {
                m_buffer[0] = '\0';
                m_pos = 0;
        }

    ~MemoryStream()
    {
                delete[] m_buffer;
                m_buffer = 0;
                m_pos = 0;
    }

    virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, void ** ppvObject)
    { 
        if (iid == __uuidof(IUnknown)
            || iid == __uuidof(IStream)
            || iid == __uuidof(ISequentialStream))
        {
            *ppvObject = static_cast<IStream*>(this);
            AddRef();
            return S_OK;
        } else
            return E_NOINTERFACE; 
    }

    virtual ULONG STDMETHODCALLTYPE AddRef(void) 
    { 
        return (ULONG)InterlockedIncrement(&m_refcount); 
    }

    virtual ULONG STDMETHODCALLTYPE Release(void) 
    {
        ULONG res = (ULONG) InterlockedDecrement(&m_refcount);
        if (res == 0) 
            delete this;
        return res;
    }

    // ISequentialStream Interface
public:
    virtual HRESULT STDMETHODCALLTYPE Read(void* pv, ULONG cb, ULONG* pcbRead)
    {
                if (m_pos + cb >= m_nbuffer)
                {
                        *pcbRead = 0;
                        return E_FAIL;
                }
                memcpy(pv, m_buffer+m_pos, cb);
                m_pos += cb;
                *pcbRead = cb;
                return S_OK;
    }

    virtual HRESULT STDMETHODCALLTYPE Write(void const* pv, ULONG cb, ULONG* pcbWritten)
    {
                if (m_pos + cb >= m_nbuffer)
                {
                        *pcbWritten = 0;
                        return E_FAIL;
                }
                memcpy(m_buffer+m_pos, pv, cb);
                m_pos += cb;
                *pcbWritten = cb;
                return S_OK;
    }

    // IStream Interface
public:
    virtual HRESULT STDMETHODCALLTYPE SetSize(ULARGE_INTEGER)
    { 
        return E_NOTIMPL;   
    }
    
    virtual HRESULT STDMETHODCALLTYPE CopyTo(IStream*, ULARGE_INTEGER, ULARGE_INTEGER*,
        ULARGE_INTEGER*) 
    { 
        return E_NOTIMPL;   
    }
    
    virtual HRESULT STDMETHODCALLTYPE Commit(DWORD)                                      
    { 
        return E_NOTIMPL;   
    }
    
    virtual HRESULT STDMETHODCALLTYPE Revert(void)                                       
    { 
        return E_NOTIMPL;   
    }
    
    virtual HRESULT STDMETHODCALLTYPE LockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD)              
    { 
        return E_NOTIMPL;   
    }
    
    virtual HRESULT STDMETHODCALLTYPE UnlockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD)            
    { 
        return E_NOTIMPL;   
    }
    
    virtual HRESULT STDMETHODCALLTYPE Clone(IStream **)                                  
    { 
        return E_NOTIMPL;   
    }

    virtual HRESULT STDMETHODCALLTYPE Seek(LARGE_INTEGER liDistanceToMove, DWORD dwOrigin,
        ULARGE_INTEGER* lpNewFilePointer)
    {
                int oldpos = m_pos;
        switch(dwOrigin)
        {
        case STREAM_SEEK_SET:
                        m_pos = liDistanceToMove.LowPart;
            break;
        case STREAM_SEEK_CUR:
                        m_pos += liDistanceToMove.LowPart;
            break;
        case STREAM_SEEK_END:
                        m_pos = m_nbuffer + liDistanceToMove.LowPart;
            break;
        default:   
            return STG_E_INVALIDFUNCTION;
            break;
        }
                if (m_pos >= m_nbuffer)
                {
                        m_pos = oldpos;
                        lpNewFilePointer->HighPart = 0;
                        lpNewFilePointer->LowPart = m_pos;
                        return E_FAIL;
                }
                lpNewFilePointer->HighPart = 0;
                lpNewFilePointer->LowPart = m_pos;
        return S_OK;
    }

    virtual HRESULT STDMETHODCALLTYPE Stat(STATSTG* pStatstg, DWORD grfStatFlag) 
    {
        return E_NOTIMPL;   
    }

};


// You might need to add the msxml4/sdk/(inc, lib) directories 
// to the Tools->Options...->Directories in Visual Studio.
//
// You might also need to append "msxml2.lib" to the
// Project->Settings...->Link->Object/Libray Modules field.



LabviewXML::LabviewXML()
{
        m_pxmldom = NULL;
        std::cerr << "ERROR: Calling LabviewXML default constructor" << std::endl;
}

// Helper function to create a DOM instance:


int LabviewXML::DomFromCOM(DAEstatus& status)
{
        HRESULT hr;
//   CoInitialize(NULL); DOMDocument40
        STATUS_CHECK_HR( CoCreateInstance(__uuidof(DOMDocument),
                                                NULL,
                                                CLSCTX_INPROC_SERVER,
                                                __uuidof(IXMLDOMDocument),
                                                (void**)&m_pxmldom),
                                        status);
        if (m_pxmldom != NULL)
        {
            STATUS_CHECK_HR( m_pxmldom->put_async(VARIANT_FALSE), status);
        STATUS_CHECK_HR( m_pxmldom->put_validateOnParse(VARIANT_FALSE), status);
            STATUS_CHECK_HR( m_pxmldom->put_resolveExternals(VARIANT_FALSE), status);  
                return DAEstatus::Success;
        }
        else
        {
                return DAEstatus::Failure;
        }
}

int LabviewXML::processAllElements(bool reading, DAEstatus& status)
{
   int i;
   for(i=0; i<n_lv; i++)
   {
          processElements(i, reading, status);
   }
   return 0;
}

int LabviewXML::processElements(int type, bool reading, DAEstatus& status)
{
        IXMLDOMNodeList *main_list = NULL, *child_list = NULL;
        IXMLDOMNode *main_node = NULL, *child_node = NULL, *parent_node = NULL;
    long lCount = 0, nlist;
        int i, j;
        BSTR tag_name = SysAllocString(lv_tags[type]);
        char name_tmp[256];
        HRESULT hr;
        hr = m_pxmldom->getElementsByTagName(tag_name, &main_list);
        hr = main_list->get_length(&nlist);
        BSTR bstr = NULL;
        insert_t insert_ret;
        iterator_t itty;
        bool is_array_element;
        char array_name[256];
        for(itty = m_list.begin(); itty != m_list.end(); ++itty)
        {
                itty->second.index = 0;
        }
    for(i=0; i<nlist; i++)
    {
                is_array_element = false;
        hr = main_list->get_item(i, &main_node);
                hr = main_node->get_parentNode(&parent_node);
                bstr = NULL;
                hr = parent_node->get_nodeName(&bstr);
                if (!wcscmp(L"Array", bstr))
                {
                        SysFreeString(bstr);
                        bstr = NULL;
                        is_array_element = true;
                        hr = parent_node->get_firstChild(&child_node);   // will be <Name> element for array
                        child_node->get_text(&bstr);
                        wcstombs(array_name, bstr, sizeof(array_name));
                        child_node->Release();
                        child_node = NULL;
                }
                SysFreeString(bstr);
                parent_node->Release();
                parent_node = NULL;
                hr = main_node->get_childNodes(&child_list);
                hr = child_list->get_length(&lCount);
                name_tmp[0] = '\0';
                for(j=0; j< lCount; j++)
                {
                        bstr = NULL;
                        child_list->get_item(j, &child_node);
                        child_node->get_nodeName(&bstr);
                        if (!wcscmp(L"Name", bstr))
                        {
                                        SysFreeString(bstr);
                                        bstr = NULL;
                                        child_node->get_text(&bstr);
                                        wcstombs(name_tmp, bstr, sizeof(name_tmp));
                        }
                        else if (!wcscmp(L"Val", bstr))
                        {
                                SysFreeString(bstr);
                                bstr = NULL;
                                if (reading)
                                {
                                        child_node->get_text(&bstr);
                                        std::string my_name = (is_array_element ? array_name : name_tmp);
                                        labview_item& item = m_list[my_name]; 
                                        item.value.push_back(static_cast<const char*>(CW2CT(bstr)));
                                        item.type = type;
                                }
                                else
                                {
                                        if (is_array_element)
                                        {
                                                itty = m_list.find(array_name);
                                        }
                                        else
                                        {
                                                itty = m_list.find(name_tmp);
                                        }
                                        if (itty != m_list.end())
                                        {
                                                labview_item& item = itty->second; 
                                                if (item.index < item.value.size())
                                                {
                                                        bstr = SysAllocString(CT2W(item.value[item.index].c_str()));
                                                }
                                                else
                                                {
                                                        bstr = SysAllocString(CT2W(lv_defaults[item.type]));
                                                }
                                                child_node->put_text(bstr);
                                                ++(item.index);
                                        }
                                        else
                                        {
                                                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "processElements: XML key \"%s\" not found", name_tmp);
                                        }
                                }
                        }
                        if (bstr != NULL)
                        {
                                SysFreeString(bstr);
                                bstr = NULL;
                        }
                        child_node->Release();
                        child_node = NULL;
                }
                child_list->Release();
                child_list = NULL;
                main_node->Release();
                main_node = NULL;
        }
        main_list->Release();
        SysFreeString(tag_name);
        return 0;
}

int LabviewXML::setValue(const char* name, long value, DAEstatus& status)
{
        char buffer[60];
        sprintf(buffer, "%ld", value);
        return setValue(name, buffer, status);
}

int LabviewXML::setValue(const char* name, __int64 value, DAEstatus& status)
{
        char buffer[60];
        sprintf(buffer, "%ld", (long)value);
        return setValue(name, buffer, status);
}

int LabviewXML::setValue(const char* name, unsigned int value, DAEstatus& status)
{
        char buffer[60];
        sprintf(buffer, "%u", value);
        return setValue(name, buffer, status);
}

int LabviewXML::setValue(const char* name, unsigned long value, DAEstatus& status)
{
        char buffer[60];
        sprintf(buffer, "%lu", value);
        return setValue(name, buffer, status);
}

int LabviewXML::setValue(const char* name, int value, DAEstatus& status)
{
        char buffer[60];
        sprintf(buffer, "%d", value);
        return setValue(name, buffer, status);
}


int LabviewXML::setValue(const char* name, double value, DAEstatus& status)
{
        char buffer[60];
        sprintf(buffer, "%g", value);
        return setValue(name, buffer, status);
}

int LabviewXML::setValue(const char* name, const std::vector<std::string>& value, DAEstatus& status)
{
        iterator_t iterator;
        iterator = m_list.find(name);
        if (iterator != m_list.end())
        {
                (iterator->second).value = value;
        }
        else
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "XML array key \"%s\" not found", name);
        }
        return 1;
}

// should use printf syle  lv_format[(iterator->second).type]   for writing
//
int LabviewXML::setValue(const char* name, const char* value, DAEstatus& status)
{
        static bool ignore_missing = Poco::Util::Application::instance().config().getBool("isisicp.ignoremissingdashboardxml", true);
        iterator_t iterator;
        iterator = m_list.find(name);
        if (iterator != m_list.end())
        {
                (iterator->second).value[0] = value;
        }
        else if (!ignore_missing)
        {
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "setValue: XML key \"%s\" not found", name);
        }
        return 1;
}

std::string LabviewXML::valueAsString(const char* name, DAEstatus& status)
{
        std::string s;
        getValue(name, s, status);
        return s;
}

int LabviewXML::getValue(const char* name, double& value, DAEstatus& status)
{
        std::string s;
        int stat = getValue(name, s, status);
        value = atof(s.c_str());
        return stat;
}

int LabviewXML::getValue(const char* name, float& value, DAEstatus& status)
{
        std::string s;
        int stat = getValue(name, s, status);
        value = static_cast<float>(atof(s.c_str()));
        return stat;
}

int LabviewXML::getValue(const char* name, long& value, DAEstatus& status)
{
        std::string s;
        int stat = getValue(name, s, status);
        value = atol(s.c_str());
        return stat;
}


int LabviewXML::getValue(const char* name, __int64& value, DAEstatus& status)
{
        std::string s;
        int stat = getValue(name, s, status);
        value = atol(s.c_str());
        return stat;
}

int LabviewXML::getValue(const char* name, int& value, DAEstatus& status)
{
        std::string s;
        int stat = getValue(name, s, status);
        value = atoi(s.c_str());
        return stat;
}

int LabviewXML::getValue(const char* name, std::vector<std::string>& value, DAEstatus& status)
{
        c_iterator_t iterator;
        iterator = m_list.find(name);
        if (iterator != m_list.end())
        {
                value = (iterator->second).value;
                return DAEstatus::Success;
        }
        else
        {
                value.clear();
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "XML array key \"%s\" not found", name);
                return DAEstatus::Failure;
        }
}

int LabviewXML::getValue(const char* name, std::string& value, DAEstatus& status)
{
        c_iterator_t iterator;
        iterator = m_list.find(name);
        if (iterator != m_list.end())
        {
                value = (iterator->second).value[0];
                return DAEstatus::Success;
        }
        else
        {
                value = " ";
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "getValue: XML key \"%s\" not found", name);
                return DAEstatus::Failure;
        }
}

int LabviewXML::getValue(const char* name, char* value, int max_len, bool write_null, DAEstatus& status)
{
        int stat;
        const char* tstr;
        c_iterator_t iterator;
        iterator = m_list.find(name);
        if (iterator != m_list.end())
        {
                tstr = (iterator->second).value[0].c_str();
                stat = DAEstatus::Success;
        }
        else
        {
                tstr = "";
                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "getValue: XML key \"%s\" not found", name);
                stat = DAEstatus::Failure;
        }
        strncpy(value, tstr, max_len);
        if (write_null)
        {
                value[max_len-1] = '\0';
        }
        else // space pad
        {
                for(size_t i=strlen(tstr); i<max_len; i++)
                {
                        value[i] = ' ';
                }
        }
        return stat;
}

// set ISO-8859-1 encoding - this is so accents etc. appear correctly in LabVIEW
int LabviewXML::setISO8859Encoding(DAEstatus& status)
{
        IXMLDOMProcessingInstruction* pi = NULL;
        if ( (m_pxmldom->createProcessingInstruction(L"xml", L" version='1.0' encoding='ISO-8859-1'", &pi) != S_OK) || (pi == NULL) )
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "LabviewXML: error creating encoding");
                return DAEstatus::Failure;
        }
        IXMLDOMElement *root_element = NULL;
        IXMLDOMNode *out_child = NULL;
        m_pxmldom->get_documentElement(&root_element);
        VARIANT v;
        v.punkVal = root_element;
        v.vt = VT_UNKNOWN;
        if (m_pxmldom->insertBefore(pi, v, &out_child) != S_OK)
        {
                status.add(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "LabviewXML: error adding encoding");
        }
        if (out_child != NULL)
        {
                out_child->Release();
        }
        pi->Release();
        root_element->Release();
        return DAEstatus::Success;
}


int LabviewXML::saveToFile(const char* filename, DAEstatus& status)
{
        processAllElements(false, status);
        CComBSTR b(filename);
        CComVariant v(b);
//      setISO8859Encoding(status);
        m_pxmldom->save(v);
        return 0;
}

//int LabviewXML::saveToString(BSTR* bstr, DAEstatus& status)
//{
//      processAllElements(false, status);
//      m_pxmldom->get_xml(bstr);
//      return 0;
//}

int LabviewXML::saveToString(std::string& s, DAEstatus& status)
{
//      if (false)
//      {
//              BSTR b = NULL;
//              saveToString(&b, status);
//              s = COLE2CT(b);
//              SysFreeString(b);
//              b = NULL;
//      }
//      else
//      {
                processAllElements(false, status);
                MemoryStream* ms = new MemoryStream;
                VARIANT v;
                VariantInit(&v);
                v.vt = VT_UNKNOWN;
                v.punkVal = ms;
                setISO8859Encoding(status);
                m_pxmldom->save(v);
                ms->toString(s);
                size_t n1 = s.find("<?xml");
                size_t n2 = s.find("?>");
                if (n1 != s.npos && n2 != s.npos)
                {
                        s.erase(n1, 2+n2-n1);   // labview does not like <?xml ?> line
                }
                delete ms;
//      }
        return 0;
}


int LabviewXML::loadFromString(const char* xml_string, DAEstatus& status)
{
//      CComBSTR b(xml_string);
        return loadFromString(CT2OLE(xml_string), status);
}

int LabviewXML::loadFromString(BSTR xml_string, DAEstatus& status)
{
   IXMLDOMParseError *pXMLErr=NULL;
   IXMLDOMElement               *element     = NULL;
   IXMLDOMNodeList *name_list = NULL, *value_list=NULL;
   IXMLDOMNode* node = NULL;
   BSTR bstr = NULL;
   VARIANT_BOOL b_status = VARIANT_FALSE;
   HRESULT hr;

   if (!m_pxmldom) 
           return DAEstatus::Failure;

//   VariantInit(&var);
//   V_BSTR(&var) = SysAllocString(L"c:\test.txt");
//   V_BSTR(&var) = SysAllocString(L"c:\test.txt");
//   V_VT(&var) = VT_BSTR;
   
   STATUS_CHECK_HR(m_pxmldom->loadXML(xml_string ,&b_status), status);
//   HRCALL(pXMLDom->load(var, &status), "");

   if (b_status!=VARIANT_TRUE) {
      STATUS_CHECK_HR(m_pxmldom->get_parseError(&pXMLErr),status);
      STATUS_CHECK_HR(pXMLErr->get_reason(&bstr),status);
                long line, linePos;
                
            pXMLErr->get_line(&line);
                pXMLErr->get_linepos(&linePos);
                pXMLErr->get_errorCode(&hr);

                status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "XML parse error %S at line %d char %d", bstr, line, linePos);
                SysFreeString(bstr);
                pXMLErr->Release();

                return DAEstatus::Failure;     
   }
   processAllElements(true, status);


//   processElements(pXMLDom, L"DBL", lab_file.dbl_list, lab_file.n_dbl, true);
//clean:
//   if (bstr) SysFreeString(bstr);
  // if (&var) VariantClear(&var);
  // if (pXMLErr) pXMLErr->Release();
  // if (pXMLDom) pXMLDom->Release();
//   CoUninitialize();
   return DAEstatus::Success;
}

int LabviewXML::loadFromFile(const char* filename, DAEstatus& status)
{
//   HRCALL(pXMLDom->load(var, &status), "");
   int i, stat;
   struct stat stat_struct;
   FILE *f = _fsopen(filename, "rtN", _SH_DENYWR);
   if (f == NULL)
   {
           status.addVa(FAC_DAE, SEV_ERROR, ERRTYPE_OUTOFMEM, "LabvieXML: cannot open \"%s\"", filename);
           return DAEstatus::Failure;
   }
   fstat(fileno(f),&stat_struct);
   char* buffer = new char[stat_struct.st_size+1];
   int n = fread(buffer, 1, stat_struct.st_size, f);
   fclose(f);
   // labview can have nulls embedded
   for(i=0; i<n; i++)
   {
           if (buffer[i] == '\0')
           {
                   buffer[i] = ' ';
           }
   }
   buffer[n] = '\0';
   CComBSTR b(n, buffer);
   stat = loadFromString(b, status);
   delete[] buffer;
   return stat;
}

// copy all values in lvxml across to us, but keeping the rest of our content unchanged
int LabviewXML::updateFrom(const LabviewXML& lvxml, DAEstatus& status)
{
        const char *name;
        c_iterator_t iterator = lvxml.m_list.begin();
        while(iterator != lvxml.m_list.end())
        {
                name = iterator->first.c_str();
                const std::vector<std::string>& value = (iterator->second).value;
                setValue(name, value, status);
                ++iterator;
        }
   return DAEstatus::Success;
}

int LabviewXML::updateFromString(const std::string& xml_string, DAEstatus& status)
{
        return updateFromString(xml_string.c_str(), status);
}

int LabviewXML::updateFromString(const char* xml_chars, DAEstatus& status)
{
        LabviewXML lvxml(status);
        if (lvxml.loadFromString(xml_chars, status) == DAEstatus::Success)
        {
                return updateFrom(lvxml, status);
        }
        else
        {
                return DAEstatus::Failure;
        }
}