knowCore.h

#include <knowCore/BigNumber.h>
#include <knowCore/UriList.h>
#include <knowCore/ValueHash.h>
 
#include <knowRuby/ConverterManager.h>
 
#include "qt.h"
 
namespace Rice::detail
{
 
  // knowCore::ReturnValue
  template<typename _T_>
  struct Type<knowCore::ReturnValue<_T_>>
  {
    static bool verify()
    {
      return Type<_T_>::verify();
    }
  };
  template<typename _T_>
  struct To_Ruby<knowCore::ReturnValue<_T_>>
  {
    VALUE convert(const knowCore::ReturnValue<_T_>& x)
    {
      if(x.success())
      {
        _T_ t = x.value();
        return To_Ruby<_T_>().convert(t);
      } else {
        throw std::runtime_error(x.message().toStdString());
      }
    }
  };
  template<>
  struct Type<knowCore::ReturnVoid>
  {
    static bool verify()
    {
      return true;
    }
  };
  template<>
  struct To_Ruby<knowCore::ReturnVoid>
  {
    VALUE convert(const knowCore::ReturnVoid& x)
    {
      if(x.success())
      {
        return Qnil;
      } else {
        throw std::runtime_error(x.message().toStdString());
      }
    }
  };
 
 
  // knowCore::BigNumber
  template<>
  struct Type<knowCore::BigNumber>
  {
    static bool verify()
    {
      return true;
    }
  };
 
  template<>
  class To_Ruby<knowCore::BigNumber>
  {
  public:
    VALUE convert(knowCore::BigNumber const& x)
    {
      if(x.isFloating())
      {
        return To_Ruby<double>().convert(x.toDouble());
      } else {
        return rb_cstr_to_inum(qPrintable(x.toString()), 10, 1);
      }
    }
  };
 
  template<>
  class To_Ruby<knowCore::BigNumber&> : To_Ruby<knowCore::BigNumber>
  {
  };
 
  template<>
  class From_Ruby<knowCore::BigNumber>
  {
  public:
    From_Ruby() = default;
 
    explicit From_Ruby(Arg* arg) : arg_(arg)
    {
    }
    bool is_convertible(VALUE value)
    {
      ruby_value_type vt = rb_type(value);
      return vt == RUBY_T_FLOAT or vt == RUBY_T_FIXNUM or vt == RUBY_T_BIGNUM;
    }
    knowCore::BigNumber convert(VALUE value)
    {
      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
      {
        return this->arg_->defaultValue<knowCore::BigNumber>();
      }
      else
      {
        switch (rb_type(value))
        {
          case RUBY_T_FLOAT:
            return knowCore::BigNumber(protect(rb_num2dbl, value));
          case RUBY_T_FIXNUM:
            return knowCore::BigNumber(protect(rb_num2short_inline, value));
          case RUBY_T_BIGNUM:
          {    
            auto const& [success, VAL, errorMessage] = knowCore::BigNumber::fromString(From_Ruby<QString>().convert(rb_big2str(value, 10)));
            if(success)
            {
              return VAL;
            } else {
              throw std::runtime_error(errorMessage.toStdString());
            }
          }
          default:
          {
            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
              detail::protect(rb_obj_classname, value), "number");
          }
 
        }
      }
    }
 
  private:
    Arg* arg_ = nullptr;
  };
 
  template<>
  struct From_Ruby<knowCore::BigNumber*> : public rice_qt::From_Ruby_Ptr<knowCore::BigNumber>
  {
    using From_Ruby_Ptr_T::From_Ruby_Ptr_T;
  };
 
  template<>
  struct From_Ruby<knowCore::BigNumber&> : public rice_qt::From_Ruby_Ref<knowCore::BigNumber>
  {
    using From_Ruby_Ref_T::From_Ruby_Ref_T;
  };
  // knowCore::Value
  template<>
  struct Type<knowCore::Value>
  {
    static bool verify()
    {
      return true;
    }
  };
 
  VALUE knowCoreValueToVALUE(knowCore::Value const&  _value)
  {
    auto const& [success, VAL, errorMessage] = knowRuby::ConverterManager::toRubyValue(_value);
    if(success)
    {
      return VAL;
    } else {
      throw std::runtime_error(errorMessage.toStdString());
    }
  }
 
  template<>
  class To_Ruby<knowCore::Value>
  {
  public:
    VALUE convert(knowCore::Value const& x)
    {
      return knowCoreValueToVALUE(x);
    }
  };
 
  template<>
  class To_Ruby<knowCore::Value&>
  {
  public:
    VALUE convert(knowCore::Value const& x)
    {
      return knowCoreValueToVALUE(x);
    }
  };
 
  template<>
  class From_Ruby<knowCore::Value>
  {
  public:
    From_Ruby() = default;
 
    explicit From_Ruby(Arg* arg) : arg_(arg)
    {
    }
 
    knowCore::Value convert(VALUE value)
    {
      if (value == Qnil && this->arg_ && this->arg_->hasDefaultValue())
      {
        return this->arg_->defaultValue<knowCore::Value>();
      }
      else
      {
        auto const& [success, VAL, errorMessage] = knowRuby::ConverterManager::toKnowCoreValue(value);
        if(success)
        {
          return VAL;
        } else {
          throw std::runtime_error(errorMessage.toStdString());
        }
      }
    }
 
  private:
    Arg* arg_ = nullptr;
  };
 
  template<>
  struct From_Ruby<knowCore::Value*> : public rice_qt::From_Ruby_Ptr<knowCore::Value>
  {
    using From_Ruby_Ptr_T::From_Ruby_Ptr;
  };
 
  template<>
  struct From_Ruby<knowCore::Value&> : public rice_qt::From_Ruby_Ref<knowCore::Value>
  {
    using From_Ruby_Ref_T::From_Ruby_Ref;
  };
  // knowCore::ValueHash
  template<>
  struct Type<knowCore::ValueHash>
  {
    static bool verify()
    {
      return true;
    }
  };
 
  template<>
  class To_Ruby<knowCore::ValueHash> : public To_Ruby<QHash<QString, knowCore::Value>>{};
  // template<>
  // class To_Ruby<knowCore::ValueHash&> : public To_Ruby<QHash<QString, knowCore::Value>&>{};
  template<>
  class From_Ruby<knowCore::ValueHash> : public From_Ruby<QHash<QString, knowCore::Value>>{};
  template<>
  struct From_Ruby<knowCore::ValueHash*> : public rice_qt::From_Ruby_Ptr<knowCore::ValueHash>
  {
    using From_Ruby_Ptr_T::From_Ruby_Ptr;
  };
 
  template<>
  struct From_Ruby<knowCore::ValueHash&> : public rice_qt::From_Ruby_Ref<knowCore::ValueHash>
  {
    using From_Ruby_Ref_T::From_Ruby_Ref;
  };
  // knowCore::UriList
  template<>
  struct Type<knowCore::UriList>
  {
    static bool verify()
    {
      return true;
    }
  };
 
  template<>
  class To_Ruby<knowCore::UriList> : public To_Ruby<QList<knowCore::Uri>>{};
  // template<>
  // class To_Ruby<knowCore::UriList&> : public To_Ruby<QList<knowCore::Uri>>{};
  template<>
  class From_Ruby<knowCore::UriList> : public From_Ruby<QList<knowCore::Uri>>{};
  template<>
  struct From_Ruby<knowCore::UriList*> : public rice_qt::From_Ruby_Ptr<knowCore::UriList>
  {
    using From_Ruby_Ptr_T::From_Ruby_Ptr;
  };
 
  template<>
  struct From_Ruby<knowCore::UriList&> : public rice_qt::From_Ruby_Ref<knowCore::UriList>
  {
    using From_Ruby_Ref_T::From_Ruby_Ref;
  };
 
}