// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//

#ifndef IDENTIFIERBASE_H
#define IDENTIFIERBASE_H

#include <string>

namespace Parser
{

/**
The types of identifiers
*/
enum TIdentifierType
    {
    /** Constants (only integer constants supported) */
    EConstIdentifier,

    /** Any integer type (INTx/UINTx) */
    EIntegerTypeIdentifier,

    /** The enumeration type - contains enumeration value types */
    EEnumTypeIdentifier,

    /** The enumation value type that represents the values contained in an enumeration */
//    EEnumValueIdentifier,

    /** A user defined structure */
    EStructIdentifier,

    /** A user defined signature */
    ESignatureIdentifier,

    /** A user defined context */
    EContextIdentifier,

    /** A user definied message */ 
    EMessageIdentifier,

    /** Identifies padding bytes */
    EPadTypeIdentifier,

    /** The builtin struct for TMessageId */
    EMessageIdTypeIdentifier,
    };

/**
CIdentifierBase is an abstract class that provides the base functionality
for any basic or builtin types.
*/
class CIdentifierBase
    {
    public:
        /**
        D'tor
        */
        virtual ~CIdentifierBase();

        /**
        Returns the type of identifier that this identifier is
        @see TIdentifierType
        */
        inline TIdentifierType Type() const
            {
            return iType;
            }

        /**
        Returns the unique name that identifies this identifier
        */
        inline const char* Name() const
            {
            return iName;
            }

        /**
        Returns identifier flags
        */
        inline int Flags() const
            {
            return iFlags;
            }
        
        /** Returns the size of this type in bytes */
        int Size() const;

        /** Returns the size of this type in bytes including the size of any base types */
        virtual int TotalSize() const;

        /**
        Formats the data provided according to the layout of the type represented by
        the implementation and outputs it to the stream.
        @param aData A pointer to the buffer containing the data for this type.
        @param aLength The number of bytes believed to belong to this type.
               It should match the TotalSize() of the identifier.
        @param aOptions A pointer to an identifier type specific object containing
               options that the type will understand and can use to alter the output
               formatting on a per item basis. This usually comes from TMember.
        @param aDescription The stream to output to.
        */
        virtual void Describe(const unsigned char* aData, unsigned int aLength, const void* aOptions, std::ostream& aDescription) const = 0;

    protected:
        explicit CIdentifierBase(TIdentifierType aType, const char* aName)
            {
            iType = aType;
            iName = _strdup(aName);
            iSize = 0;
            iFlags = 0;
            }

    protected:
        int iSize; // The size of this type in bytes
        int iFlags;

    private:
        TIdentifierType iType;
        char* iName;
    };
    

/**
TMember represents a data member of a structure style type.
These are STRUCT, CONTEXT, and SIGNATURE.
*/
struct TMember
    {
    public:
        TMember()
            : iMemberType(NULL), iOffset(0), iArraySize(1), iIdentifierOptions(NULL)
            {
            }

        const CIdentifierBase* iMemberType;
        std::string iMemberName;
        int iOffset;
        int iArraySize;
        void* iIdentifierOptions;
    };

} // namespace Parser

#endif
// IDENTIFIERBASE_H