UniversalDictionary.h

Go to the documentation of this file.

#ifndef UNIVERSALDICTIONARY_H
#define UNIVERSALDICTIONARY_H

#include "StorageItem.h"
#include <qvariant.h>
#include <utility>
#include <map>
#include "core/common/eplatform.h"

class UniversalDictionary : public StorageItem
{
public:
    UniversalDictionary( const int32_t &storageDataType );
    UniversalDictionary( const UniversalDictionary &otherInstance );
    virtual ~UniversalDictionary();

    virtual StorageItem *Clone();
    virtual QString WhoAmI() const;
    virtual int32_t GetStorageDataType() const;

    void AddItem( const long key, const QVariant &value );
    void AddItem( const long key, void *value );

    void AddExistingDictionary( const UniversalDictionary *copiedDictionary );

    DEPRECATED( bool GetBool( const long key, bool &data ) );
    DEPRECATED( bool GetNumber( const long key, long &data ) );
    DEPRECATED( bool GetNumber( const long key, unsigned long &data ) );
    DEPRECATED( bool GetString( const long key, QString &data ) );
    DEPRECATED( bool GetPointer( const long key, void *&data ) );

#ifdef EMTEST_XSCALE
    bool GetData( const int32_t key, QString &data )
    {
        QVariant qvariantValue;
        bool ok = GetQVariantByKey( key, qvariantValue );
        if ( ok == false )
        {
            return false;
        }

        if ( qvariantValue.canCast( QVariant::String ) == true )
        {
            data = qvariantValue.toString();
            return true;
        }

        return false;
    }
#endif

    template<typename T>
    bool GetData( const int32_t key, T &data )
    {
        QVariant qvariantValue;
        bool ok = GetQVariantByKey( key, qvariantValue );
        if ( ok == false )
        {
            return false;
        }

        QVariant returnValue( data );
#ifdef EMTEST_XSCALE
        if ( qvariantValue.canCast( returnValue.type() ) == true )
        {
            QVariant::Type type = qvariantValue.type();
            switch( type )
            {
                case QVariant::Bool:
                {
                    data = qvariantValue.toBool();
                }
                break;

                case QVariant::String:
                {
                    // RDU - toString() tu nemoze byt kvoli chybe kompilacie (invalidconversion from `const char*' to `int'). Na ziskanie QString sa pouzije samostatna metoda.
                    //data = qvariantValue.toString();
                    return false;
                }
                break;

                case QVariant::Int:
                case QVariant::LongLong:
                {
                    data = qvariantValue.toInt();
                }
                break;

                case QVariant::UInt:
                case QVariant::ULongLong:
                {
                    data = qvariantValue.toUInt();
                }
                break;

                default:
                {
                    return false;
                }
            }
        }
#else
        if ( qvariantValue.canConvert( returnValue.type() ) == true )
        {
            data = qvariant_cast<T>( qvariantValue );
        }
#endif
        else
        {
            return false;
        }

        return true;
    }

    template<typename T>
    bool GetPointer( const int32_t key, T &data )
    {
        void *rawPointer = NULL;
        bool ok = GetRawPointerByKey( key, rawPointer );
        if ( ok == false )
        {
            return false;
        }

        data = ( T )rawPointer;
        return true;
    }

    bool RemoveItem( const int32_t &key );

    unsigned short GetSize();

    UniversalDictionary &operator =( const UniversalDictionary &otherInstance );
    UniversalDictionary &operator =( const UniversalDictionary *otherInstance );

#ifdef DEVELOP
    virtual void PrintToLog();
#endif

private:

    class DataClass;
    DataClass *d;

    bool GetRawPointerByKey( const int32_t key, void *&rawPointer );
    bool GetQVariantByKey( const int32_t key, QVariant &variant );

};

#endif // UniversalDictionary_H