inline Manip2P<uint8_t, bool> PacketTerminator(
        _In_ const uint8_t value = PacketStream::_PACKET_TERMINATOR,
        _In_ const bool isfinal = true)
    {
        return(Manip2P<uint8_t, bool>(
            [](_In_ PacketInStream& os, 
               _In_ const uint8_t value, 
               _In_ const bool isfinal) -> PacketInStream&
            {
                os.DecodeConst(value, isfinal);
                return os;
            },
            value, isfinal));
    }

enum PacketStreamFeline { _PACKET_TERMINATOR };
class PacketInStreamFeline
{
public:
    void DecodeConst(const uint8_t value, const bool isfinal) {}
};

void felineVATestFuncHoldingLambda()
{
    std::map<uint8_t, bool> PacketTerminator(
        _In_ const uint8_t value = PacketStreamFeline::_PACKET_TERMINATOR,
        _In_ const bool isfinal = true)
    {
        return(std::map<uint8_t, bool>(
            [](_In_ PacketInStreamFeline& os,
                _In_ const uint8_t value,
                _In_ const bool isfinal) -> PacketInStreamFeline&
            {
                os.DecodeConst(value, isfinal);
                return os;
            },
            value, isfinal));
    }
}

#pragma once

#include <cstdio>

namespace Packet
{
    class PacketStream
    {
    public:
        PacketStream(_In_ const size_t size) noexcept :
            _width(0),
            _remaining(size),
            _streamOkay(true),
            _size(0)
        {
        }

        // Get the current status of the packet

        operator bool() const
        {
            return _streamOkay;
        }

        // Return the current size of the data, or 0 if there are any errors

        inline size_t Size() const
        {
            return operator bool() ? _size : 0;
        }

        // Set the maximum width of the next string

        inline void SetW(_In_ const size_t width)
        {
            _width = width;
        }

        // ASCII string terminator character

        static constexpr uint8_t _ASCII_STRING_TERMINATOR = 0x00;

        // Packet terminator character

        static constexpr uint8_t _PACKET_TERMINATOR = 0x10;

        // Manipulator template for one parameter

        template <class TStream, typename TP1>
        class Manip1
        {
        public:

            // Function prototype for the manipulator worker.

            using Function = TStream & (*) (TStream&, TP1);

            // Construct a new manipulator object.

            Manip1(Function function, TP1 value) :
                _function(function),
                _value1(value)
            {
            }

            // Execute the manipulator.

            TStream& Go(TStream& os) const
            {
                _function(os, _value1);
            }

        private:

            // The value to apply to the manipulator call.

            TP1 _value1;

            // The manipulator function to call.

            Function _function;
        };

        // Manipulator template for two parameters

        template <class TStream, typename TP1, typename TP2>
        class Manip2
        {
        public:

            // Function prototype for the manipulator worker.

            using Function = TStream & (*) (_Inout_ TStream&, _In_ const TP1, _In_ const TP2);

            // Construct a new manipulator object.

            Manip2(_In_ const Function function, _In_ const TP1 value1, _In_ const TP2 value2) :
                _function(function),
                _value1(value1),
                _value2(value2)
            {
            }

            // Execute the manipulator.

            TStream& Go(_Inout_ TStream& os) const
            {
                _function(os, _value1, _value2);

                return os;
            }

        private:

            // The value to apply to the manipulator call.

            TP1 _value1;

            // The value to apply to the manipulator call.

            TP2 _value2;

            // The manipulator function to call.

            Function _function;
        };

    protected:

        // Width of the the next string operation

        size_t _width;

        // Remaining unused / unprocessed bytes in the packet data

        size_t _remaining;

        // The number of read or written bytes in the stream

        size_t _size;

        // Current status of the packet processing

        bool _streamOkay;
    };


    // Stream operator template 1 parameter manipulators

    template <class TOStream, typename TP1>
    inline TOStream& operator<<(_Inout_ TOStream& os, _In_ const PacketStream::Manip1<TOStream, TP1>& manip)
    {
        return manip.Go(os);
    }

    // Stream operator template 1 parameter manipulators

    template <class TIStream, typename TP1>
    inline TIStream& operator>>(_Inout_ TIStream& is, _In_ const PacketStream::Manip1<TIStream, TP1>& manip)
    {
        return manip.Go(is);
    }

    // Stream operator template 2 parameter manipulators

    template <typename TIStream, typename TP1, typename TP2>
    inline TIStream& operator>>(_Inout_ TIStream& is, _In_ const PacketStream::Manip2<TIStream, TP1, TP2>& manip)
    {
        return manip.Go(is);
    }

#include <stdexcept>

    class PacketTestStream : public PacketStream
    {
    public:
        // Default constructor

        PacketTestStream(_In_ const uint8_t* const data, _In_ size_t size) noexcept :
            PacketStream(size)
        {
            std::ignore = data;
        }

        // Decode a terminator byte

        inline void DecodeConst(_In_ const uint8_t value, _In_ const bool isfinal)
        {
            std::ignore = value;
            std::ignore = isfinal;
            throw std::logic_error("TODO");
        }

        template <typename T>
        PacketTestStream& operator>>(_Out_ T& value)
        {
            std::ignore = value;
            throw std::logic_error("TODO");
        }

    private:

        // Decode a uint8

        inline void Decode(_Out_ uint8_t& value)
        {
            std::ignore = value;
            throw std::logic_error("TODO");
        }

    public:

        // Instantiate the set width manipulator.

        static inline Manip1<PacketTestStream, size_t> SetW(_In_ const size_t width)
        {
            return(Manip1<PacketTestStream, size_t>(
                [](_Inout_ PacketTestStream& os, _In_ const size_t width) -> PacketTestStream& {
                    os.SetW(width);
                    return os;
                },
                width));
        }

        // Instantiate the packet terminator manipulator.

        static inline Manip2<PacketTestStream, uint8_t, bool> PacketTerminator(
            _In_ const uint8_t value = PacketStream::_PACKET_TERMINATOR,
            _In_ const bool isfinal = true)
        {
            return(Manip2<PacketTestStream, uint8_t, bool>(
                [](_In_ PacketTestStream& is, _In_ const uint8_t value, _In_ const bool isfinal) -> PacketTestStream& {
                    is.DecodeConst(value, isfinal);
                    return is;
                },
                value, isfinal));
        }

    };

}