apiargument.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 "apivalue.h"
 
// External Includes
#include <rtti/rtti.h>
#include <nap/resource.h>
 
namespace nap
{
    class NAPAPI APIArgument final
    {
    public:
        APIArgument(std::unique_ptr<APIBaseValue> value) : mAPIValue(std::move(value)) { }
 
        // Default destructor
        ~APIArgument() = default;
 
        APIArgument(APIArgument&) = delete;
        APIArgument& operator=(const APIArgument&) = delete;
 
        const rtti::TypeInfo getValueType() const;
 
        const APIBaseValue& getValue() const                    { return *mAPIValue; }
 
        template<typename T>
        T* get();
 
        template<typename T>
        const T* get() const;
        
        template<typename T>
        T getCopy();
 
        bool isArray() const;
 
        template<typename T>
        const std::vector<T>* asArray() const;
 
        template<typename T>
        std::vector<T>* asArray();
 
        bool isString() const;
 
        std::string asString() const;
 
        bool isChar() const;
 
        char asChar() const;
 
        bool isByte() const;
 
        uint8_t asByte() const;
 
        bool isFloat() const;
 
        float asFloat() const;
        
        bool isDouble() const;
 
        double asDouble() const;
 
        bool isInt() const;
 
        int asInt() const;
 
        bool isBool() const;
 
        bool asBool() const;
        
        bool isLong() const;
 
        int64_t asLong() const;
 
        const std::string& getName() const;
 
    private:
        std::unique_ptr<APIBaseValue> mAPIValue = nullptr;  
    };
 
 
    // Template definitions
 
    template<typename T>
    T* nap::APIArgument::get()
    {
        return rtti_cast<T>(mAPIValue.get());
    }
 
 
    template<typename T>
    const T* nap::APIArgument::get() const
    {
        return rtti_cast<T>(mAPIValue.get());
    }
 
 
    template<typename T>
    T nap::APIArgument::getCopy()
    {
        T* val_ptr = this->get<T>();
        assert(val_ptr != nullptr);
        return *val_ptr;
    }
 
 
    template<typename T>
    const std::vector<T>* nap::APIArgument::asArray() const
    {
        const APIValue<std::vector<T>>* api_value = get<APIValue<std::vector<T>>>();
        if (api_value == nullptr)
            return nullptr;
 
        // Return array
        return &api_value->mValue;
    }
 
 
    template<typename T>
    std::vector<T>* nap::APIArgument::asArray()
    {
        APIValue<std::vector<T>>* api_value = get<APIValue<std::vector<T>>>();
        if (api_value == nullptr)
            return nullptr;
 
        // Return array
        return &api_value->mValue;
    }
}