oscevent.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
 
// Local includes
#include "oscargument.h"
 
// External Includes
#include <nap/event.h>
#include <nap/numeric.h>
#include <utility/uniqueptrvectoriterator.h>
 
namespace nap
{
    using OSCArgumentList = std::vector<std::unique_ptr<OSCArgument>>;
 
    class NAPAPI OSCEvent : public Event
    {
        RTTI_ENABLE(Event)
    public:
        using ArgumentConstIterator = utility::UniquePtrConstVectorWrapper<OSCArgumentList, OSCArgument*>;
 
        OSCEvent() = delete;
        
        OSCEvent(const std::string& address);
 
        OSCEvent(const std::string&& address);
 
        const std::string& getAddress() const                               { return mAddress; }
 
        template<typename T, typename... Args>
        OSCArgument* addArgument(Args&&... args);
 
        template<typename T, typename... Args>
        OSCArgument* addValue(Args&&... args);
 
        OSCArgument* addString(const std::string& string);
 
        int getCount() const                                                { return static_cast<int>(mArguments.size()); }
 
        const ArgumentConstIterator getArguments() const                    { return ArgumentConstIterator(mArguments); }
 
        const OSCArgument* getArgument(int index) const;
 
        OSCArgument* getArgument(int index);
        
        std::size_t getSize() const;
 
        OSCArgument& operator[](std::size_t idx)                            { return *getArgument(static_cast<int>(idx)); }
        
        const OSCArgument& operator[](std::size_t idx) const                { return *getArgument(static_cast<int>(idx)); }
 
    private:
        OSCArgumentList mArguments;                         // All the arguments associated with the event
        std::string mAddress;                               // The osc event address
    };
 
    // Template definitions
 
    template<typename T, typename... Args>
    OSCArgument* nap::OSCEvent::addArgument(Args&&... args)
    {
        assert(RTTI_OF(T).is_derived_from(RTTI_OF(nap::OSCBaseValue)));
        
        // Create value
        std::unique_ptr<T> value = std::make_unique<T>(std::forward<Args>(args)...);
        
        // Create argument and move value
        std::unique_ptr<OSCArgument> argument = std::make_unique<OSCArgument>(std::move(value));
        
        mArguments.emplace_back(std::move(argument));
        return mArguments.back().get();
    }
 
 
    template<typename T, typename... Args>
    OSCArgument* nap::OSCEvent::addValue(Args&&... args)
    {
        return addArgument<nap::OSCValue<T>>(std::forward<Args>(args)...);
    }
 
    using OSCEventPtr = std::unique_ptr<nap::OSCEvent>;
}