src/klftools/klfpobj.h

Go to the documentation of this file.

/***************************************************************************
 *   file klfpobj.h
 *   This file is part of the KLatexFormula Project.
 *   Copyright (C) 2011 by Philippe Faist
 *   philippe.faist at bluewin.ch
 *                                                                         *
 *   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.             *
 ***************************************************************************/
/* $Id$ */


#ifndef KLFPOBJ_H
#define KLFPOBJ_H

#include <QDebug>
#include <QVariant>
#include <QByteArray>
#include <QDataStream>
#include <QTextStream>
#include <QVector>
#include <QList>
#include <QMap>
#include <QStringList>

#include <klfdefs.h>




class KLF_EXPORT KLFAbstractPropertizedObject
{
public:
  KLFAbstractPropertizedObject();
  virtual ~KLFAbstractPropertizedObject();

  virtual QString objectKind() const = 0;

  virtual QVariant property(const QString& propName) const = 0;

  virtual QStringList propertyNameList() const = 0;

  virtual bool setProperty(const QString& pname, const QVariant& value) = 0;


  virtual QMap<QString,QVariant> allProperties() const;

  virtual bool setAllProperties(const QMap<QString,QVariant>& data);

  virtual bool hasFixedTypes() const { return false; }

  virtual QByteArray typeNameFor(const QString& property) const { Q_UNUSED(property); return QByteArray(); }

  virtual QByteArray typeSpecificationFor(const QString& property) const { Q_UNUSED(property); return QByteArray(); }
};


class KLF_EXPORT KLFSpecifyableType
{
public:
  KLFSpecifyableType();
  virtual ~KLFSpecifyableType();

  virtual QByteArray specification() const = 0;
  virtual bool setSpecification(const QByteArray& data) = 0;
};


class KLF_EXPORT KLFEnumType : public KLFSpecifyableType
{
  int val;
  QStringList enumVals;
public:
  KLFEnumType(int initvalue = 0) : val(initvalue), enumVals()
  {
  }
  KLFEnumType(const KLFEnumType& copy) : KLFSpecifyableType(), val(copy.val), enumVals(copy.enumVals)
  {
  }
  virtual ~KLFEnumType() { }

  inline int value() const
  {
    return val;
  }
  inline void setValue(int v)
  {
    val = v;
  }

  inline QString enumValue() const
  {
    if (val < 0 || val >= enumVals.size()) {
      klfWarning("Invalid value: "<<val<<" for enum values "<<enumVals) ;
      return QString();
    }
    return enumVals[val];
  }


  inline QStringList enumValues() const
  {
    return enumVals;
  }
  inline void setEnumValues(const QStringList& list)
  {
    enumVals = list;
  }

  QByteArray specification() const
  {
    return enumVals.join(":").toUtf8();
  }

  bool setSpecification(const QByteArray& data)
  {
    // parse enum values
    setEnumValues(QString::fromUtf8(data).split(QRegExp(":")));
    return true;
  }

};


Q_DECLARE_METATYPE(KLFEnumType) ;

KLF_EXPORT QDataStream& operator<<(QDataStream& stream, const KLFEnumType& e);
KLF_EXPORT QDataStream& operator>>(QDataStream& stream, KLFEnumType& e);
// exact matches
inline bool operator==(const KLFEnumType& a, const KLFEnumType& b)
{ return a.value() == b.value(); }




class KLFPObjPropRefHelper;


class KLF_EXPORT KLFPropertizedObject : public KLFAbstractPropertizedObject
{
public:
  explicit KLFPropertizedObject(const QString& propertyNameSpace);
  virtual ~KLFPropertizedObject();

  virtual QVariant property(const QString& propName) const;
  virtual QVariant property(int propId) const;
  virtual QVariant property(const QString& propName, const QVariant& defaultValue) const;
  virtual bool hasPropertyValue(const QString& propName) const;
  virtual bool hasPropertyValue(int propId) const;

  QList<int> propertyIdList() const;

  QStringList propertyNameList() const;

  QMap<QString,QVariant> allProperties() const;

  virtual bool setProperty(const QString& propname, const QVariant& value);

  virtual bool setProperty(int propId, const QVariant& value);

  virtual bool setAllProperties(const QMap<QString, QVariant>& propValues);


  QDataStream& streamInto(QDataStream& stream) const;

  QDataStream& streamFrom(QDataStream& stream);
  

  QByteArray allPropertiesToByteArray() const;

  void setAllPropertiesFromByteArray(const QByteArray& data);

  /*
  / ** \brief Parses a string representation of a property
   *
   * Subclasses should reimplement this function to parse the actual string into a value. Note
   * that this function should NOT set the property, it should just parse the string in a way
   * depending on what kind of information the property \c propId is supposed to store.
   *
   * The formatting is left to the implementation. It could be user input, for example.
   *
   * The default implementation calls \ref parsePropertyValue(const QString&, const QString&) .
   * It is thus enough for subclasses to reimplement the other method.
   * /
   virtual QVariant parsePropertyValue(int propId, const QString& strvalue);

   / ** \brief Parses a string representation of a property
   *
   * Subclasses should reimplement this function to parse the actual string into a value. Note
   * that this function should NOT set the property, it should just parse the string in a way
   * depending on what kind of information the property \c propName is supposed to store.
   *
   * The formatting is left to the implementation. It could be user input, for example.
   *
   * Since the base implementation has no idea what kind of information \c propId is supposed
   * to store, the default implementation returns a null \c QVariant().
   * /
   virtual QVariant parsePropertyValue(const QString& propName, const QString& strvalue);
  */


  enum ToStringFlag {
    ToStringUseHtml = 0x0001, 
    ToStringUseHtmlDiv = 0x0002, 
    ToStringQuoteValues = 0x0004, 
    ToStringAllProperties = 0x0008 
  };
  virtual QString toString(uint toStringFlags = 0) const;


  int propertyMaxId() const;

  bool propertyIdRegistered(int propId) const;

  bool propertyNameRegistered(const QString& propertyName) const;

  int propertyIdForName(const QString& propertyName) const;

  QString propertyNameForId(int propId) const;

  QList<int> registeredPropertyIdList() const;

  QStringList registeredPropertyNameList() const;

  QMap<QString, int> registeredProperties() const;

  virtual QString objectKind() const { return pPropNameSpace; }

protected:

  virtual void propertyValueChanged(int propId, const QVariant& oldValue,
                                    const QVariant& newValue);


  virtual bool doSetProperty(const QString& propname, const QVariant& value);

  virtual bool doSetProperty(int propId, const QVariant& value);

  virtual int doLoadProperty(const QString& propname, const QVariant& value);

  void registerBuiltInProperty(int propId, const QString& propName) const;

  int registerProperty(const QString& propertyName) const;

  static void registerBuiltInProperty(const QString& propNameSpace, int propId,
                                      const QString& name);

  static int registerProperty(const QString& propNameSpace, const QString& propertyName);

  static int propertyMaxId(const QString& propNameSpace);

  static bool propertyIdRegistered(const QString& propNameSpace, int propId);

  static bool propertyNameRegistered(const QString& propNameSpace, const QString& propertyName);

  static int propertyIdForName(const QString& propNameSpace, const QString& propertyName);

  static QString propertyNameForId(const QString& propNameSpace, int propId);

  static QList<int> registeredPropertyIdList(const QString& propNameSpace);

  static QStringList registeredPropertyNameList(const QString& propNameSpace);

  static QMap<QString, int> registeredProperties(const QString& propNameSpace);

  QString propertyNameSpace() const { return pPropNameSpace; }

  QVector<QVariant> propertyVector() const { return pProperties; }


  friend class KLFPObjPropRefHelper;

private:
  KLFPropertizedObject() { }

  QString pPropNameSpace;

  QVector<QVariant> pProperties;

  static int internalRegisterProperty(const QString& propNameSpace, const QString& name,
                                      int propId = -1);
  static QMap<QString, QMap<QString, int> > pRegisteredProperties;
  static QMap<QString, int> pRegisteredPropertiesMaxId;

  friend bool operator==(const KLFPropertizedObject& a, const KLFPropertizedObject& b);
};

bool operator==(const KLFPropertizedObject& a, const KLFPropertizedObject& b);

KLF_EXPORT QDataStream& operator<<(QDataStream& stream, const KLFPropertizedObject& obj);
KLF_EXPORT QDataStream& operator>>(QDataStream& stream, KLFPropertizedObject& obj);

KLF_EXPORT QTextStream& operator<<(QTextStream& stream, const KLFPropertizedObject& obj);

KLF_EXPORT QDebug& operator<<(QDebug& stream, const KLFPropertizedObject& obj);


class KLFPObjPropRefHelper
{
protected:
  void registerbuiltinprop(KLFPropertizedObject *obj, int propid, const QString& pname)
  {
    obj->registerBuiltInProperty(propid, pname);
  }
  QString propertyNameSpace(KLFPropertizedObject *obj) const { return obj->propertyNameSpace(); }
};

template<class T>
class KLF_EXPORT KLFPObjPropRef : private KLFPObjPropRefHelper
{
  KLFPropertizedObject *pPObj;
  int pPropId;
public:
  typedef T Type;

  KLFPObjPropRef(KLFPropertizedObject *pobj, int propId)
    : pPObj(pobj), pPropId(propId)
  {
  }
  KLFPObjPropRef(const KLFPObjPropRef& other)
    : pPObj(other.pPObj), pPropId(other.pPropId)
  {
  }
  KLFPObjPropRef(KLFPropertizedObject *pobj, int builtInPropId, const QString& pname)
    : pPObj(pobj), pPropId(builtInPropId)
  {
    init(pname);
  }
  KLFPObjPropRef(KLFPropertizedObject *pobj, int builtInPropId, const QString& pname, const T& value)
    : pPObj(pobj), pPropId(builtInPropId)
  {
    init(pname);
    set(value);
  }

  operator QVariant() const
  {
    return variantValue();
  }
  operator T() const
  {
    return value<T>();
  }
  const T operator ()() const
  {
    return value<T>();
  }
  const KLFPObjPropRef& operator=(const QVariant& v)
  {
    pPObj->setProperty(pPropId, v);
    return *this;
  }
  const KLFPObjPropRef& operator=(const T& value)
  {
    pPObj->setProperty(pPropId, QVariant::fromValue<T>(value));
    return *this;
  }
  const KLFPObjPropRef& operator=(const KLFPObjPropRef& value)
  {
    return this->operator=(value.value());
  }

  QVariant variantValue() const
  {
    return pPObj->property(pPropId);
  }

  const T value() const
  {
    return value<T>();
  }

  template<class VariantType>
  const T value() const
  {
    QVariant v = pPObj->property(pPropId);
    return T(v.value<VariantType>());
  }

  template<class VariantType>
  void set(const T& value)
  {
    pPObj->setProperty(pPropId, QVariant::fromValue<VariantType>(value));
  }
  void set(const T& value)
  {
    set<T>(value);
  }

  template<class VariantType>
  bool equals(const KLFPObjPropRef& other) const
  {
    return (value<VariantType>() == other.value<VariantType>());
  }
  bool equals(const KLFPObjPropRef& other) const
  {
    return equals<T>(other);
  }

  bool operator==(const T& val) const
  {
    return (value() == val);
  }
  bool operator==(const KLFPObjPropRef& other) const
  {
    return (value() == other.value());
  }

private:
  void init(const QString& pname)
  {
    if (!pPObj->propertyIdRegistered(pPropId)) {
      // from our helper base class
      registerbuiltinprop(pPObj, pPropId, pname);
    } else {
      // make sure the correct name was registered
      KLF_ASSERT_CONDITION(pPObj->propertyNameForId(pPropId) == pname,
                           qPrintable(propertyNameSpace(pPObj))<<": Built-In property ID "<<pPropId
                           <<" does not have name "<<pname<<" !",
                           ; ) ;
    }
  }

};

template<typename T>
inline QDebug & operator<<(QDebug & str, const KLFPObjPropRef<T> & p)
{
  return str << p();
}



// ----

class KLFPObjRegisteredType {
public:
  KLFPObjRegisteredType(const char *name)
  {
    doregister(Register, name);
  }

  static bool isRegistered(const char *name)
  {
    return doregister(Query, name);
  }

private:
  enum Action { Query, Register };
  static int doregister(Action action, const char * name)
  {
    static QList<QByteArray> registered_types;
    bool x;
    switch (action) {
    case Query: // is querying the existance of a registered type
      x = registered_types.contains(QByteArray(name));
      return x;
    case Register: // want to register the given type
      registered_types.append(QByteArray(name));
      return 0;
    default:
      fprintf(stderr, "ERRORORROOERROR: %s: what is your action?? `%d' for name `%s'\n",
              KLF_FUNC_NAME, (int)action, name);
    }
    return -1;
  }
};

#define KLF_DECLARE_POBJ_TYPE(TYPE)                                     \
  static KLFPObjRegisteredType __klf_pobj_regtype_##TYPE = KLFPObjRegisteredType(#TYPE) ;

class KLFSpecifyableRegisteredType {
public:
  KLFSpecifyableRegisteredType(const char *name)
  {
    doregister(Register, name);
  }

  static bool isRegistered(const char *name)
  {
    return doregister(Query, name);
  }

private:
  enum Action { Query, Register };
  static int doregister(Action action, const char * name)
  {
    static QList<QByteArray> registered_types;
    bool x;
    switch (action) {
    case Query: // is querying the existance of a registered type
      x = registered_types.contains(QByteArray(name));
      return x;
    case Register: // want to register the given type
      registered_types.append(QByteArray(name));
      return 0;
    default:
      fprintf(stderr, "ERRORORROORORR: %s: what is your action?? `%d' for name `%s'\n",
              KLF_FUNC_NAME, (int)action, name);
    }
    return -1;
  }
};

#define KLF_DECLARE_SPECIFYABLE_TYPE(TYPE)                                      \
  static KLFSpecifyableRegisteredType __klf_specifyable_regtype_##TYPE = KLFSpecifyableRegisteredType(#TYPE) ;



#endif