metatype.h

Go to the documentation of this file.

/*
  This file is part of the Cutelee template system.
 
  Copyright (c) 2010 Michael Jansen <kde@michael-jansen.biz>
  Copyright (c) 2010 Stephen Kelly <steveire@gmail.com>
 
  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.1 of the Licence, or (at your option) any later version.
 
  This library 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
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 
*/
 
#ifndef CUTELEE_METATYPE_H
#define CUTELEE_METATYPE_H
 
#include "cutelee_templates_export.h"
 
#include "typeaccessor.h"
 
#include <QtCore/QVariant>
 
 
namespace Cutelee
{
 
 
#ifndef Q_QDOC
class CUTELEE_TEMPLATES_EXPORT MetaType
{
public:
  typedef QVariant (*LookupFunction)(const QVariant &, const QString &);
 
  static void registerLookUpOperator(int id, LookupFunction f);
 
  static void internalLock();
 
  static void internalUnlock();
 
  static QVariant lookup(const QVariant &object, const QString &property);
 
  static bool lookupAlreadyRegistered(int id);
 
private:
  MetaType();
};
#endif
 
namespace
{
 
/*
  This is a helper to select an appropriate overload of indexAccess
 */
template <typename RealType, typename HandleAs> struct LookupTrait {
  static QVariant doLookUp(const QVariant &object, const QString &property)
  {
    typedef typename Cutelee::TypeAccessor<RealType> Accessor;
    return Accessor::lookUp(object.value<RealType>(), property);
  }
};
 
template <typename RealType, typename HandleAs>
struct LookupTrait<RealType &, HandleAs &> {
  static QVariant doLookUp(const QVariant &object, const QString &property)
  {
    typedef typename Cutelee::TypeAccessor<HandleAs &> Accessor;
    return Accessor::lookUp(object.value<HandleAs>(), property);
  }
};
 
template <typename RealType, typename HandleAs> static int doRegister(int id)
{
  if (MetaType::lookupAlreadyRegistered(id))
    return id;
 
  QVariant (*lf)(const QVariant &, const QString &)
      = LookupTrait<RealType, HandleAs>::doLookUp;
 
  MetaType::registerLookUpOperator(
      id, reinterpret_cast<MetaType::LookupFunction>(lf));
 
  return id;
}
 
/*
  Register a type so cutelee knows how to handle it.
 */
template <typename RealType, typename HandleAs> struct InternalRegisterType {
  static int doReg()
  {
    const int id = qMetaTypeId<RealType>();
    return doRegister<RealType &, HandleAs &>(id);
  }
};
 
template <typename RealType, typename HandleAs>
struct InternalRegisterType<RealType *, HandleAs *> {
  static int doReg()
  {
    const int id = qMetaTypeId<RealType *>();
    return doRegister<RealType *, HandleAs *>(id);
  }
};
}
 
template <typename RealType, typename HandleAs> int registerMetaType()
{
  MetaType::internalLock();
 
  const int id = InternalRegisterType<RealType, HandleAs>::doReg();
 
  MetaType::internalUnlock();
 
  return id;
}
 
#ifndef Q_QDOC
template <typename Type> int registerMetaType()
{
  return registerMetaType<Type, Type>();
}
 
#endif
} // namespace Cutelee
 
#define CUTELEE_BEGIN_LOOKUP(Type)                                            \
  namespace Cutelee                                                           \
  {                                                                            \
  template <>                                                                  \
  inline QVariant TypeAccessor<Type &>::lookUp(const Type &object,             \
                                               const QString &property)        \
  {
 
#define CUTELEE_BEGIN_LOOKUP_PTR(Type)                                        \
  namespace Cutelee                                                           \
  {                                                                            \
  template <>                                                                  \
  inline QVariant TypeAccessor<Type *>::lookUp(const Type *const object,       \
                                               const QString &property)        \
  {
 
#define CUTELEE_END_LOOKUP                                                    \
  return QVariant();                                                           \
  }                                                                            \
  }
 
#endif // #define CUTELEE_METATYPE_H