apivalue.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
 
// External Includes
#include <rtti/rtti.h>
#include <nap/resource.h>
#include <iostream>
 
namespace nap
{
    // Forward Declares
    class APIArgument;
 
    class NAPAPI APIBaseValue : public Resource
    {
        friend class APIArgument;
        RTTI_ENABLE(Resource)
    public:
        APIBaseValue(const rtti::TypeInfo& type, const std::string& name) :
            mName(name),
            mRepresentedType(type) { }
 
        const rtti::TypeInfo& getRepresentedType() const    { return mRepresentedType; }
 
        std::string mName;                                  
 
    protected:
        APIBaseValue(const rtti::TypeInfo& type) :
            mRepresentedType(type)                           { }
 
    private:
        rtti::TypeInfo mRepresentedType;                    
    };
 
 
    template<typename T>
    class APIValue : public APIBaseValue
    {
        RTTI_ENABLE(APIBaseValue)
    public:
        APIValue();
 
        APIValue(APIValue&& other);
 
        APIValue(const APIValue& other);
 
        APIValue(const std::string& name, T&& value);
 
        APIValue(const std::string& name, const T& value);
 
        APIValue<T>& operator=(APIValue<T>&& other);
 
        APIValue<T>& operator=(const APIValue<T>& other);
 
        T mValue;               
    };
 
 
    // API Type Definitions
 
    using APIFloat = APIValue<float>;
    using APIBool = APIValue<bool>;
    using APIInt = APIValue<int>;
    using APIChar = APIValue<char>;
    using APIByte = APIValue<uint8_t>;
    using APIString = APIValue<std::string>;
    using APIDouble = APIValue<double>;
    using APILong = APIValue<int64_t>;
 
    using APIFloatArray = APIValue<std::vector<float>>;
    using APIBoolArray = APIValue<std::vector<bool>>;
    using APIIntArray = APIValue<std::vector<int>>;
    using APICharArray = APIValue<std::vector<char>>;
    using APIByteArray = APIValue<std::vector<uint8_t>>;
    using APIStringArray = APIValue<std::vector<std::string>>;
    using APIDoubleArray = APIValue<std::vector<double>>;
    using APILongArray = APIValue<std::vector<int64_t>>;
 
 
    // Template definitions
 
    template<typename T>
    nap::APIValue<T>::APIValue(const std::string& name, T&& value) :
        APIBaseValue(RTTI_OF(T), name),
        mValue(std::move(value)) { }
 
 
    template<typename T>
    nap::APIValue<T>::APIValue(const std::string& name, const T& value) :
        APIBaseValue(RTTI_OF(T), name),
        mValue(value) { }
 
 
    template<typename T>
    nap::APIValue<T>::APIValue(const APIValue& other) :
        APIBaseValue(RTTI_OF(T), other.mName),
        mValue(other.mValue)
    {
        this->mID = other.mID;
    }
 
 
    template<typename T>
    nap::APIValue<T>::APIValue(APIValue&& other) :
        APIBaseValue(RTTI_OF(T)),
        mValue(std::move(other.mValue))
    {
        this->mName = std::move(other.mName);
        this->mID = std::move(other.mID);
    }
 
 
    template<typename T>
    nap::APIValue<T>& nap::APIValue<T>::operator=(APIValue<T>&& other)
    {
        if (this != &other)
        {
            mValue = std::move(other.mValue);
            mID = std::move(other.mID);
            mName = std::move(other.mName);
        }
 
        return *this;
    }
 
 
    template<typename T>
    nap::APIValue<T>& nap::APIValue<T>::operator=(const APIValue<T>& other)
    {
        if (this != &other)
        {
            mValue = other.mValue;
            mID = other.mID;
            mName = other.mName;
        }
        return *this;
    }
}