value.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#ifndef PXR_BASE_JS_VALUE_H
#define PXR_BASE_JS_VALUE_H
 
 
#include "pxr/pxr.h"
#include "pxr/base/js/api.h"
#include "pxr/base/js/types.h"
 
#include <algorithm>
#include <cstdint>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
// Value API Version
// 1 (or undefined) - Initial version.
// 2 - Changed Get{Array,Object} to GetJs{Array,Object}.
#define JS_VALUE_API_VERSION 2
 
class JsValue
{
public:
    enum Type {
        ObjectType,
        ArrayType,
        StringType,
        BoolType,
        IntType,
        RealType,
        NullType
    };
 
    JS_API JsValue();
 
    JS_API JsValue(const JsObject& value);
 
    JS_API JsValue(JsObject&& value);
 
    JS_API JsValue(const JsArray& value);
 
    JS_API JsValue(JsArray&& value);
 
    JS_API explicit JsValue(const char* value);
 
    JS_API explicit JsValue(const std::string& value);
 
    JS_API explicit JsValue(std::string&& value);
 
    JS_API explicit JsValue(bool value);
 
    JS_API explicit JsValue(int value);
 
    JS_API explicit JsValue(int64_t value);
 
    JS_API explicit JsValue(uint64_t value);
 
    JS_API explicit JsValue(double value);
 
    JS_API const JsObject& GetJsObject() const;
 
    JS_API const JsArray& GetJsArray() const;
 
    JS_API const std::string& GetString() const;
 
    JS_API bool GetBool() const;
 
    JS_API int GetInt() const;
 
    JS_API int64_t GetInt64() const;
 
    JS_API uint64_t GetUInt64() const;
 
    JS_API double GetReal() const;
 
    template <typename T,
              typename ReturnType = typename std::conditional<
                  std::is_same<T, JsObject>::value || 
                  std::is_same<T, JsArray>::value || 
                  std::is_same<T, std::string>::value,
                  const T&, T>::type>
    ReturnType Get() const {
        return _Get(static_cast<T*>(nullptr));
    }
 
    template <typename T>
    std::vector<T> GetArrayOf() const;
 
    JS_API Type GetType() const;
 
    JS_API std::string GetTypeName() const;
 
    JS_API bool IsObject() const;
 
    JS_API bool IsArray() const;
 
    JS_API bool IsString() const;
 
    JS_API bool IsBool() const;
 
    JS_API bool IsInt() const;
 
    JS_API bool IsReal() const;
 
    JS_API bool IsUInt64() const;
 
    template <typename T>
    bool Is() const {
        return _Is(static_cast<T*>(nullptr));
    }
 
    template <typename T>
    bool IsArrayOf() const;
 
    JS_API bool IsNull() const;
 
    JS_API explicit operator bool() const;
 
    JS_API bool operator==(const JsValue& other) const;
 
    JS_API bool operator!=(const JsValue& other) const;
 
private:
    template <typename T> 
    struct _InvalidTypeHelper : public std::false_type { };
 
    template <class T>
    T _Get(T*) const {
        static_assert(_InvalidTypeHelper<T>::value, 
                      "Invalid type for JsValue");
        return T();
    }
 
    const JsObject& _Get(JsObject*) const { return GetJsObject(); }
    const JsArray& _Get(JsArray*) const { return GetJsArray(); }
    const std::string& _Get(std::string*) const { return GetString(); }
    bool _Get(bool*) const { return GetBool(); }
    int _Get(int*) const { return GetInt(); }
    int64_t _Get(int64_t*) const { return GetInt64(); }
    uint64_t _Get(uint64_t*) const { return GetUInt64(); }
    double _Get(double*) const { return GetReal(); }
 
    template <class T>
    bool _Is(T*) const {
        static_assert(_InvalidTypeHelper<T>::value, 
                      "Invalid type for JsValue");
        return false;
    }
 
    bool _Is(JsObject*) const { return IsObject(); }
    bool _Is(JsArray*) const { return IsArray(); }
    bool _Is(std::string*) const { return IsString(); }
    bool _Is(bool*) const { return IsBool(); }
    bool _Is(int*) const { return IsInt(); }
    bool _Is(int64_t*) const { return IsInt(); }
    bool _Is(uint64_t*) const { return IsUInt64(); }
    bool _Is(double*) const { return IsReal(); }
 
    struct _Holder;
    std::shared_ptr<_Holder> _holder;
};
 
template <typename T>
inline std::vector<T> JsValue::GetArrayOf() const
{
    const JsArray& array = GetJsArray();
    std::vector<T> result(array.size());
    std::transform(array.begin(), array.end(), result.begin(),
                   [](const JsValue& v) { return v.Get<T>(); });
    return result;
}
 
template <typename T>
inline bool JsValue::IsArrayOf() const 
{
    if (!IsArray()) {
        return false;
    }
    const JsArray& array = GetJsArray();
    return std::all_of(array.begin(), array.end(),
                       [](const JsValue& v) { return v.Is<T>(); });
}
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_BASE_JS_VALUE_H