Encryptable.hh

Go to the documentation of this file.

//
// Encryptable.hh
//
// Copyright (c) 2026 Couchbase, Inc All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
 
#pragma once
 
#ifdef COUCHBASE_ENTERPRISE
 
#include "cbl++/Base.hh"
#include "cbl/CBLEncryptable.h"
#include "fleece/Fleece.hh"
#include <string_view>
 
 
CBL_ASSUME_NONNULL_BEGIN
 
namespace cbl {

    class Encryptable : protected RefCounted {
    public:
    explicit Encryptable(fleece::Value value) : Encryptable(CBLEncryptable_CreateWithValue(value), adopt){}

    explicit Encryptable(std::string_view value) : Encryptable(CBLEncryptable_CreateWithString((slice)value), adopt){}

    static Encryptable createWithNull() {
        return {CBLEncryptable_CreateWithNull(), adopt};
    }

    static Encryptable createWithBool(bool value) {
        return {CBLEncryptable_CreateWithBool(value), adopt};
    }

    static Encryptable createWithInt(int64_t value) {
        return {CBLEncryptable_CreateWithInt(value), adopt};
    }

    static Encryptable createWithUInt(uint64_t value) {
        return {CBLEncryptable_CreateWithUInt(value), adopt};
    }

    static Encryptable createWithFloat(float value) {
        return {CBLEncryptable_CreateWithFloat(value), adopt};
    }

    static Encryptable createWithDouble(double value) {
        return {CBLEncryptable_CreateWithDouble(value), adopt};
    }

    fleece::Value value() const     {return CBLEncryptable_Value(ref());}

    fleece::Dict properties() const {return CBLEncryptable_Properties(ref());}

    void setInto(fleece::MutableDict dict, fleece::slice key) const {
        fleece::Dict props = properties();
        fleece::MutableDict mProps = props.asMutable();
        if (!mProps)
            mProps = props.mutableCopy();
        dict[key] = mProps;
    }

    static bool isEncryptableValue(fleece::Dict dict) {
        return FLDict_IsEncryptableValue(dict);
    }

    static Encryptable getEncryptableValue(fleece::Value value) {
        return Encryptable{const_cast<CBLEncryptable*>(FLValue_GetEncryptableValue(value))};
    }
 
    protected:
        CBL_REFCOUNTED_BOILERPLATE(Encryptable, RefCounted, CBLEncryptable)
 
    private:
        struct adopt_t {};
        inline static constexpr adopt_t adopt{};
 
        Encryptable(CBLEncryptable* cObj, adopt_t) {_ref = (CBLRefCounted*)cObj;}
    };
 
}
 
CBL_ASSUME_NONNULL_END
 
#endif // COUCHBASE_ENTERPRISE