oscargument.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
#include <nap/numeric.h>
#include <rtti/rtti.h>
#include <utility/dllexport.h>
#include <glm/glm.hpp>
#include <osc/OscOutboundPacketStream.h>
#include <sstream>
 
namespace nap
{
    class OSCBaseValue;
    using OSCValuePtr = std::unique_ptr<OSCBaseValue>;
 
    class NAPAPI OSCArgument final
    {
        RTTI_ENABLE()
    public:
        // Default Constructor
        OSCArgument() = default;
        OSCArgument(OSCValuePtr value);
 
        // Default Destructor
        ~OSCArgument() = default;
 
        template<typename T>
        const T* get() const;
 
        template<typename T>
        T* get();
 
        rtti::TypeInfo getValueType() const;
 
    public:
        float asFloat() const;
 
        bool isFloat() const;
 
        int asInt() const;
 
        bool isInt() const;
 
        bool asBool() const;
 
        bool isBool() const;
 
        const std::string& asString() const;
 
        bool isString() const;
 
        double asDouble() const;
 
        bool isDouble() const;
 
        char asChar() const;
 
        bool isChar() const;
 
        bool isNil() const;
 
        std::string toString();
 
        OSCArgument(OSCArgument&) = delete;
        OSCArgument& operator=(const OSCArgument&) = delete;
 
        void add(osc::OutboundPacketStream& outPacket) const;
 
        std::size_t size() const;
 
    private:
        OSCValuePtr mValue = nullptr;
    };
 
 
    // OSC Values
 
    class NAPAPI OSCBaseValue
    {
        friend OSCArgument;
        RTTI_ENABLE()
    public:
        OSCBaseValue() = default;
        virtual ~OSCBaseValue() = default;
 
        virtual std::string toString() const = 0;
    protected:
        virtual void add(osc::OutboundPacketStream& outPacket) const = 0;
 
        virtual std::size_t size() const = 0;
    };
 
 
    template<typename T>
    class OSCValue : public OSCBaseValue
    {
        RTTI_ENABLE(OSCBaseValue)
    public:
        OSCValue(const T& value)  : mValue(value)                               { }
        OSCValue(const T&& value) : mValue(std::move(value))                    { }
        T mValue;
        
        virtual std::string toString() const override;
    protected:
        virtual void add(osc::OutboundPacketStream& outPacket) const override;
        virtual std::size_t size() const override;
    };
 
    
    class NAPAPI OSCString : public OSCBaseValue
    {
        RTTI_ENABLE(OSCBaseValue)
    public:
        OSCString(const std::string& string) : mString(string)                      { }
        OSCString(const std::string&& string) : mString(std::move(string))          { }
        std::string mString;
 
        virtual std::string toString() const override;
    protected:
        virtual void add(osc::OutboundPacketStream& outPacket) const override;
        virtual std::size_t size() const override;
    };
 
 
    class NAPAPI OSCNil : public OSCBaseValue
    {
        RTTI_ENABLE(OSCBaseValue)
    public:
        virtual std::string toString() const override                               { return "null"; }
    protected:
        virtual void add(osc::OutboundPacketStream& outPacket) const override       { outPacket << osc::OscNil; }
        virtual std::size_t size() const override                                   { return sizeof(osc::OscNil); }
    };
 
 
    class NAPAPI OSCTimeTag : public OSCBaseValue
    {
        RTTI_ENABLE(OSCBaseValue)
    public:
        OSCTimeTag(nap::uint64 timeTag) : mTimeTag(timeTag) { }
        nap::uint64 mTimeTag;
 
        virtual std::string toString() const override                               { std::ostringstream os; os << mTimeTag; return os.str(); }
    protected:
        virtual void add(osc::OutboundPacketStream& outPacket) const override       { outPacket << osc::TimeTag(mTimeTag); }
        virtual size_t size() const override                                        { return sizeof(nap::uint64); }
    };
 
 
    class NAPAPI OSCBlob : public OSCBaseValue
    {
        RTTI_ENABLE(OSCBaseValue)
    public:
        OSCBlob(const void* sourceData, int size);
        
        virtual ~OSCBlob();
 
        void* getCopy();
 
        virtual std::string toString() const override               { return ""; }
 
        // Data associated with the blob
        void* mData = nullptr;
 
        // Size of the blob in bytes
        int mSize = 0;
 
    protected:
        virtual void add(osc::OutboundPacketStream& outPacket) const override;
        virtual size_t size() const override                                    { return mSize; }
    };
 
 
    class NAPAPI OSCColor : public OSCBaseValue
    {
        RTTI_ENABLE(OSCBaseValue)
    public:
        OSCColor(nap::uint32 color) : mColor(color)                             { }
 
        virtual std::string toString() const override                           { std::ostringstream os; os << mColor; return os.str(); }
 
    protected:
        virtual void add(osc::OutboundPacketStream& outPacket) const override;
        virtual size_t size() const override                                    { return sizeof(nap::uint32); }
 
    private:
        nap::uint32 mColor;
    };
 
 
    // Type definitions for all supported OSC values
 
    using OSCFloat =    OSCValue<float>;
    using OSCBool  =    OSCValue<bool>;
    using OSCInt =      OSCValue<int>;
    using OSCDouble =   OSCValue<double>;
    using OSCChar =     OSCValue<char>;
 
    // Template definitions
 
    template<typename T>
    const T* nap::OSCArgument::get() const
    {
        if (!(mValue->get_type().is_derived_from(RTTI_OF(T))))
        {
            assert(false);
            return nullptr;
        }
        return static_cast<const T*>(mValue.get());
    }
 
 
    template<typename T>
    T* nap::OSCArgument::get()
    {
        if (!(mValue->get_type().is_derived_from(RTTI_OF(T))))
        {
            assert(false);
            return nullptr;
        }
        return static_cast<T*>(mValue.get());
    }
 
 
    template<typename T>
    void nap::OSCValue<T>::add(osc::OutboundPacketStream& outPacket) const
    {
        outPacket << mValue;
    }
 
 
    template<typename T>
    size_t nap::OSCValue<T>::size() const
    {
        return sizeof(T);
    }
 
 
    template<typename T>
    std::string nap::OSCValue<T>::toString() const
    {
        std::ostringstream os; 
        os << mValue; 
        return os.str();
    }
}