Base.hh

Go to the documentation of this file.

//
// Base.hh
//
// Copyright (c) 2019 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
#include "cbl/CBLBase.h"
#include "cbl/CBLQueryTypes.h"
#include "fleece/slice.hh"
#include <algorithm>
#include <functional>
#include <cassert>
#include <memory>
#include <stdexcept>
#include <utility>
 
#if DEBUG
#include "cbl/CBLLog.h"
#endif
 
 
CBL_ASSUME_NONNULL_BEGIN

inline bool operator== (const CBLError &e1, const CBLError &e2) {
    if (e1.code != 0)
        return e1.domain == e2.domain && e1.code == e2.code;
    else
        return e2.code == 0;
}
 
namespace cbl {

    using slice = fleece::slice;
    using alloc_slice = fleece::alloc_slice;
 
    using QueryLanguage = CBLQueryLanguage;
 
    // Internal base class of the C++ wrapper classes; it holds the reference to the
    // underlying ref-counted C object and manages retain/release for it.
    // Not part of the public API, and excluded from the API docs.
    class RefCounted {
    protected:
        RefCounted() noexcept                            :_ref(nullptr) { }
        explicit RefCounted(CBLRefCounted* _cbl_nullable ref) noexcept :_ref(CBL_Retain(ref)) { }
        RefCounted(const RefCounted &other) noexcept     :_ref(CBL_Retain(other._ref)) { }
        RefCounted(RefCounted &&other) noexcept          :_ref(other._ref) {other._ref = nullptr;}
        ~RefCounted() noexcept                           {CBL_Release(_ref);}
 
        RefCounted& operator= (const RefCounted &other) noexcept {
            CBL_Retain(other._ref);
            CBL_Release(_ref);
            _ref = other._ref;
            return *this;
        }
 
        RefCounted& operator= (RefCounted &&other) noexcept {
            if (other._ref != _ref) {
                CBL_Release(_ref);
                _ref = other._ref;
                other._ref = nullptr;
            }
            return *this;
        }
 
        void clear()                                    {CBL_Release(_ref); _ref = nullptr;}
        bool valid() const                              {return _ref != nullptr;}
        explicit operator bool() const                  {return valid();}
 
        CBLRefCounted* _cbl_nullable _ref;
 
        friend class Extension;
        friend class Transaction;
    };

    struct Error: std::runtime_error {
        Error(CBLErrorDomain domain, int code, const std::string& what)
        : std::runtime_error(what)
        , domain(domain)
        , code(code)
        {}
        Error()
        : std::runtime_error("")
        , domain(kCBLDomain)
        , code(0)
        {}
        Error& operator=(const Error& other) {
            std::runtime_error::operator=(other);
            domain = other.domain;
            code   = other.code;
            return *this;
        }
        CBLErrorDomain domain;         
        int            code;           
    };
 
    namespace internal {
        inline std::string asString(FLSlice s)          {return slice(s).asString();}
        inline std::string asString(FLSliceResult &&s)  {return alloc_slice(s).asString();}
 
        inline void check(bool ok, CBLError &error) {
            if (!ok) {
                alloc_slice message = CBLError_Message(&error);
#if DEBUG
                CBL_Log(kCBLLogDomainDatabase, kCBLLogError, "API returning error %d/%d: %.*s",
                        error.domain, error.code, (int)message.size, (char*)message.buf);
#endif
                throw cbl::Error{error.domain, error.code, message.asString()};
            }
        }
    }
 
// For use by the cbl++ headers only: generates the public boilerplate members (ctors,
// assignment ops, comparisons, ref()) that each wrapper class must declare itself.
#define CBL_REFCOUNTED_WITHOUT_COPY_MOVE_BOILERPLATE(CLASS, SUPER, C_TYPE) \
public: \
 \
    CLASS() noexcept                              :SUPER() { } \
 \
    CLASS& operator=(std::nullptr_t)              {clear(); return *this;} \
 \
    bool valid() const                            {return RefCounted::valid();} \
 \
    explicit operator bool() const                {return valid();} \
 \
    bool operator==(const CLASS &other) const     {return _ref == other._ref;} \
 \
    bool operator!=(const CLASS &other) const     {return _ref != other._ref;} \
 \
    C_TYPE* _cbl_nullable ref() const             {return (C_TYPE*)_ref;}\
protected: \
 \
    explicit CLASS(C_TYPE* _cbl_nullable ref)     :SUPER((CBLRefCounted*)ref) { }
 
#define CBL_REFCOUNTED_BOILERPLATE(CLASS, SUPER, C_TYPE) \
CBL_REFCOUNTED_WITHOUT_COPY_MOVE_BOILERPLATE(CLASS, SUPER, C_TYPE) \
public: \
 \
    CLASS(const CLASS &other) noexcept            :SUPER(other) { } \
 \
    CLASS(CLASS &&other) noexcept                 :SUPER((SUPER&&)other) { } \
 \
    CLASS& operator=(const CLASS &other) noexcept {SUPER::operator=(other); return *this;} \
 \
    CLASS& operator=(CLASS &&other) noexcept      {SUPER::operator=((SUPER&&)other); return *this;}

    template <class... Args>
    class ListenerToken {
    public:
        using Callback = std::function<void(Args...)>;

        ListenerToken()                                  =default;
        ~ListenerToken()                                 {CBLListener_Remove(_token);}

        ListenerToken(Callback cb)
        :_callback(new Callback(cb))
        { }

        ListenerToken(ListenerToken &&other)
        :_token(other._token),
        _callback(std::move(other._callback))
        {other._token = nullptr;}

        ListenerToken& operator=(ListenerToken &&other) {
            CBLListener_Remove(_token);
            _token = other._token;
            other._token = nullptr;
            _callback = std::move(other._callback);
            return *this;
        }

        void remove() {
            CBLListener_Remove(_token);
            _token = nullptr;
            _callback = nullptr;
        }

        void* _cbl_nullable context() const             {return _callback.get();}
        CBLListenerToken* _cbl_nullable token() const   {return _token;}
        void setToken(CBLListenerToken* token)          {assert(!_token); _token = token;}

        static void call(void* _cbl_nullable context, Args... args) {
            auto listener = (Callback*)context;
            (*listener)(args...);
        }
 
    private:
        CBLListenerToken* _cbl_nullable _token {nullptr};
        std::shared_ptr<Callback> _callback; // Use shared_ptr instead of unique_ptr to allow to move
 
        ListenerToken(const ListenerToken&) =delete;
        ListenerToken& operator=(const ListenerToken &other) =delete;
    };
}
 
CBL_ASSUME_NONNULL_END