element.h

/***************************************************************************
*   Copyright (C) 2014 by Okkel Klaver   *
*   info@vanhetland.nl   *
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
*   This program is distributed in the hope that it will be useful,       *
*   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
*   GNU General Public License for more details.                          *
*                                                                         *
*   You should have received a copy of the GNU General Public License     *
*   along with this program; if not, write to the                         *
*   Free Software Foundation, Inc.,                                       *
*   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
***************************************************************************/

#ifndef SEPARATISTA_ELEMENT_H
#define SEPARATISTA_ELEMENT_H

#include <ctime>
#include <string>
#include <map>
#include <vector>
#include <sstream>
#include <Windows.h>

#include "separatista/separatista.h"
#include "separatista/xerces_types.h"
#include "separatista/debug/debug.h"
#include "separatista/elementdescriptor.h"
#include "separatista/exception.h"

namespace Separatista
{
    // Forward decl
    class ElementException;
    class UnsupportedElementException;

    class ElementListener
    {
    public:
        virtual void elementValueChanged(Element *pElement, const wchar_t *pNewValue) = 0;
        virtual void elementCreated(Element *pParent, Element *pChild) = 0;
        virtual void elementDeleted(Element *pElement) = 0;
    };

    
    class SEPARATISTA_EXTERN Element
    {
    public:
        enum ErrorOptions
        {
            ThrowExceptions = 0,
            ClearValue,
            AcceptValue
        };

        const ElementDescriptor* getElementDescriptor() const;
        
        virtual IOErrorCode toDOMDocument(xercesc::DOMDocument *pDOMDocument, xercesc::DOMElement *pDOMParent, const ErrorOptions errorOptions = ThrowExceptions) const = 0;

        virtual void fromDOMDocument(xercesc::DOMElement *pDOMElement, const ErrorOptions errorOptions = ThrowExceptions) = 0;

        void addElementListener(ElementListener* pElementListener);

        void removeElementListener(ElementListener* pElementListener);

        const wchar_t* getTag() const;

        virtual Element* getElementByTag(const wchar_t *pTagName, size_t nIndex = 0) const;

        virtual Element* createElementByTag(const wchar_t *pTagName, size_t nIndex = 0);

        virtual void destroyElement(Element *pChildElement);

        virtual const wchar_t* getTextValue() const;

        virtual void setValue(const wchar_t *pValue, const ErrorOptions errorOptions = ThrowExceptions);

        virtual const wchar_t* getAttributeValue(const wchar_t *pAttributeName) const;

        virtual void setAttributeValue(const wchar_t *pAttributeName, const wchar_t *pValue);

        time_t getDateValue() const;

        void setValue(const time_t Value, bool bWithTime = false, const ErrorOptions errorOptions = ThrowExceptions);

        int getIntValue() const;

        void setValue(const int Value, const ErrorOptions errorOptions = ThrowExceptions);

        double getDoubleValue() const;

        void setValue(const double d, const ErrorOptions errorOptions = ThrowExceptions);

        bool isEmpty() const;

        class TagKey
        {
        public:
            TagKey(const wchar_t *pTagName, size_t  nIndex, const ElementDescriptor *pBranchElementDescriptor);

            bool operator <(const TagKey &Other) const;

            bool operator ==(const TagKey &Other) const;

            static unsigned int HashKey(const wchar_t *pTagName);

            const wchar_t* getTagName() const;
            
            unsigned int getHash() const;

        private:
            size_t m_nIndex;
            const wchar_t *m_pTagName;
            unsigned int m_nHash;
            const ElementDescriptor *m_pBranchElementDescriptor;
        };

        typedef std::map<const TagKey, Element*> TagKeyMap;

        typedef struct
        {
            TagKeyMap::const_iterator m_begin;
            TagKeyMap::const_iterator m_end;
        } TagKeyRange;

        virtual TagKeyRange getAllByTagName(const wchar_t *pTagName);

    protected:
        Element(const ChildElementDescriptor* pChildElementDescriptor);

        virtual ~Element();

        Element* getParentElement() const;

        static void deleteElement(Element *pChildElement);

        void onElementValueChanged(const wchar_t *pNewValue);

        void onElementCreated(Element *pChildElement);

        void onElementDeleted();

    private:
        const ChildElementDescriptor *m_pChildElementDescriptor;
        
        std::vector<ElementListener*> m_ElementListeners;

        Element *m_pParent;

        const wchar_t *m_pTag;
    };
}

#endif // ifndef SEPARATISTA_ELEMENT_H