print_param_defn.hpp

Go to the documentation of this file.

#ifndef MLPACK_BINDINGS_JULIA_PRINT_PARAM_DEFN_HPP
#define MLPACK_BINDINGS_JULIA_PRINT_PARAM_DEFN_HPP

#include <mlpack/bindings/util/strip_type.hpp>

namespace mlpack {
namespace bindings {
namespace julia {

template<typename T>
void PrintParamDefn(
    util::ParamData& /* d */,
    const std::string& /* programName */,
    const typename std::enable_if::value>::type* = 0,
    const typename std::enable_ifdata::HasSerialize::value>::type* = 0)
{
  // Do nothing.
}

template<typename T>
void PrintParamDefn(
    util::ParamData& /* d */,
    const std::string& /* programName */,
    const typename std::enable_if::value>::type* = 0)
{
  // Do nothing.
}

template<typename T>
void PrintParamDefn(
    util::ParamData& d,
    const std::string& programName,
    const typename std::enable_if::value>::type* = 0,
    const typename std::enable_if<data::HasSerialize::value>::type* = 0)
{
  // We need to print something of the form below:
  //
  // import ...
  //
  // function IOGetParam(paramName::String)
  //   (ccall((:IOGetParamPtr, Library),
  //       Ptr{Nothing}, (Cstring,), paramName))
  // end
  //
  // function IOSetParam(paramName::String, model::)
  //   ccall((:IOSetParamPtr, Library), Nothing,
  //       (Cstring, Ptr{Nothing}), paramName, model.ptr)
  // end
  //
  // function serialize(stream::IO, model::)
  //   buf_len = UInt[0]
  //   buffer = ccall((:SerializePtr, Library),
  //       Vector{UInt8}, (Ptr{Nothing}, Ptr{UInt8}), model.ptr,
  //       Base.pointer(buf_len))
  //   buf = Base.unsafe_wrap(buf_ptr, buf_len[0]; own=true)
  //   write(stream, buf)
  // end
  //
  // function deserialize(stream::IO)::
  //   buffer = read(stream)
  //   (ccall((:DeserializePtr, Library),
  //       Ptr{Nothing}, (Vector{UInt8}, UInt), buffer, length(buffer)))
  // end

  std::string type = util::StripType(d.cppType);

  // First, print the import of the struct.
  std::cout << "import ..." << type << std::endl;
  std::cout << std::endl;

  // Now, IOGetParam().
  std::cout << "# Get the value of a model pointer parameter of type " << type
      << "." << std::endl;
  std::cout << "function IOGetParam" << type << "(paramName::String)::"
      << type << std::endl;
  std::cout << "  " << type << "(ccall((:IO_GetParam" << type
      << "Ptr, " << programName << "Library), Ptr{Nothing}, (Cstring,), "
      << "paramName))" << std::endl;
  std::cout << "end" << std::endl;
  std::cout << std::endl;

  // Next, IOSetParam().
  std::cout << "# Set the value of a model pointer parameter of type " << type
      << "." << std::endl;
  std::cout << "function IOSetParam" << type << "(paramName::String, "
      << "model::" << type << ")" << std::endl;
  std::cout << "  ccall((:IO_SetParam" << type << "Ptr, "
      << programName << "Library), Nothing, (Cstring, "
      << "Ptr{Nothing}), paramName, model.ptr)" << std::endl;
  std::cout << "end" << std::endl;
  std::cout << std::endl;

  // Now the serialization functionality.
  std::cout << "# Serialize a model to the given stream." << std::endl;
  std::cout << "function serialize" << type << "(stream::IO, model::" << type
      << ")" << std::endl;
  std::cout << "  buf_len = UInt[0]" << std::endl;
  std::cout << "  buf_ptr = ccall((:Serialize" << type << "Ptr, " << programName
      << "Library), Ptr{UInt8}, (Ptr{Nothing}, Ptr{UInt}), model.ptr, "
      << "Base.pointer(buf_len))" << std::endl;
  std::cout << "  buf = Base.unsafe_wrap(Vector{UInt8}, buf_ptr, buf_len[1]; "
      << "own=true)" << std::endl;
  std::cout << "  write(stream, buf)" << std::endl;
  std::cout << "end" << std::endl;

  // And the deserialization functionality.
  std::cout << "# Deserialize a model from the given stream." << std::endl;
  std::cout << "function deserialize" << type << "(stream::IO)::" << type
      << std::endl;
  std::cout << "  buffer = read(stream)" << std::endl;
  std::cout << "  " << type << "(ccall((:Deserialize" << type << "Ptr, "
      << programName << "Library), Ptr{Nothing}, (Ptr{UInt8}, UInt), "
      << "Base.pointer(buffer), length(buffer)))" << std::endl;
  std::cout << "end" << std::endl;
}

template<typename T>
void PrintParamDefn(util::ParamData& d,
                    const void* input,
                    void* /* output */)
{
  PrintParamDefn::type>(d,
      *(std::string*) input);
}

} // namespace julia
} // namespace bindings
} // namespace mlpack

#endif