ValueMarshal.h

#pragma once
 
#include <knowCore/Value.h>
#include <knowCore/ValueList.h>
#include <knowRDF/Literal.h>
#include <knowCore/Uris/askcore_types.h>
 
namespace knowRDF
{
  template<typename _T_>
  struct ValueMarshal;
  
  template<typename _T_, typename _DO_NOT_SPECIALISED_ = void>
  knowCore::ReturnValue<knowCore::Value> toValue(const _T_& _t)
  {
    return ValueMarshal<_T_>::convert(_t);
  }
  
  template<typename _T_>
  knowCore::ReturnValue<_T_> fromValue(const knowCore::Value& _t)
  {
    return ValueMarshal<_T_>::convert(_t);
  }
 
  template<typename _T_>
  struct ValueMarshal
  {
    static knowCore::ReturnValue<knowCore::Value> convert(const _T_& _t)
    {
      return kCrvReturnResult(knowCore::Value::fromValue(_t));
    }
    static knowCore::ReturnValue<_T_> convert(const knowCore::Value& _t)
    {
      return _t.value<_T_>();
    }
  };
  template<>
  struct ValueMarshal<knowCore::Value>
  {
    static knowCore::ReturnValue<knowCore::Value> convert(const knowCore::Value& _t)
    {
      return kCrvSuccess(_t);
    }
  };
  template<typename _T_>
  struct ValueMarshal<QList<_T_>>
  {
    static knowCore::ReturnValue<knowCore::Value> convert(const QList<_T_>& _t)
    {
      QList<knowCore::Value> values;
      for(const _T_& st : _t)
      {
        KNOWCORE_RETURN_VALUE_TRY(value, toValue(st));
        values.append(value);
      }
      return kCrvReturnResult(knowCore::Value::fromValue(knowCore::ValueList(values)));
    }
    static knowCore::ReturnValue<QList<_T_>> convert(const knowCore::Value& _t)
    {
      QList<_T_> list;
      KNOWCORE_RETURN_VALUE_TRY(value_list, _t.toList());
      for(const knowCore::Value val : value_list.values())
      {
        KNOWCORE_RETURN_VALUE_TRY(val_t, fromValue<_T_>(val));
        list.append(val_t);
      }
      return kCrvSuccess(list);
    }
  };
}