kopeteproperties.h

Go to the documentation of this file.

/*
    kopeteproperties.h - Kopete Properties

    Copyright (c) 2004      by Richard Smith         <kde@metafoo.co.uk>
    Kopete    (c) 2002-2004 by the Kopete developers <kopete-devel@kde.org>

    *************************************************************************
    *                                                                       *
    * This library is free software; you can redistribute it and/or         *
    * modify it under the terms of the GNU Lesser General Public            *
    * License as published by the Free Software Foundation; either          *
    * version 2 of the License, or (at your option) any later version.      *
    *                                                                       *
    *************************************************************************
*/

#ifndef KOPETEPROPERTIES_H
#define KOPETEPROPERTIES_H

#include <QMultiHash>
#include <QVariant>

#include <typeinfo>

class QString;
class QDomElement;

namespace Kopete
{

namespace Properties
{

//BEGIN core functionality

template<class Parent>
class PropertyBase
{
public:
    virtual const QByteArray &name() const = 0;
};

template<class Parent, typename Type>
class Property : public PropertyBase<Parent>
{
public:
    virtual Type get( const Parent *parent ) const = 0;
    virtual void set( Parent *, const Type & ) const = 0;
};

struct PropertyData
{
    virtual ~PropertyData() {}
};

class PropertyStorage
{
    typedef QMultiHash<QByteArray, PropertyData*> PropertyDict;
    // setCustomPropertyData can be called on a const object, allowing the
    // guarantee that DataProperty::data() never returns 0.
    mutable PropertyDict _storage;

public:
    PropertyStorage() {}
    ~PropertyStorage()
    {
        qDeleteAll(_storage);
    }

    void setCustomPropertyData( const QByteArray &name, PropertyData *data ) const { _storage.replace( name, data ); }

    PropertyData *getCustomPropertyData( const QByteArray &name ) const { return _storage.value(name); }
};

template<class Parent>
class WithProperties : public PropertyStorage
{
public:
    template<typename T>
    T property( Property<Parent,T> const &prop ) { return prop.get( static_cast<Parent*>(this) ); }
    template<typename T>
    void setProperty( Property<Parent,T> const &prop, const T &value ) { prop.set( static_cast<Parent*>(this), value ); }

    static void propertyCreated( const PropertyBase<Parent> &property );
};

//END core functionality

//BEGIN interfaces

template<class Parent>
struct UserVisible
{
    virtual QString userText( Parent * ) = 0;
    virtual QString label() = 0;
    virtual QString icon() = 0;
};

template<class Parent>
struct XMLSerializable
{
    virtual void fromXML( Parent *, const QDomElement & ) = 0;
    virtual void toXML( const Parent *, QDomElement & ) = 0;
};

template<class Parent>
struct StringSerializable
{
    virtual void fromString( Parent *, const QString & ) = 0;
    virtual QString toString( const Parent * ) = 0;
};

//END interfaces

//BEGIN convenience classes

void customPropertyDataIncorrectType( const char *name, const std::type_info &found, const std::type_info &expected );

template<class Parent, typename Type, class Data>
class DataProperty : public Property<Parent,Type>
{
public:
    Data *data( const Parent *c ) const
    {
        PropertyData *pd = c->getCustomPropertyData( this->name() );
        Data *data = dynamic_cast<Data*>(pd);
        if ( !data )
        {
            if ( pd )
                customPropertyDataIncorrectType( this->name(), typeid(*pd), typeid(Data) );
            data = new Data;
            c->setCustomPropertyData( this->name(), data );
        }
        return data;
    }
};

template<typename T>
struct SimplePropertyData : public PropertyData
{
    SimplePropertyData() : value() {}
    T value;
};

template<class Parent, typename Type>
class SimpleDataProperty : public DataProperty<Parent,Type,SimplePropertyData<Type> >
{
public:
    Type get( const Parent *p ) const { return data(p)->value; }
    void set( Parent *p, const Type &v ) const { data(p)->value = v; }
};

template<class T> T variantTo(QVariant);

QVariant variantFromXML(const QDomElement&);
void variantToXML(QVariant v, QDomElement &);

template<class Derived, class Parent, typename Type>
class XMLProperty : public XMLSerializable<Parent>
{
public:
    void fromXML( Parent *t, const QDomElement &e )
    {
        static_cast<Derived*>(this)->set(t, variantTo<Type>(variantFromXML(e)));
    }
    void toXML( const Parent *t, QDomElement &e )
    {
        variantToXML(QVariant(static_cast<Derived*>(this)->get(t)),e);
    }
};

//END convenience classes

} // namespace Properties

} // namespace Kopete

#endif