/*
 * SAXAttributes.h 
 * Copyright (c) 2011 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// SOL9
// 2011/01/27
#pragma once
#include <sol/xml/XMLObject.h>
#include <sol/WString.h>

// Simple C++ wrapper class to ISAXAttributes.
// SAXAttribute is a list of 'readonly' XMLf attributes

namespace SOL {

class SAXAttributes : public XMLObject {
private:
    MSXML2::ISAXAttributesPtr pAttributes;

public:
    SAXAttributes(MSXML2::ISAXAttributes* attr)
        :pAttributes(attr)
    {
    }

public:
    ~SAXAttributes()
    {
        pAttributes = NULL;
    }

public:
    MSXML2::ISAXAttributesPtr getAttributesPtr()
    {
        if (pAttributes == NULL) {
            throw Exception("Error: SAXAttributes is NULL");
        }
        return pAttributes;
    }
    int getLength()
    {
        return getAttributesPtr() -> getLength();
    }

    HRESULT getURI(
        __in int nIndex,
        __out _bstr_t& url)
    {
        unsigned short* pwchUrl = NULL;
        int    cchUrl = 0;
        HRESULT hr = getAttributesPtr() -> getURI(nIndex, &pwchUrl, &cchUrl);
        if(SUCCEEDED(hr)) {
            WString wurl(pwchUrl, cchUrl);
            url =(const wchar_t*)wurl;
        } else {
            throw hr;
        }
        return hr;
    }

    HRESULT getLocalName(
        __in int nIndex,
        __out _bstr_t& localName)
    {
        unsigned short* pwchLocalName = NULL;
        int    cchLocalName = 0;
        HRESULT hr = getAttributesPtr() -> getLocalName(nIndex, &pwchLocalName, &cchLocalName);
        if(SUCCEEDED(hr)) {
            WString wlocalName(pwchLocalName, cchLocalName);
            localName =(const wchar_t*)wlocalName;
        } else {
            throw hr;
        }
        return hr;
    }

    HRESULT getQName(
        __in int nIndex,
        __out _bstr_t& qName)
    {
        unsigned short* pwchQName = NULL;
        int    cchQName = 0;
        HRESULT hr = getAttributesPtr() -> getQName(nIndex, &pwchQName, &cchQName);
        if(SUCCEEDED(hr)) {
            WString wqName(pwchQName, cchQName);
            qName =(const wchar_t*)wqName;
        } else {
            throw hr;
        }
        return hr;
    }

    HRESULT getName(
        __in int nIndex,
        __out _bstr_t& url,
        __out _bstr_t& localName,
        __out _bstr_t& qName)
    {
        unsigned short* pwchUrl = NULL;
        int    cchUrl = 0;

        unsigned short* pwchLocalName = NULL;
        int    cchLocalName = 0;

        unsigned short* pwchQName = NULL;
        int    cchQName = 0;
        HRESULT hr = getAttributesPtr() -> getName(nIndex, 
                &pwchUrl, &cchUrl,
                &pwchLocalName, &cchLocalName, 
                &pwchQName, &cchQName);
        if(SUCCEEDED(hr)) {
            WString wurl(pwchUrl, cchUrl);
            WString wlocalName(pwchLocalName, cchLocalName);
            WString wqName(pwchQName, cchQName);
            url =(const wchar_t*)wurl;
            localName =(const wchar_t*)wlocalName;
            qName =(const wchar_t*)wqName;

        } else {
            throw hr;
        }
        return hr;
    }

    int getIndexFromName(
        __in const _bstr_t url,
        __in const _bstr_t localName)
    {
        return getAttributesPtr() -> getIndexFromName(toShort(url), url.length(),
            toShort(localName), localName.length());
    }


    int getIndexFromQName(__in const _bstr_t qName)
    {
        return getAttributesPtr() -> getIndexFromQName(toShort(qName), qName.length());
    }

    HRESULT getType(
        __in int nIndex,
        __out _bstr_t& type)
    {
        unsigned short* pwchType = NULL;
        int    cchType = 0;
        HRESULT hr = getAttributesPtr() -> getType(nIndex, &pwchType, &cchType);
        if(SUCCEEDED(hr)) {
            WString wtype(pwchType, cchType);
            type =(const wchar_t*)wtype;
        } else {
            throw hr;
        }
        return hr;
    }

    HRESULT getTypeFromName(
        __in const _bstr_t url,
        __in const _bstr_t localName,
        __out _bstr_t& type)
    {
        unsigned short* pwchType = NULL;
        int    cchType = 0;
        HRESULT hr = getAttributesPtr() -> getTypeFromName(toShort(url), url.length(),
                toShort(localName), localName.length(),
                &pwchType, &cchType);
        if(SUCCEEDED(hr)) {
            WString wtype(pwchType, cchType);
            type =(const wchar_t*)wtype;
        } else {
            throw hr;
        }
        return hr;
    }

    HRESULT getTypeFromQName(
        __in const _bstr_t qName,
        __out _bstr_t& type)
    {
        unsigned short* pwchType = NULL;
        int    cchType = 0;
        HRESULT hr = getAttributesPtr() -> getTypeFromQName(toShort(qName), qName.length(),
                &pwchType, &cchType);
        if(SUCCEEDED(hr)) {
            WString wtype(pwchType, cchType);
            type =(const wchar_t*)wtype;
        } else {
            throw hr;
        }
        return hr;
    }

    HRESULT getValue(
        __in int nIndex,
        __out _bstr_t& value)
    {
        unsigned short* pwchValue = NULL;
        int    cchValue = 0;
        HRESULT hr = getAttributesPtr() -> getValue(nIndex, &pwchValue, &cchValue);
        if(SUCCEEDED(hr)) {
            WString wvalue(pwchValue, cchValue);
            value =(const wchar_t*)wvalue;
        } else {
            throw hr;
        }
        return hr;
    }

    HRESULT getValueFromName(
        __in const _bstr_t url,
        __in const _bstr_t localName,
        __out _bstr_t& value)
    {
        unsigned short* pwchValue = NULL;
        int    cchValue = 0;
        HRESULT hr = getAttributesPtr() -> getValueFromName(toShort(url), url.length(),
                toShort(localName), localName.length(),
                &pwchValue, &cchValue);
        if(SUCCEEDED(hr)) {
            WString wvalue(pwchValue, cchValue);
            value =(const wchar_t*)wvalue;
        } else {
            throw hr;
        }
        return hr;
    }

    HRESULT getValueFromQName(
        __in const _bstr_t qName,
        __out _bstr_t& value)
    {
        unsigned short* pwchValue = NULL;
        int    cchValue = 0;
        HRESULT hr = getAttributesPtr() -> getValueFromQName(toShort(qName), qName.length(),
            &pwchValue, &cchValue);
        if(SUCCEEDED(hr)) {
            WString wvalue(pwchValue, cchValue);
            value =(const wchar_t*)wvalue;
        } else {
            throw hr;
        }
        return hr;
    }

public:
    virtual void display()
    {
        int len = getLength();
        if(len <1) {
            return;
        }

        for(int i = 0; i<len; i++) {
            try {
                _bstr_t qName= L"";
                _bstr_t value = L"";
                getQName(i, qName);

                getValue(i, value);
                printf(" %S=\"%S\"",(const wchar_t*)qName,(const wchar_t*)value);
            } catch(HRESULT hr) {
                printf("Exception SAXAttributes::display HRESULT=0x%08x\n", hr);
            } catch(...) {
                printf("Exception SAXAttributes::display\n");
            }
        }
    }
};

}