CanUtility.hpp

[詳解]

#pragma once
 
#include <Udon/Types/ArrayView.hpp>
 
#include <algorithm>
#include <cmath>
 
namespace Udon
{
    namespace Impl
    {

        template <typename Function>
        inline void Packetize(
            Udon::ArrayView<const uint8_t>&& input,               // _In_
            Udon::ArrayView<uint8_t>&&       output,              // _Out_
            size_t                           singlePacketSize,    // _In_
            Function                         func                 // _In_
        )
        {
 
            if (input.size() > singlePacketSize)
            {
                // multi packetize
                // packet: [index][data][data]...[data] <=8byte
                const size_t dataSize    = singlePacketSize - 1;
                const size_t packetCount = static_cast<size_t>(std::ceil(
                    static_cast<double>(input.size()) / dataSize));
 
                for (uint8_t index = 0; index < packetCount; ++index)
                {
                    output.at(0) = index;
 
                    if (index == packetCount - 1)
                    {
                        // last packet
                        std::copy_n(
                            input.begin() + index * dataSize,
                            std::min(dataSize, input.size() - index * dataSize),
                            output.begin() + 1);
                        func(input.size() - index * dataSize);    // callback
                    }
                    else
                    {
                        std::copy_n(
                            input.begin() + index * dataSize,
                            dataSize,
                            output.begin() + 1);
                        func(singlePacketSize);    // callback
                    }
                }
            }
            else
            {
                // single packetize
                // packet: [data][data]...[data] <=8byte
                std::copy_n(
                    input.begin(),
                    input.size(),
                    output.begin());
                func(input.size());    // callback
            }
        }

        inline void Unpacketize(
            Udon::ArrayView<const uint8_t>&& input,              // _In_
            Udon::ArrayView<uint8_t>&&       output,             // _Out_
            size_t                           singlePacketSize    // _In_
        )
        {
 
            if (singlePacketSize == 0)
            {
                return;
            }
 
            if (output.size() <= singlePacketSize)
            {
                // single packetize
                // packet: [data][data]...[data] <=8byte
                std::copy_n(
                    input.begin(),
                    std::min(input.size(), output.size()),
                    output.begin());
            }
            else
            {
                // multi packetize
                // packet: [index][data][data]...[data] <=8byte
 
                const auto index = input.at(0);
 
                const size_t dataSize    = singlePacketSize - 1;    // -1: index
                const size_t packetCount = static_cast<size_t>(std::ceil(
                    static_cast<double>(output.size()) / dataSize));
 
                if (index >= packetCount)
                {
                    // invalid index (buffer overflow)
                    return;
                }
                if (index == packetCount - 1)
                {
                    // last packet (copy remain data)
                    std::copy_n(
                        input.begin() + 1,    // skip index
                        output.size() - index * dataSize,
                        output.begin() + index * dataSize);
                    return;
                }
                else
                {
                    std::copy_n(
                        input.begin() + 1,    // skip index
                        dataSize,
                        output.begin() + index * dataSize);
                }
            }
        }
    }    // namespace Impl
 
}    // namespace Udon