converter_cli.hpp

#pragma once
#ifndef XCORESDK_SRC_MANAGED_CONVERTER_CLI_HPP_
#define XCORESDK_SRC_MANAGED_CONVERTER_CLI_HPP_
 
#include <system_error>
#include <string>
#include "data_types.h"
#include "data_types_cli.hpp"
 
namespace rokae::clr {
 
    System::String^ utf8StdStringToString(const std::string& s);
    System::String^ utf8CStringToString(const char* s);
    template <size_t S>
    array<double>^ convertArray(const std::array<double, S>& _in) {
        auto ret = gcnew array<double>((int)_in.size());
        for (int i = 0; i < (int)_in.size(); ++i) {
            ret[i] = _in[i];
        }
        return ret;
    }
 
    template <typename T>
    array<T>^ convertVectorToArray(const std::vector<T>& _in) {
        auto ret = gcnew array<T>((int)_in.size());
        for (int i = 0; i < (int)_in.size(); ++i) {
            ret[i] = _in[i];
        }
        return ret;
    }
 
    template <size_t S>
    std::array<double, S> convertArray(array<double>^ _in) {
        std::array<double, S> _out{};
        for (unsigned int i = 0; i < ((_in->Length < S) ? _in->Length : S); ++i) {
            _out[i] = _in[i];
        }
        return _out;
    }
 
    template <typename T>
    std::vector<T> convertVector(List<T>^ _in) {
        std::vector<T> _out(_in->Count);
        for (int i = 0; i < _in->Count; ++i) {
            _out[i] = _in[i];
        }
        return _out;
    }
 
    template <typename T>
    std::vector<T> convertArrayToVector(array<T>^ in) {
        std::vector<T> out(in->Length);
        for (decltype(in->Length) i = 0; i < in->Length; ++i) {
            out[i] = in[i];
        }
        return out;
    }
 
    template <typename T>
    void convertVector(const std::vector<T>& in, List<T>^% out) {
        out->Clear();
        for (const auto& d : in) {
            out->Add(d);
        }
    }
 
    void convertErrorCode(const std::error_code& _in, ErrorCode^% _out);
    Load^ convertLoad(const rokae::Load& _in);
    Toolset^ convertToolset(const rokae::Toolset& _in);
 
    void convertLoad(Load^ in, rokae::Load& out);
    rokae::Toolset convertToolset(Toolset^ in);
 
    rokae::Frame convertFrame(Frame^ frame);
    std::string convertString(String^ in);
 
    Frame^ convertFrame(const rokae::Frame& _in);
 
    rokae::CartesianPosition convertCartesianPosition(CartesianPosition^ posture);
 
    CartesianPosition^ convertCartesianPosition(const rokae::CartesianPosition& _cart);
 
    void convertOffset(CartesianPosition::Offset^ in, rokae::CartesianPosition::Offset& out);
 
    KeyPadState convertKeyPadState(const rokae::KeyPadState& in);
    CANFrame^ convertCANFrame(const rokae::CANFrame& in);
    rokae::CANFrame convertCANFrame(CANFrame^ in);
 
    template <class Cmd>
    std::vector<Cmd> convertCartMove(List<MoveCommand^>^ cmds) {
        std::vector<Cmd> _cmds;
 
        for each (MoveCommand ^ cmd in cmds) {
            Cmd _cmd(convertCartesianPosition(cmd->cartTarget), cmd->speed, cmd->zone);
            convertOffset(cmd->cartTargetOffset, _cmd.offset);
 
            if constexpr (std::is_same_v<MoveLCommand, Cmd>) {
                _cmd.rotSpeed = cmd->rotSpeed;
            }
            else {
                _cmd.jointSpeed = cmd->jointSpeed;
            }
 
            _cmd.customInfo = convertString(cmd->customInfo);
            _cmds.emplace_back(_cmd);
        }
        return _cmds;
    }
 
    std::vector<MoveCCommand> convertCircularMove(List<MoveCommand^>^ cmds);
 
    std::vector<MoveCFCommand> convertCircularFullMove(List<MoveCommand^>^ cmds);
 
    std::vector<rokae::MoveSPCommand> convertSpiralMove(List<MoveCommand^>^ cmds);
 
    std::vector<rokae::MoveAbsJCommand> convertJointMove(List<MoveCommand^>^ cmds);
 
    rokae::MoveWaitCommand convertWaitMove(List<MoveCommand^>^ cmds);
 
}
 
#endif // XCORESDK_SRC_MANAGED_CONVERTER_CLI_HPP_