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"
 
#include <qglobal.h>
#if QT_VERSION < 0x040000
    typedef QValueList<QVariant> QVariantList;
#endif
 
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 );
 
};
 
#ifdef EMTEST_XSCALE
template<>
inline bool UniversalDictionary::GetData<QVariantList>( const int32_t key, QVariantList &data )
{
    QVariant qvariantValue;
    bool ok = GetQVariantByKey( key, qvariantValue );
    if ( ok == false )
    {
        return false;
    }
 
    if ( qvariantValue.canCast( QVariant::List ) == true )
    {
        data = qvariantValue.toList();
        return true;
    }
 
    return false;
}
 
#endif // EMTEST_XSCALE
 
#endif // UniversalDictionary_H