CBORValue.cpp   [plain text]

// Copyright 2017 The Chromium Authors. All rights reserved.
// Copyright (C) 2018 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:
//
//    * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//    * 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.
//    * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
// OWNER OR 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.

#include "config.h"
#include "CBORValue.h"

#if ENABLE(WEB_AUTHN)

#include <new>
#include <utility>

namespace cbor {

CBORValue::CBORValue()
    : m_type(Type::None)
{
}

CBORValue::CBORValue(CBORValue&& that)
{
    internalMoveConstructFrom(WTFMove(that));
}

CBORValue::CBORValue(Type type)
    : m_type(type)
{
    // Initialize with the default value.
    switch (m_type) {
    case Type::Unsigned:
    case Type::Negative:
        m_integerValue = 0;
        return;
    case Type::ByteString:
        new (&m_byteStringValue) BinaryValue();
        return;
    case Type::String:
        new (&m_stringValue) String();
        return;
    case Type::Array:
        new (&m_arrayValue) ArrayValue();
        return;
    case Type::Map:
        new (&m_mapValue) MapValue();
        return;
    case Type::SimpleValue:
        m_simpleValue = CBORValue::SimpleValue::Undefined;
        return;
    case Type::None:
        return;
    }
    ASSERT_NOT_REACHED();
}

CBORValue::CBORValue(int integerValue)
    : CBORValue(static_cast<int64_t>(integerValue))
{
}

CBORValue::CBORValue(int64_t integerValue)
    : m_integerValue(integerValue)
{
    m_type = integerValue >= 0 ? Type::Unsigned : Type::Negative;
}

CBORValue::CBORValue(const BinaryValue& inBytes)
    : m_type(Type::ByteString)
    , m_byteStringValue(inBytes)
{
}

CBORValue::CBORValue(BinaryValue&& inBytes)
    : m_type(Type::ByteString)
    , m_byteStringValue(WTFMove(inBytes))
{
}

CBORValue::CBORValue(const char* inString)
    : CBORValue(String(inString))
{
}

CBORValue::CBORValue(String&& inString)
    : m_type(Type::String)
    , m_stringValue(WTFMove(inString))
{
}

CBORValue::CBORValue(const String& inString)
    : m_type(Type::String)
    , m_stringValue(inString)
{
}

CBORValue::CBORValue(const ArrayValue& inArray)
    : m_type(Type::Array)
    , m_arrayValue()
{
    m_arrayValue.reserveCapacity(inArray.size());
    for (const auto& val : inArray)
        m_arrayValue.append(val.clone());
}

CBORValue::CBORValue(ArrayValue&& inArray)
    : m_type(Type::Array)
    , m_arrayValue(WTFMove(inArray))
{
}

CBORValue::CBORValue(const MapValue& inMap)
    : m_type(Type::Map)
    , m_mapValue()
{
    for (const auto& it : inMap)
        m_mapValue.emplace_hint(m_mapValue.end(), it.first.clone(), it.second.clone());
}

CBORValue::CBORValue(MapValue&& inMap)
    : m_type(Type::Map)
    , m_mapValue(WTFMove(inMap))
{
}

CBORValue::CBORValue(SimpleValue inSimple)
    : m_type(Type::SimpleValue)
    , m_simpleValue(inSimple)
{
    ASSERT(static_cast<int>(inSimple) >= 20 && static_cast<int>(inSimple) <= 23);
}

CBORValue::CBORValue(bool inBool)
    : m_type(Type::SimpleValue)
{
    m_simpleValue = inBool ? CBORValue::SimpleValue::TrueValue : CBORValue::SimpleValue::FalseValue;
}

CBORValue& CBORValue::operator=(CBORValue&& that)
{
    internalCleanup();
    internalMoveConstructFrom(WTFMove(that));

    return *this;
}

CBORValue::~CBORValue()
{
    internalCleanup();
}

CBORValue CBORValue::clone() const
{
    switch (m_type) {
    case Type::None:
        return CBORValue();
    case Type::Unsigned:
    case Type::Negative:
        return CBORValue(m_integerValue);
    case Type::ByteString:
        return CBORValue(m_byteStringValue);
    case Type::String:
        return CBORValue(m_stringValue);
    case Type::Array:
        return CBORValue(m_arrayValue);
    case Type::Map:
        return CBORValue(m_mapValue);
    case Type::SimpleValue:
        return CBORValue(m_simpleValue);
    }

    ASSERT_NOT_REACHED();
    return CBORValue();
}

const int64_t& CBORValue::getInteger() const
{
    ASSERT(isInteger());
    return m_integerValue;
}

const int64_t& CBORValue::getUnsigned() const
{
    ASSERT(isUnsigned());
    ASSERT(m_integerValue >= 0);
    return m_integerValue;
}

const int64_t& CBORValue::getNegative() const
{
    ASSERT(isNegative());
    ASSERT(m_integerValue < 0);
    return m_integerValue;
}

const String& CBORValue::getString() const
{
    ASSERT(isString());
    return m_stringValue;
}

const CBORValue::BinaryValue& CBORValue::getByteString() const
{
    ASSERT(isByteString());
    return m_byteStringValue;
}

const CBORValue::ArrayValue& CBORValue::getArray() const
{
    ASSERT(isArray());
    return m_arrayValue;
}

const CBORValue::MapValue& CBORValue::getMap() const
{
    ASSERT(isMap());
    return m_mapValue;
}

CBORValue::SimpleValue CBORValue::getSimpleValue() const
{
    ASSERT(isSimple());
    return m_simpleValue;
}

bool CBORValue::getBool() const
{
    ASSERT(isBool());
    return m_simpleValue == SimpleValue::TrueValue;
}

void CBORValue::internalMoveConstructFrom(CBORValue&& that)
{
    m_type = that.m_type;

    switch (m_type) {
    case Type::Unsigned:
    case Type::Negative:
        m_integerValue = that.m_integerValue;
        return;
    case Type::ByteString:
        new (&m_byteStringValue) BinaryValue(WTFMove(that.m_byteStringValue));
        return;
    case Type::String:
        new (&m_stringValue) String(WTFMove(that.m_stringValue));
        return;
    case Type::Array:
        new (&m_arrayValue) ArrayValue(WTFMove(that.m_arrayValue));
        return;
    case Type::Map:
        new (&m_mapValue) MapValue(WTFMove(that.m_mapValue));
        return;
    case Type::SimpleValue:
        m_simpleValue = that.m_simpleValue;
        return;
    case Type::None:
        return;
    }
    ASSERT_NOT_REACHED();
}

void CBORValue::internalCleanup()
{
    switch (m_type) {
    case Type::ByteString:
        m_byteStringValue.~BinaryValue();
        break;
    case Type::String:
        m_stringValue.~String();
        break;
    case Type::Array:
        m_arrayValue.~ArrayValue();
        break;
    case Type::Map:
        m_mapValue.~MapValue();
        break;
    case Type::None:
    case Type::Unsigned:
    case Type::Negative:
    case Type::SimpleValue:
        break;
    }
    m_type = Type::None;
}

} // namespace cbor

#endif // ENABLE(WEB_AUTHN)