FLSlice.h

Go to the documentation of this file.

//
//  FLSlice.h
//  Fleece
//
//  Created by Jens Alfke on 8/13/18.
//  Copyright 2018-Present Couchbase, Inc.
//
//  Use of this software is governed by the Business Source License included
//  in the file licenses/BSL-Couchbase.txt.  As of the Change Date specified
//  in that file, in accordance with the Business Source License, use of this
//  software will be governed by the Apache License, Version 2.0, included in
//  the file licenses/APL2.txt.
//
 
#pragma once
#ifndef _FLSLICE_H
#define _FLSLICE_H
 
#include "CompilerSupport.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
 
 
#ifdef __cplusplus
    #include <string>
    namespace fleece { struct alloc_slice; }
#endif
 
 
FL_ASSUME_NONNULL_BEGIN
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
typedef struct FLSlice {
    const void* FL_NULLABLE buf;
    size_t size;
 
#ifdef __cplusplus
    explicit operator bool() const noexcept FLPURE  {return buf != nullptr;}
    explicit operator std::string() const           {return std::string((char*)buf, size);}
#endif
} FLSlice;
 
 
struct NODISCARD FLSliceResult {
    const void* FL_NULLABLE buf;
    size_t size;
 
#ifdef __cplusplus
    explicit operator bool() const noexcept FLPURE  {return buf != nullptr;}
    explicit operator FLSlice () const              {return {buf, size};}
    inline explicit operator std::string() const;
#endif
};
typedef struct FLSliceResult FLSliceResult;
 
 
#ifdef __cplusplus
    struct FLHeapSlice : public FLSlice {
        constexpr FLHeapSlice() noexcept                           :FLSlice{nullptr, 0} { }
    private:
        constexpr FLHeapSlice(const void *FL_NULLABLE b, size_t s) noexcept    :FLSlice{b, s} { }
        friend struct fleece::alloc_slice;
    };
#else
    typedef FLSlice FLHeapSlice;
#endif
 
 
// Aliases used to indicate that a slice is expected to contain UTF-8 data.
typedef FLSlice FLString;
typedef FLSliceResult FLStringResult;
 
 
#ifdef _MSC_VER
    static const FLSlice kFLSliceNull = { NULL, 0 };
#else
    #define kFLSliceNull ((FLSlice){NULL, 0})
#endif
 
 
static inline FLPURE int FLMemCmp(const void * FL_NULLABLE a,
                                  const void * FL_NULLABLE b, size_t size) FLAPI
{
    if (_usuallyFalse(size == 0))
        return 0;
    return memcmp(a, b, size);
}
 
static inline void FLMemCpy(void* FL_NULLABLE dst, const void* FL_NULLABLE src, size_t size) FLAPI {
    if (_usuallyTrue(size > 0))
        memcpy(dst, src, size);
}
 
 
static inline FLSlice FLStr(const char* FL_NULLABLE str) FLAPI {
    FLSlice foo = { str, str ? strlen(str) : 0 };
    return foo;
}
 
#ifdef __cplusplus
    #define FLSTR(STR) (FLSlice {("" STR), sizeof(("" STR))-1})
#else
    #define FLSTR(STR) ((FLSlice){("" STR), sizeof(("" STR))-1})
#endif
 
 
FLEECE_PUBLIC bool FLSlice_Equal(FLSlice a, FLSlice b) FLAPI FLPURE;
 
FLEECE_PUBLIC int FLSlice_Compare(FLSlice, FLSlice) FLAPI FLPURE;
 
FLEECE_PUBLIC uint32_t FLSlice_Hash(FLSlice s) FLAPI FLPURE;
 
FLEECE_PUBLIC bool FLSlice_ToCString(FLSlice s, char* buffer, size_t capacity) FLAPI;
 
FLEECE_PUBLIC FLSliceResult FLSliceResult_New(size_t) FLAPI;
 
FLEECE_PUBLIC FLSliceResult FLSlice_Copy(FLSlice) FLAPI;
 
 
static inline FLSliceResult FLSliceResult_CreateWith(const void* FL_NULLABLE bytes, size_t size) FLAPI {
    FLSlice s = {bytes, size};
    return FLSlice_Copy(s);
}
 
 
FLEECE_PUBLIC void _FLBuf_Retain(const void* FL_NULLABLE) FLAPI;   // internal; do not call
FLEECE_PUBLIC void _FLBuf_Release(const void* FL_NULLABLE) FLAPI;  // internal; do not call
 
static inline FLSliceResult FLSliceResult_Retain(FLSliceResult s) FLAPI {
    _FLBuf_Retain(s.buf);
    return s;
}
 
static inline void FLSliceResult_Release(FLSliceResult s) FLAPI {
    _FLBuf_Release(s.buf);
}
 
static inline FLSlice FLSliceResult_AsSlice(FLSliceResult sr) {
    FLSlice ret;
    memcpy(&ret, &sr, sizeof(ret));
    return ret;
}
 
 
FLEECE_PUBLIC void FL_WipeMemory(void *dst, size_t size) FLAPI;
 
 
#ifdef __cplusplus
}
 
    FLPURE static inline bool operator== (FLSlice s1, FLSlice s2) {return FLSlice_Equal(s1, s2);}
    FLPURE static inline bool operator!= (FLSlice s1, FLSlice s2) {return !(s1 == s2);}
 
    FLPURE static inline bool operator== (FLSliceResult sr, FLSlice s) {return (FLSlice)sr == s;}
    FLPURE static inline bool operator!= (FLSliceResult sr, FLSlice s) {return !(sr ==s);}
 
 
    FLSliceResult::operator std::string () const {
        auto str = std::string((char*)buf, size);
        FLSliceResult_Release(*this);
        return str;
    }
#endif
 
FL_ASSUME_NONNULL_END
#endif // _FLSLICE_H