Blob.hh

Go to the documentation of this file.

//
// Blob.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++/Base.hh"
#include "cbl++/Document.hh"
#include "cbl/CBLBlob.h"
#include "cbl/CBLDatabase.h"
#include "fleece/Mutable.hh"
#include <optional>
#include <string>
#include <string_view>
 
 
CBL_ASSUME_NONNULL_BEGIN
 
namespace cbl {
    class BlobReadStream;
    class BlobWriteStream;

    class Blob : protected RefCounted {
    public:
        static bool isBlob(fleece::Dict d)  {return FLDict_IsBlob(d);}

        Blob(std::optional<std::string_view> contentType, slice contents) {
            slice ctype;
            if ( contentType ) ctype = slice(*contentType);
            _ref = (CBLRefCounted*) CBLBlob_CreateWithData(ctype, contents);
        }

        inline Blob(std::optional<std::string_view> contentType, BlobWriteStream& writer);

        Blob(fleece::Dict d) 
        :RefCounted((CBLRefCounted*) FLDict_GetBlob(d))
        { }

        bool blobEquals(const Blob& other) const    {return CBLBlob_Equals(ref(), other.ref());}

        uint64_t length() const                     {return CBLBlob_Length(ref());}
        
        std::string contentType() const             {return internal::asString(CBLBlob_ContentType(ref()));}
        
        std::string digest() const                  {return internal::asString(CBLBlob_Digest(ref()));}
        
        fleece::Dict properties() const             {return CBLBlob_Properties(ref());}

        std::string createJSON() const              {return alloc_slice(CBLBlob_CreateJSON(ref())).asString();}

        operator fleece::Dict() const               {return properties();}

        alloc_slice loadContent() {
            CBLError error;
            fleece::alloc_slice content = CBLBlob_Content(ref(), &error);
            internal::check(content.buf, error);
            return content;
        }

        inline BlobReadStream* openContentStream();
 
    protected:
 
        CBL_REFCOUNTED_BOILERPLATE(Blob, RefCounted, CBLBlob)
 
    private:
        friend class Database;
        struct adopt_t {};
        inline static constexpr adopt_t adopt{};
 
        Blob(CBLBlob* _cbl_nullable cObj, adopt_t) { _ref = (CBLRefCounted*)cObj; }
    };

    class BlobReadStream {
    public:
        using SeekBase = CBLSeekBase;

        BlobReadStream(Blob *blob) {
            CBLError error;
            _stream = CBLBlob_OpenContentStream(blob->ref(), &error);
            internal::check(_stream, error);
        }

        ~BlobReadStream() {
            CBLBlobReader_Close(_stream);
        }

        size_t read(void *dst, size_t maxLength) {
            CBLError error;
            int bytesRead = CBLBlobReader_Read(_stream, dst, maxLength, &error);
            internal::check(bytesRead >= 0, error);
            return size_t(bytesRead);
        }

        int64_t seek(int64_t offset, SeekBase base) {
            CBLError error{};
            int64_t ret = CBLBlobReader_Seek(_stream, offset, base, &error);
            internal::check(ret >= 0, error);
            return ret;
        }

        uint64_t position() {
            return CBLBlobReader_Position(_stream);
        }
 
    private:
        CBLBlobReadStream* _cbl_nullable _stream {nullptr};
    };
 
    inline BlobReadStream* Blob::openContentStream() {
        return new BlobReadStream(this);
    }

    class BlobWriteStream {
    public:
        BlobWriteStream(Database db) {
            CBLError error;
            _writer = CBLBlobWriter_Create(db.ref(), &error);
            internal::check(_writer, error);
        }

        ~BlobWriteStream() {
            CBLBlobWriter_Close(_writer);
        }

        void write(fleece::slice data) {
            write(data.buf, data.size);
        }

        void write(const void *src, size_t length) {
            CBLError error;
            if (!CBLBlobWriter_Write(_writer, src, length, &error))
                internal::check(false, error);
        }
 
    private:
        friend class Blob;
        CBLBlobWriteStream* _cbl_nullable _writer {nullptr};
    };
 
    inline Blob::Blob(std::optional<std::string_view> contentType, BlobWriteStream& writer) {
        slice ctype;
        if ( contentType ) ctype = slice(*contentType);
        _ref = (CBLRefCounted*) CBLBlob_CreateWithStream(ctype, writer._writer);
        writer._writer = nullptr;
    }
 
    inline Blob Database::getBlob(fleece::Dict properties) const {
        CBLError error{};
        const CBLBlob* blob = CBLDatabase_GetBlob(this->ref(), properties, &error);
        // Per the C API: null with error.code==0 is a legitimate "not found";
        // null with a populated error is a real failure -> throw.
        internal::check(blob != nullptr || error.code == 0, error);
        return {const_cast<CBLBlob*>(blob), Blob::adopt};
    }
 
    inline void Database::saveBlob(const Blob& blob) {
        CBLError error{};
        internal::check(CBLDatabase_SaveBlob(this->ref(), blob.ref(), &error), error);
    }
}
 
CBL_ASSUME_NONNULL_END