190 lines
7.0 KiB
C++
190 lines
7.0 KiB
C++
/*
|
|
* Copyright (C) 2020 Apple Inc. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
|
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
|
* THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "StringFunctions.h"
|
|
|
|
namespace WTR {
|
|
|
|
WKDictionaryRef dictionaryValue(WKTypeRef);
|
|
|
|
bool booleanValue(WKTypeRef);
|
|
bool booleanValue(const WKRetainPtr<WKTypeRef>&);
|
|
|
|
double doubleValue(WKTypeRef);
|
|
std::optional<double> optionalDoubleValue(WKTypeRef);
|
|
|
|
WKStringRef stringValue(WKTypeRef);
|
|
WTF::String toWTFString(WKTypeRef);
|
|
|
|
uint64_t uint64Value(WKTypeRef);
|
|
uint64_t uint64Value(const WKRetainPtr<WKTypeRef>&);
|
|
|
|
WKTypeRef value(WKDictionaryRef, const char* key);
|
|
|
|
bool booleanValue(WKDictionaryRef, const char* key);
|
|
double doubleValue(WKDictionaryRef, const char* key);
|
|
WKStringRef stringValue(WKDictionaryRef, const char* key);
|
|
uint64_t uint64Value(WKDictionaryRef, const char* key);
|
|
|
|
std::optional<double> optionalDoubleValue(WKDictionaryRef, const char* key);
|
|
|
|
template<typename T> void setValue(const WKRetainPtr<WKMutableDictionaryRef>&, const char* key, const WKRetainPtr<T>& value);
|
|
void setValue(const WKRetainPtr<WKMutableDictionaryRef>&, const char* key, bool value);
|
|
void setValue(const WKRetainPtr<WKMutableDictionaryRef>&, const char* key, const char* value);
|
|
void setValue(const WKRetainPtr<WKMutableDictionaryRef>&, const char* key, uint64_t value);
|
|
void setValue(const WKRetainPtr<WKMutableDictionaryRef>&, const char* key, double value);
|
|
void setValue(const WKRetainPtr<WKMutableDictionaryRef>&, const char* key, WKStringRef value);
|
|
void setValue(const WKRetainPtr<WKMutableDictionaryRef>&, const char* key, JSStringRef value);
|
|
void setValue(const WKRetainPtr<WKMutableDictionaryRef>&, const char* key, const WTF::String& value);
|
|
template<typename T> void setValue(const WKRetainPtr<WKMutableDictionaryRef>&, const char* key, const std::optional<T>& value);
|
|
void setValue(const WKRetainPtr<WKMutableDictionaryRef>&, const char* key, int value) = delete;
|
|
void setValue(const WKRetainPtr<WKMutableDictionaryRef>&, const char* key, unsigned value) = delete;
|
|
void setValue(const WKRetainPtr<WKMutableDictionaryRef>&, const char* key, const void* value) = delete;
|
|
|
|
inline bool booleanValue(WKTypeRef value)
|
|
{
|
|
return value && WKGetTypeID(value) == WKBooleanGetTypeID() && WKBooleanGetValue(static_cast<WKBooleanRef>(value));
|
|
}
|
|
|
|
inline bool booleanValue(const WKRetainPtr<WKTypeRef>& value)
|
|
{
|
|
return booleanValue(value.get());
|
|
}
|
|
|
|
inline WKDictionaryRef dictionaryValue(WKTypeRef value)
|
|
{
|
|
return value && WKGetTypeID(value) == WKDictionaryGetTypeID() ? static_cast<WKDictionaryRef>(value) : nullptr;
|
|
}
|
|
|
|
inline double doubleValue(WKTypeRef value)
|
|
{
|
|
return value && WKGetTypeID(value) == WKDoubleGetTypeID() ? WKDoubleGetValue(static_cast<WKDoubleRef>(value)) : 0;
|
|
}
|
|
|
|
inline std::optional<double> optionalDoubleValue(WKTypeRef value)
|
|
{
|
|
return value && WKGetTypeID(value) == WKDoubleGetTypeID() ? std::make_optional(WKDoubleGetValue(static_cast<WKDoubleRef>(value))) : std::nullopt;
|
|
}
|
|
|
|
inline WKStringRef stringValue(WKTypeRef value)
|
|
{
|
|
return value && WKGetTypeID(value) == WKStringGetTypeID() ? static_cast<WKStringRef>(value) : nullptr;
|
|
}
|
|
|
|
inline WTF::String toWTFString(WKTypeRef value)
|
|
{
|
|
return toWTFString(stringValue(value));
|
|
}
|
|
|
|
inline uint64_t uint64Value(WKTypeRef value)
|
|
{
|
|
return value && WKGetTypeID(value) == WKUInt64GetTypeID() ? WKUInt64GetValue(static_cast<WKUInt64Ref>(value)) : 0;
|
|
}
|
|
|
|
inline uint64_t uint64Value(const WKRetainPtr<WKTypeRef>& value)
|
|
{
|
|
return uint64Value(value.get());
|
|
}
|
|
|
|
inline WKTypeRef value(WKDictionaryRef dictionary, const char* key)
|
|
{
|
|
return dictionary ? WKDictionaryGetItemForKey(dictionary, toWK(key).get()) : nullptr;
|
|
}
|
|
|
|
inline bool booleanValue(WKDictionaryRef dictionary, const char* key)
|
|
{
|
|
return booleanValue(value(dictionary, key));
|
|
}
|
|
|
|
inline double doubleValue(WKDictionaryRef dictionary, const char* key)
|
|
{
|
|
return doubleValue(value(dictionary, key));
|
|
}
|
|
|
|
inline WKStringRef stringValue(WKDictionaryRef dictionary, const char* key)
|
|
{
|
|
return stringValue(value(dictionary, key));
|
|
}
|
|
|
|
inline uint64_t uint64Value(WKDictionaryRef dictionary, const char* key)
|
|
{
|
|
return uint64Value(value(dictionary, key));
|
|
}
|
|
|
|
inline std::optional<double> optionalDoubleValue(WKDictionaryRef dictionary, const char* key)
|
|
{
|
|
return optionalDoubleValue(value(dictionary, key));
|
|
}
|
|
|
|
template<typename T> void setValue(const WKRetainPtr<WKMutableDictionaryRef>& dictionary, const char* key, const WKRetainPtr<T>& value)
|
|
{
|
|
WKDictionarySetItem(dictionary.get(), toWK(key).get(), value.get());
|
|
}
|
|
|
|
inline void setValue(const WKRetainPtr<WKMutableDictionaryRef>& dictionary, const char* key, JSStringRef value)
|
|
{
|
|
setValue(dictionary, key, toWK(value));
|
|
}
|
|
|
|
inline void setValue(const WKRetainPtr<WKMutableDictionaryRef>& dictionary, const char* key, WKStringRef value)
|
|
{
|
|
WKDictionarySetItem(dictionary.get(), toWK(key).get(), value);
|
|
}
|
|
|
|
inline void setValue(const WKRetainPtr<WKMutableDictionaryRef>& dictionary, const char* key, bool value)
|
|
{
|
|
setValue(dictionary, key, adoptWK(WKBooleanCreate(value)));
|
|
}
|
|
|
|
inline void setValue(const WKRetainPtr<WKMutableDictionaryRef>& dictionary, const char* key, const char* value)
|
|
{
|
|
setValue(dictionary, key, toWK(value));
|
|
}
|
|
|
|
inline void setValue(const WKRetainPtr<WKMutableDictionaryRef>& dictionary, const char* key, const WTF::String& value)
|
|
{
|
|
setValue(dictionary, key, toWK(value));
|
|
}
|
|
|
|
inline void setValue(const WKRetainPtr<WKMutableDictionaryRef>& dictionary, const char* key, uint64_t value)
|
|
{
|
|
setValue(dictionary, key, adoptWK(WKUInt64Create(value)));
|
|
}
|
|
|
|
inline void setValue(const WKRetainPtr<WKMutableDictionaryRef>& dictionary, const char* key, double value)
|
|
{
|
|
setValue(dictionary, key, adoptWK(WKDoubleCreate(value)));
|
|
}
|
|
|
|
template<typename T> void setValue(const WKRetainPtr<WKMutableDictionaryRef>& dictionary, const char* key, const std::optional<T>& value)
|
|
{
|
|
if (value)
|
|
setValue(dictionary, key, *value);
|
|
}
|
|
|
|
} // namespace WTR
|