VariantMarshal.h

 
#pragma once
 
#include <QVariant>
#include <knowCore/BigNumber.h>
#include <knowRDF/Literal.h>
 
namespace knowRDF
{
  template<typename _T_>
  struct VariantMarshal;
  
  template<typename _T_, typename _DO_NOT_SPECIALISED_ = void>
  QVariant toVariant(const _T_& _t)
  {
    return VariantMarshal<_T_>::convert(_t);
  }
  namespace details
  {
    template<typename _T_>
    knowCore::ReturnValue<_T_> fromVariant(const QVariant& _t)
    {
      if(_t.userType() == knowRDF::LiteralMetaTypeInformation::id())
      {
        return _t.value<knowRDF::Literal>().value<_T_>();
      }
      return VariantMarshal<_T_>::convert(_t);
    }
    template<>
    knowCore::ReturnValue<knowCore::BigNumber> fromVariant<knowCore::BigNumber>(const QVariant& _t)
    {
      return knowCore::BigNumber::from(_t);
    }
    template<>
    knowCore::ReturnValue<knowRDF::Literal> fromVariant<knowRDF::Literal>(const QVariant& _t)
    {
      return knowRDF::Literal::fromVariant(_t); //TODO this would VariantMarshal should be removed in knowCore 2
    }
  }
  template<typename _T_>
  auto fromVariant = details::fromVariant<_T_>;
 
  template<typename _T_>
  struct VariantMarshal
  {
    static QVariant convert(const _T_& _t)
    {
      return QVariant::fromValue(_t);
    }
    static _T_ convert(const QVariant& _t)
    {
      return _t.value<_T_>();
    }
  };
  template<>
  struct VariantMarshal<QVariant>
  {
    static QVariant convert(const QVariant& _t)
    {
      return _t;
    }
  };
  template<typename _T_>
  struct VariantMarshal<QList<_T_>>
  {
    static QVariant convert(const QList<_T_>& _t)
    {
      QVariantList list;
      for(const _T_& st : _t)
      {
        list.append(toVariant(st));
      }
      return list;
    }
    static QList<_T_> convert(const QVariant& _t)
    {
      QList<_T_> list;
      for(const QVariant& st : _t.toList())
      {
        list.append(fromVariant<_T_>(st));
      }
      return list;
    }
  };
  template<>
  struct VariantMarshal<knowRDF::Literal>
  {
    static QVariant convert(const knowRDF::Literal& _t)
    {
      return _t.toVariant();
    }
    static knowRDF::Literal convert(const QVariant& _t)
    {
      return knowRDF::Literal::fromVariant(_t).expectSuccess(); //TODO this would VariantMarshal should be removed in knowCore 2
    }
  };
}