Document.hh

Go to the documentation of this file.

//
// Document.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++/Collection.hh"
#include "cbl++/Database.hh"
#include "cbl/CBLDocument.h"
#include "fleece/Mutable.hh"
#include <string>
 
 
CBL_ASSUME_NONNULL_BEGIN
 
namespace cbl {
    class MutableDocument;

    class Document : protected RefCounted {
    public:
        // Metadata:

        std::string id() const                     {return internal::asString(CBLDocument_ID(ref()));}

        std::string revisionID() const             {return internal::asString(CBLDocument_RevisionID(ref()));}
        
        uint64_t timestamp() const                 {return CBLDocument_Timestamp(ref());}

        uint64_t sequence() const                  {return CBLDocument_Sequence(ref());}
        
        Collection collection() const              {return Collection(CBLDocument_Collection(ref()));}
 
        // Properties:

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

        alloc_slice propertiesAsJSON() const       {return alloc_slice(CBLDocument_CreateJSON(ref()));}

        fleece::Value operator[] (std::string_view key) const {return properties()[slice(key)];}
 
        // Operations:
        
        inline MutableDocument mutableCopy() const;
 
    protected:
        friend class Collection;
        friend class Database;
        friend class Replicator;
        
        Document(CBLRefCounted* r)                  :RefCounted(r) { }
 
        static Document adopt(const CBLDocument* _cbl_nullable d, CBLError *error) {
            if (!d && error->code != 0)
                internal::check(false, *error);
            Document doc;
            doc._ref = (CBLRefCounted*)d;
            return doc;
        }
 
        static bool checkSave(bool saveResult, CBLError &error) {
            if (saveResult)
                return true;
            else {
                bool permittedError = (error.code == kCBLErrorConflict && error.domain == kCBLDomain);
                internal::check(permittedError, error); // throw if not permittedError
                return false;
            }
        }
 
        CBL_REFCOUNTED_BOILERPLATE(Document, RefCounted, const CBLDocument)
    };
 

    class MutableDocument : public Document {
    public:
        explicit MutableDocument(std::nullptr_t)        {_ref = (CBLRefCounted*)CBLDocument_CreateWithID(fleece::nullslice);}

        explicit MutableDocument(std::string_view docID) {
            _ref = (CBLRefCounted*)CBLDocument_CreateWithID(slice(docID));
        }

        fleece::MutableDict properties()                {return CBLDocument_MutableProperties(ref());}

        template <typename V>
        void set(std::string_view key, const V &val)    {properties().set(slice(key), val);}
        
        template <typename K, typename V>
        void set(const K &key, const V &val)            {properties().set(key, val);}

        fleece::keyref<fleece::MutableDict,fleece::slice> operator[] (std::string_view key)
                                                        {return properties()[slice(key)];}

        void setProperties(fleece::MutableDict properties) {
            CBLDocument_SetProperties(ref(), properties);
        }

        void setProperties(fleece::Dict properties) {
            CBLDocument_SetProperties(ref(), properties.mutableCopy());
        }

        void setPropertiesAsJSON(std::string_view json) {
            CBLError error;
            internal::check(CBLDocument_SetJSON(ref(), slice(json), &error), error);
        }
 
    protected:
        static MutableDocument adopt(CBLDocument* _cbl_nullable d, CBLError *error) {
            internal::check(d != nullptr || error->code == 0, *error);
            MutableDocument doc;
            doc._ref = (CBLRefCounted*)d;
            return doc;
        }
 
        friend class Collection;
        friend class Database;
        friend class Document;
        CBL_REFCOUNTED_BOILERPLATE(MutableDocument, Document, CBLDocument)
    };
    
    // Document method bodies:
 
    inline MutableDocument Document::mutableCopy() const {
        MutableDocument doc;
        doc._ref = (CBLRefCounted*) CBLDocument_MutableCopy(ref());
        return doc;
    }
 
    // Collection method bodies:
 
    inline Document Collection::getDocument(std::string_view id) const {
        CBLError error;
        return Document::adopt(CBLCollection_GetDocument(ref(), slice(id), &error), &error);
    }
 
    inline MutableDocument Collection::getMutableDocument(std::string_view id) const {
        CBLError error;
        return MutableDocument::adopt(CBLCollection_GetMutableDocument(ref(), slice(id), &error), &error);
    }
 
    inline void Collection::saveDocument(MutableDocument &doc) {
        (void) saveDocument(doc, kCBLConcurrencyControlLastWriteWins);
    }
 
    inline bool Collection::saveDocument(MutableDocument &doc, CBLConcurrencyControl c) {
        CBLError error;
        return Document::checkSave(
            CBLCollection_SaveDocumentWithConcurrencyControl(ref(), doc.ref(), c, &error), error);
    }
 
    inline bool Collection::saveDocument(MutableDocument &doc, CollectionConflictHandler conflictHandler) {
        CBLConflictHandler cHandler = [](void *context, CBLDocument *myDoc,
                                         const CBLDocument *otherDoc) -> bool {
            return (*(CollectionConflictHandler*)context)(MutableDocument(myDoc),
                                                Document(otherDoc));
        };
        CBLError error;
        return Document::checkSave(
            CBLCollection_SaveDocumentWithConflictHandler(ref(), doc.ref(), cHandler,
                                                          &conflictHandler, &error), error);
    }
 
    inline void Collection::deleteDocument(Document &doc) {
        (void) deleteDocument(doc, kCBLConcurrencyControlLastWriteWins);
    }
 
    inline bool Collection::deleteDocument(Document &doc, CBLConcurrencyControl cc) {
        CBLError error;
        return Document::checkSave(
            CBLCollection_DeleteDocumentWithConcurrencyControl(ref(), doc.ref(), cc, &error), error);
    }
 
    inline void Collection::purgeDocument(Document &doc) {
        CBLError error{};
        internal::check(CBLCollection_PurgeDocument(ref(), doc.ref(), &error), error);
    }
}
 
CBL_ASSUME_NONNULL_END