Fleece.h

Go to the documentation of this file.

//
// Fleece.h
//
// Copyright 2016-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 _FLEECE_H
#define _FLEECE_H
 
#include "FLSlice.h"
#include <stdio.h>
 
// On Windows, FLEECE_PUBLIC marks symbols as being exported from the shared library.
// However, this is not the whole list of things that are exported.  The API methods
// are exported using a definition list, but it is not possible to correctly include
// initialized global variables, so those need to be marked (both in the header and 
// implementation) with FLEECE_PUBLIC.  See kFLNullValue below and in Fleece.cc
// for an example.
#if defined(_MSC_VER)
#ifdef FLEECE_EXPORTS
#define FLEECE_PUBLIC __declspec(dllexport)
#else
#define FLEECE_PUBLIC __declspec(dllimport)
#endif
#else
#define FLEECE_PUBLIC
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
    // This is the C API! For the C++ API, see Fleece.hh.
 
 
 
#ifndef FL_IMPL
    typedef const struct _FLValue* FLValue;         
    typedef const struct _FLArray* FLArray;         
    typedef const struct _FLDict*  FLDict;          
    typedef struct _FLSlot*        FLSlot;          
    typedef struct _FLArray*       FLMutableArray;  
    typedef struct _FLDict*        FLMutableDict;   
    typedef struct _FLEncoder*     FLEncoder;       
#endif
 
 
    typedef enum {
        kFLNoError = 0,
        kFLMemoryError,        // Out of memory, or allocation failed
        kFLOutOfRange,         // Array index or iterator out of range
        kFLInvalidData,        // Bad input data (NaN, non-string key, etc.)
        kFLEncodeError,        // Structural error encoding (missing value, too many ends, etc.)
        kFLJSONError,          // Error parsing JSON
        kFLUnknownValue,       // Unparseable data in a Value (corrupt? Or from some distant future?)
        kFLInternalError,      // Something that shouldn't happen
        kFLNotFound,           // Key not found
        kFLSharedKeysStateError, // Misuse of shared keys (not in transaction, etc.)
        kFLPOSIXError,
        kFLUnsupported,         // Operation is unsupported
    } FLError;
 
 
 
 
#ifndef FL_IMPL
    typedef struct _FLDoc*         FLDoc;           
    typedef struct _FLSharedKeys*  FLSharedKeys;    
#endif
 
    typedef enum {
        kFLUntrusted,
        kFLTrusted
    } FLTrust;
 
 
    FLDoc FLDoc_FromResultData(FLSliceResult data, FLTrust, FLSharedKeys, FLSlice externData) FLAPI;
 
    FLDoc FLDoc_FromJSON(FLSlice json, FLError *outError) FLAPI;
 
    void FLDoc_Release(FLDoc) FLAPI;
 
    FLDoc FLDoc_Retain(FLDoc) FLAPI;
 
    FLSlice FLDoc_GetData(FLDoc) FLAPI FLPURE;
 
    FLSliceResult FLDoc_GetAllocedData(FLDoc) FLAPI FLPURE;
 
    FLValue FLDoc_GetRoot(FLDoc) FLAPI FLPURE;
 
    FLSharedKeys FLDoc_GetSharedKeys(FLDoc) FLAPI FLPURE;
 
    bool FLDoc_SetAssociated(FLDoc doc, void *pointer, const char *type) FLAPI;
 
    void* FLDoc_GetAssociated(FLDoc doc, const char *type) FLAPI FLPURE;
 
    FLDoc FLValue_FindDoc(FLValue) FLAPI FLPURE;
 
 
    FLValue FLValue_FromData(FLSlice data, FLTrust) FLAPI FLPURE;
 
    FLSliceResult FLData_ConvertJSON(FLSlice json, FLError *outError) FLAPI;
 
    FLStringResult FLData_Dump(FLSlice data) FLAPI;
 
 
    FLStringResult FLValue_ToJSON(FLValue) FLAPI;
 
    FLStringResult FLValue_ToJSON5(FLValue v) FLAPI;
 
    FLStringResult FLValue_ToJSONX(FLValue v,
                                  bool json5,
                                  bool canonicalForm) FLAPI;
 
    FLStringResult FLJSON5_ToJSON(FLString json5,
                                  FLStringResult *outErrorMessage,
                                  size_t *outErrorPos,
                                  FLError *outError) FLAPI;
 
    const char* FLDump(FLValue) FLAPI;
    const char* FLDumpData(FLSlice data) FLAPI;
 
 
 
    typedef enum {
        kFLUndefined = -1,  
        kFLNull = 0,        
        kFLBoolean,         
        kFLNumber,          
        kFLString,          
        kFLData,            
        kFLArray,           
        kFLDict             
    } FLValueType;
 
 
    typedef int64_t FLTimestamp;
 
    #define FLTimestampNone INT64_MIN
 
 
    FLValueType FLValue_GetType(FLValue) FLAPI FLPURE;
 
    bool FLValue_IsInteger(FLValue) FLAPI FLPURE;
 
    bool FLValue_IsUnsigned(FLValue) FLAPI FLPURE;
 
    bool FLValue_IsDouble(FLValue) FLAPI;
 
    bool FLValue_AsBool(FLValue) FLAPI FLPURE;
 
    int64_t FLValue_AsInt(FLValue) FLAPI FLPURE;
 
    uint64_t FLValue_AsUnsigned(FLValue) FLAPI FLPURE;
 
    float FLValue_AsFloat(FLValue) FLAPI FLPURE;
 
    double FLValue_AsDouble(FLValue) FLAPI FLPURE;
 
    FLString FLValue_AsString(FLValue) FLAPI FLPURE;
 
    FLTimestamp FLValue_AsTimestamp(FLValue) FLAPI FLPURE;
 
    FLSlice FLValue_AsData(FLValue) FLAPI FLPURE;
 
    FLArray FLValue_AsArray(FLValue) FLAPI FLPURE;
 
    FLDict FLValue_AsDict(FLValue) FLAPI FLPURE;
 
    FLStringResult FLValue_ToString(FLValue) FLAPI;
 
    bool FLValue_IsEqual(FLValue v1, FLValue v2) FLAPI FLPURE;
 
    bool FLValue_IsMutable(FLValue) FLAPI FLPURE;
 
    FLValue FLValue_Retain(FLValue) FLAPI;
 
    void FLValue_Release(FLValue) FLAPI;
 
    static inline FLArray FLArray_Retain(FLArray v)     {FLValue_Retain((FLValue)v); return v;}
    static inline void FLArray_Release(FLArray v)       {FLValue_Release((FLValue)v);}
    static inline FLDict FLDict_Retain(FLDict v)        {FLValue_Retain((FLValue)v); return v;}
    static inline void FLDict_Release(FLDict v)         {FLValue_Release((FLValue)v);}
 
    FLValue FLValue_NewString(FLString) FLAPI;
 
    FLValue FLValue_NewData(FLSlice) FLAPI;
 
    FLEECE_PUBLIC extern const FLValue kFLNullValue;
 
    FLEECE_PUBLIC extern const FLValue kFLUndefinedValue;
 
 
 
 
    uint32_t FLArray_Count(FLArray) FLAPI FLPURE;
 
    bool FLArray_IsEmpty(FLArray) FLAPI FLPURE;
 
    FLMutableArray FLArray_AsMutable(FLArray) FLAPI FLPURE;
 
    FLValue FLArray_Get(FLArray, uint32_t index) FLAPI FLPURE;
 
    FLEECE_PUBLIC extern const FLArray kFLEmptyArray;
 
    typedef struct {
#if !DOXYGEN_PARSING
        void* _private1;
        uint32_t _private2;
        bool _private3;
        void* _private4;
#endif
    } FLArrayIterator;
 
    void FLArrayIterator_Begin(FLArray, FLArrayIterator* NONNULL) FLAPI;
 
    FLValue FLArrayIterator_GetValue(const FLArrayIterator* NONNULL) FLAPI FLPURE;
 
    FLValue FLArrayIterator_GetValueAt(const FLArrayIterator* NONNULL, uint32_t offset) FLAPI FLPURE;
 
    uint32_t FLArrayIterator_GetCount(const FLArrayIterator* NONNULL) FLAPI FLPURE;
 
    bool FLArrayIterator_Next(FLArrayIterator* NONNULL) FLAPI;
 
 
 
    typedef enum {
        kFLDefaultCopy        = 0,
        kFLDeepCopy           = 1,
        kFLCopyImmutables     = 2,
        kFLDeepCopyImmutables = (kFLDeepCopy | kFLCopyImmutables),
    } FLCopyFlags;
 
 
    FLMutableArray FLArray_MutableCopy(FLArray, FLCopyFlags) FLAPI;
 
    FLMutableArray FLMutableArray_New(void) FLAPI;
 
    FLMutableArray FLMutableArray_NewFromJSON(FLString json, FLError* outError) FLAPI;
 
    static inline FLMutableArray FLMutableArray_Retain(FLMutableArray d) {
        return (FLMutableArray)FLValue_Retain((FLValue)d);
    }
    static inline void FLMutableArray_Release(FLMutableArray d) {
        FLValue_Release((FLValue)d);
    }
 
    FLArray FLMutableArray_GetSource(FLMutableArray) FLAPI;
 
    bool FLMutableArray_IsChanged(FLMutableArray) FLAPI;
 
    void FLMutableArray_SetChanged(FLMutableArray, bool) FLAPI;
 
    void FLMutableArray_Insert(FLMutableArray array, uint32_t firstIndex, uint32_t count) FLAPI;
 
    void FLMutableArray_Remove(FLMutableArray array, uint32_t firstIndex, uint32_t count) FLAPI;
 
    void FLMutableArray_Resize(FLMutableArray array, uint32_t size) FLAPI;
 
    FLMutableArray FLMutableArray_GetMutableArray(FLMutableArray, uint32_t index) FLAPI;
 
    FLMutableDict FLMutableArray_GetMutableDict(FLMutableArray, uint32_t index) FLAPI;
 
 
    static inline void FLMutableArray_SetNull(FLMutableArray NONNULL, uint32_t index);
    static inline void FLMutableArray_SetBool(FLMutableArray NONNULL, uint32_t index, bool);
    static inline void FLMutableArray_SetInt(FLMutableArray NONNULL, uint32_t index, int64_t);
    static inline void FLMutableArray_SetUInt(FLMutableArray NONNULL, uint32_t index, uint64_t);
    static inline void FLMutableArray_SetFloat(FLMutableArray NONNULL, uint32_t index, float);
    static inline void FLMutableArray_SetDouble(FLMutableArray NONNULL, uint32_t index, double);
    static inline void FLMutableArray_SetString(FLMutableArray NONNULL, uint32_t index, FLString);
    static inline void FLMutableArray_SetData(FLMutableArray NONNULL, uint32_t index, FLSlice);
    static inline void FLMutableArray_SetValue(FLMutableArray NONNULL, uint32_t index, FLValue);
    static inline void FLMutableArray_SetArray(FLMutableArray NONNULL, uint32_t index, FLArray);
    static inline void FLMutableArray_SetDict(FLMutableArray NONNULL, uint32_t index, FLDict);
 
    static inline void FLMutableArray_AppendNull(FLMutableArray NONNULL);
    static inline void FLMutableArray_AppendBool(FLMutableArray NONNULL, bool);
    static inline void FLMutableArray_AppendInt(FLMutableArray NONNULL, int64_t);
    static inline void FLMutableArray_AppendUInt(FLMutableArray NONNULL, uint64_t);
    static inline void FLMutableArray_AppendFloat(FLMutableArray NONNULL, float);
    static inline void FLMutableArray_AppendDouble(FLMutableArray NONNULL, double);
    static inline void FLMutableArray_AppendString(FLMutableArray NONNULL, FLString);
    static inline void FLMutableArray_AppendData(FLMutableArray NONNULL, FLSlice);
    static inline void FLMutableArray_AppendValue(FLMutableArray NONNULL, FLValue);
    static inline void FLMutableArray_AppendArray(FLMutableArray NONNULL, FLArray);
    static inline void FLMutableArray_AppendDict(FLMutableArray NONNULL, FLDict);
 
 
 
 
    uint32_t FLDict_Count(FLDict) FLAPI FLPURE;
 
    bool FLDict_IsEmpty(FLDict) FLAPI FLPURE;
 
    FLMutableDict FLDict_AsMutable(FLDict) FLAPI FLPURE;
 
    FLValue FLDict_Get(FLDict, FLSlice keyString) FLAPI FLPURE;
 
    FLEECE_PUBLIC extern const FLDict kFLEmptyDict;
 
    typedef struct {
#if !DOXYGEN_PARSING
        void* _private1;
        uint32_t _private2;
        bool _private3;
        void* _private4[4];
        int _private5;
#endif
    } FLDictIterator;
 
    void FLDictIterator_Begin(FLDict, FLDictIterator* NONNULL) FLAPI;
 
    FLValue FLDictIterator_GetKey(const FLDictIterator* NONNULL) FLAPI FLPURE;
 
    FLString FLDictIterator_GetKeyString(const FLDictIterator* NONNULL) FLAPI;
 
    FLValue FLDictIterator_GetValue(const FLDictIterator* NONNULL) FLAPI FLPURE;
 
    uint32_t FLDictIterator_GetCount(const FLDictIterator*  NONNULL) FLAPI FLPURE;
 
    bool FLDictIterator_Next(FLDictIterator* NONNULL) FLAPI;
 
    void FLDictIterator_End(FLDictIterator* NONNULL) FLAPI;
 
    typedef struct {
#if !DOXYGEN_PARSING
        FLSlice _private1;
        void* _private2;
        uint32_t _private3, private4;
        bool private5;
#endif
    } FLDictKey;
 
    FLDictKey FLDictKey_Init(FLSlice string) FLAPI;
 
    FLString FLDictKey_GetString(const FLDictKey * NONNULL) FLAPI;
 
    FLValue FLDict_GetWithKey(FLDict, FLDictKey* NONNULL) FLAPI;
 
 
 
 
    FLMutableDict FLDict_MutableCopy(FLDict source, FLCopyFlags) FLAPI;
 
    FLMutableDict FLMutableDict_New(void) FLAPI;
 
    FLMutableDict FLMutableDict_NewFromJSON(FLString json, FLError *outError) FLAPI;
 
    static inline FLMutableDict FLMutableDict_Retain(FLMutableDict d) {
        return (FLMutableDict)FLValue_Retain((FLValue)d);
    }
 
    static inline void FLMutableDict_Release(FLMutableDict d) {
        FLValue_Release((FLValue)d);
    }
 
    FLDict FLMutableDict_GetSource(FLMutableDict) FLAPI;
 
    bool FLMutableDict_IsChanged(FLMutableDict) FLAPI;
 
    void FLMutableDict_SetChanged(FLMutableDict, bool) FLAPI;
 
    void FLMutableDict_Remove(FLMutableDict, FLString key) FLAPI;
 
    void FLMutableDict_RemoveAll(FLMutableDict) FLAPI;
 
    FLMutableArray FLMutableDict_GetMutableArray(FLMutableDict, FLString key) FLAPI;
 
    FLMutableDict FLMutableDict_GetMutableDict(FLMutableDict, FLString key) FLAPI;
 
 
    static inline void FLMutableDict_SetNull(FLMutableDict NONNULL, FLString key);
    static inline void FLMutableDict_SetBool(FLMutableDict NONNULL, FLString key, bool);
    static inline void FLMutableDict_SetInt(FLMutableDict NONNULL, FLString key, int64_t);
    static inline void FLMutableDict_SetUInt(FLMutableDict NONNULL, FLString key, uint64_t);
    static inline void FLMutableDict_SetFloat(FLMutableDict NONNULL, FLString key, float);
    static inline void FLMutableDict_SetDouble(FLMutableDict NONNULL, FLString key, double);
    static inline void FLMutableDict_SetString(FLMutableDict NONNULL, FLString key, FLString);
    static inline void FLMutableDict_SetData(FLMutableDict NONNULL, FLString key, FLSlice);
    static inline void FLMutableDict_SetValue(FLMutableDict NONNULL, FLString key, FLValue);
    static inline void FLMutableDict_SetArray(FLMutableDict NONNULL, FLString key, FLArray);
    static inline void FLMutableDict_SetDict(FLMutableDict NONNULL, FLString key, FLDict);
 
 
 
 
#ifndef FL_IMPL
    typedef struct _FLDeepIterator* FLDeepIterator; 
#endif
 
    FLDeepIterator FLDeepIterator_New(FLValue) FLAPI;
 
    void FLDeepIterator_Free(FLDeepIterator) FLAPI;
 
    FLValue FLDeepIterator_GetValue(FLDeepIterator NONNULL) FLAPI;
 
    FLValue FLDeepIterator_GetParent(FLDeepIterator NONNULL) FLAPI;
 
    FLSlice FLDeepIterator_GetKey(FLDeepIterator NONNULL) FLAPI;
 
    uint32_t FLDeepIterator_GetIndex(FLDeepIterator NONNULL) FLAPI;
 
    size_t FLDeepIterator_GetDepth(FLDeepIterator NONNULL) FLAPI;
 
    void FLDeepIterator_SkipChildren(FLDeepIterator NONNULL) FLAPI;
 
    bool FLDeepIterator_Next(FLDeepIterator NONNULL) FLAPI;
 
    typedef struct {
        FLSlice key;        
        uint32_t index;     
    } FLPathComponent;
 
    void FLDeepIterator_GetPath(FLDeepIterator NONNULL,
                                FLPathComponent* * NONNULL outPath,
                                size_t* NONNULL outDepth) FLAPI;
 
    FLSliceResult FLDeepIterator_GetPathString(FLDeepIterator NONNULL) FLAPI;
 
    FLSliceResult FLDeepIterator_GetJSONPointer(FLDeepIterator NONNULL) FLAPI;
 
 
 
 
#ifndef FL_IMPL
    typedef struct _FLKeyPath*     FLKeyPath;       
#endif
 
    FLKeyPath FLKeyPath_New(FLSlice specifier, FLError *error) FLAPI;
 
    void FLKeyPath_Free(FLKeyPath) FLAPI;
 
    FLValue FLKeyPath_Eval(FLKeyPath NONNULL, FLValue root) FLAPI;
 
    FLValue FLKeyPath_EvalOnce(FLSlice specifier, FLValue root NONNULL, FLError *error) FLAPI;
 
    FLStringResult FLKeyPath_ToString(FLKeyPath path) FLAPI;
 
    bool FLKeyPath_Equals(FLKeyPath path1, FLKeyPath path2) FLAPI;
 
    bool FLKeyPath_GetElement(FLKeyPath NONNULL,
                              size_t i,
                              FLSlice *outDictKey NONNULL,
                              int32_t *outArrayIndex NONNULL) FLAPI;
 
 
 
    FLSharedKeys FLSharedKeys_New(void) FLAPI;
 
    typedef bool (*FLSharedKeysReadCallback)(void *context, FLSharedKeys);
 
    FLSharedKeys FLSharedKeys_NewWithRead(FLSharedKeysReadCallback,
                                          void *context) FLAPI;
 
    FLSliceResult FLSharedKeys_GetStateData(FLSharedKeys NONNULL) FLAPI;
 
    bool FLSharedKeys_LoadStateData(FLSharedKeys, FLSlice) FLAPI;
 
    void FLSharedKeys_WriteState(FLSharedKeys, FLEncoder) FLAPI;
 
    bool FLSharedKeys_LoadState(FLSharedKeys, FLValue) FLAPI;
 
    int FLSharedKeys_Encode(FLSharedKeys NONNULL, FLString, bool add) FLAPI;
 
    FLString FLSharedKeys_Decode(FLSharedKeys NONNULL, int key) FLAPI;
 
    unsigned FLSharedKeys_Count(FLSharedKeys NONNULL) FLAPI;
 
    void FLSharedKeys_RevertToCount(FLSharedKeys NONNULL, unsigned oldCount) FLAPI;
 
    FLSharedKeys FLSharedKeys_Retain(FLSharedKeys) FLAPI;
 
    void FLSharedKeys_Release(FLSharedKeys) FLAPI;
 
 
    typedef struct _FLSharedKeyScope* FLSharedKeyScope;
    FLSharedKeyScope FLSharedKeyScope_WithRange(FLSlice range, FLSharedKeys) FLAPI;
    void FLSharedKeyScope_Free(FLSharedKeyScope);
 
 
 
 
    typedef enum {
        kFLEncodeFleece,    
        kFLEncodeJSON,      
        kFLEncodeJSON5      
    } FLEncoderFormat;
 
 
    FLEncoder FLEncoder_New(void) FLAPI;
 
    FLEncoder FLEncoder_NewWithOptions(FLEncoderFormat format,
                                       size_t reserveSize,
                                       bool uniqueStrings) FLAPI;
 
    FLEncoder FLEncoder_NewWritingToFile(FILE* NONNULL, bool uniqueStrings) FLAPI;
 
    void FLEncoder_Free(FLEncoder) FLAPI;
 
    void FLEncoder_SetSharedKeys(FLEncoder NONNULL, FLSharedKeys) FLAPI;
 
    void FLEncoder_SetExtraInfo(FLEncoder NONNULL, void *info) FLAPI;
 
    void* FLEncoder_GetExtraInfo(FLEncoder NONNULL) FLAPI;
 
 
    void FLEncoder_Amend(FLEncoder e NONNULL, FLSlice base,
                         bool reuseStrings, bool externPointers) FLAPI;
 
    FLSlice FLEncoder_GetBase(FLEncoder NONNULL) FLAPI;
 
    void FLEncoder_SuppressTrailer(FLEncoder NONNULL) FLAPI;
 
    void FLEncoder_Reset(FLEncoder NONNULL) FLAPI;
 
    size_t FLEncoder_BytesWritten(FLEncoder NONNULL) FLAPI;
 
    size_t FLEncoder_GetNextWritePos(FLEncoder NONNULL) FLAPI;
 
    bool FLEncoder_WriteNull(FLEncoder NONNULL) FLAPI;
 
    bool FLEncoder_WriteUndefined(FLEncoder NONNULL) FLAPI;
 
    bool FLEncoder_WriteBool(FLEncoder NONNULL, bool) FLAPI;
 
    bool FLEncoder_WriteInt(FLEncoder NONNULL, int64_t) FLAPI;
 
    bool FLEncoder_WriteUInt(FLEncoder NONNULL, uint64_t) FLAPI;
 
    bool FLEncoder_WriteFloat(FLEncoder NONNULL, float) FLAPI;
 
    bool FLEncoder_WriteDouble(FLEncoder NONNULL, double) FLAPI;
 
    bool FLEncoder_WriteString(FLEncoder NONNULL, FLString) FLAPI;
 
    bool FLEncoder_WriteDateString(FLEncoder NONNULL encoder, FLTimestamp ts, bool asUTC) FLAPI;
 
    bool FLEncoder_WriteData(FLEncoder NONNULL, FLSlice) FLAPI;
 
    bool FLEncoder_WriteRaw(FLEncoder NONNULL, FLSlice) FLAPI;
 
 
    bool FLEncoder_BeginArray(FLEncoder NONNULL, size_t reserveCount) FLAPI;
 
    bool FLEncoder_EndArray(FLEncoder NONNULL) FLAPI;
 
 
    bool FLEncoder_BeginDict(FLEncoder NONNULL, size_t reserveCount) FLAPI;
 
    bool FLEncoder_WriteKey(FLEncoder NONNULL, FLString) FLAPI;
 
    bool FLEncoder_WriteKeyValue(FLEncoder NONNULL, FLValue NONNULL) FLAPI;
 
    bool FLEncoder_EndDict(FLEncoder NONNULL) FLAPI;
 
 
    bool FLEncoder_WriteValue(FLEncoder NONNULL, FLValue NONNULL) FLAPI;
 
 
    intptr_t FLEncoder_LastValueWritten(FLEncoder e);
 
    void FLEncoder_WriteValueAgain(FLEncoder e, intptr_t preWrittenValue);
 
 
    FLSliceResult FLEncoder_Snip(FLEncoder e);
 
 
    bool FLEncoder_ConvertJSON(FLEncoder NONNULL, FLSlice json) FLAPI;
 
    size_t FLEncoder_FinishItem(FLEncoder NONNULL) FLAPI;
 
    FLDoc FLEncoder_FinishDoc(FLEncoder NONNULL, FLError*) FLAPI;
 
    MUST_USE_RESULT
    FLSliceResult FLEncoder_Finish(FLEncoder e, FLError *outError) FLAPI;
 
    FLError FLEncoder_GetError(FLEncoder NONNULL) FLAPI;
 
    const char* FLEncoder_GetErrorMessage(FLEncoder NONNULL) FLAPI;
 
 
 
    FLSliceResult FLCreateJSONDelta(FLValue old, FLValue nuu) FLAPI;
 
    bool FLEncodeJSONDelta(FLValue old, FLValue nuu, FLEncoder NONNULL jsonEncoder) FLAPI;
 
 
    FLSliceResult FLApplyJSONDelta(FLValue old,
                                   FLSlice jsonDelta,
                                   FLError *error) FLAPI;
 
    bool FLEncodeApplyingJSONDelta(FLValue old,
                                   FLSlice jsonDelta,
                                   FLEncoder encoder) FLAPI;
 
 
 
 
    MUST_USE_RESULT
    FLSlot FLMutableArray_Set(FLMutableArray NONNULL, uint32_t index) FLAPI;
 
    MUST_USE_RESULT
    FLSlot FLMutableArray_Append(FLMutableArray NONNULL) FLAPI;
 
    MUST_USE_RESULT
    FLSlot FLMutableDict_Set(FLMutableDict FL_NONNULL, FLString key) FLAPI;
 
 
    void FLSlot_SetNull(FLSlot NONNULL) FLAPI;             
    void FLSlot_SetBool(FLSlot NONNULL, bool) FLAPI;       
    void FLSlot_SetInt(FLSlot NONNULL, int64_t) FLAPI;     
    void FLSlot_SetUInt(FLSlot NONNULL, uint64_t) FLAPI;   
    void FLSlot_SetFloat(FLSlot NONNULL, float) FLAPI;     
    void FLSlot_SetDouble(FLSlot NONNULL, double) FLAPI;   
    void FLSlot_SetString(FLSlot NONNULL, FLString) FLAPI; 
    void FLSlot_SetData(FLSlot NONNULL, FLSlice) FLAPI;    
    void FLSlot_SetValue(FLSlot NONNULL, FLValue) FLAPI;   
    
    static inline void FLSlot_SetArray(FLSlot NONNULL slot, FLArray array) {
        FLSlot_SetValue(slot, (FLValue)array);
    }
 
    static inline void FLSlot_SetDict(FLSlot NONNULL slot, FLDict dict) {
        FLSlot_SetValue(slot, (FLValue)dict);
    }
 
 
    // implementations of the inline methods declared earlier:
 
    static inline void FLMutableArray_SetNull(FLMutableArray a, uint32_t index) {
        FLSlot_SetNull(FLMutableArray_Set(a, index));
    }
    static inline void FLMutableArray_SetBool(FLMutableArray a, uint32_t index, bool val) {
        FLSlot_SetBool(FLMutableArray_Set(a, index), val);
    }
    static inline void FLMutableArray_SetInt(FLMutableArray a, uint32_t index, int64_t val) {
        FLSlot_SetInt(FLMutableArray_Set(a, index), val);
    }
    static inline void FLMutableArray_SetUInt(FLMutableArray a, uint32_t index, uint64_t val) {
        FLSlot_SetUInt(FLMutableArray_Set(a, index), val);
    }
    static inline void FLMutableArray_SetFloat(FLMutableArray a, uint32_t index, float val) {
        FLSlot_SetFloat(FLMutableArray_Set(a, index), val);
    }
    static inline void FLMutableArray_SetDouble(FLMutableArray a, uint32_t index, double val) {
        FLSlot_SetDouble(FLMutableArray_Set(a, index), val);
    }
    static inline void FLMutableArray_SetString(FLMutableArray a, uint32_t index, FLString val) {
        FLSlot_SetString(FLMutableArray_Set(a, index), val);
    }
    static inline void FLMutableArray_SetData(FLMutableArray a, uint32_t index, FLSlice val) {
        FLSlot_SetData(FLMutableArray_Set(a, index), val);
    }
    static inline void FLMutableArray_SetValue(FLMutableArray a, uint32_t index, FLValue val) {
        FLSlot_SetValue(FLMutableArray_Set(a, index), val);
    }
    static inline void FLMutableArray_SetArray(FLMutableArray a, uint32_t index, FLArray val) {
        FLSlot_SetValue(FLMutableArray_Set(a, index), (FLValue)val);
    }
    static inline void FLMutableArray_SetDict(FLMutableArray a, uint32_t index, FLDict val) {
        FLSlot_SetValue(FLMutableArray_Set(a, index), (FLValue)val);
    }
 
    static inline void FLMutableArray_AppendNull(FLMutableArray a) {
        FLSlot_SetNull(FLMutableArray_Append(a));
    }
    static inline void FLMutableArray_AppendBool(FLMutableArray a, bool val) {
        FLSlot_SetBool(FLMutableArray_Append(a), val);
    }
    static inline void FLMutableArray_AppendInt(FLMutableArray a, int64_t val) {
        FLSlot_SetInt(FLMutableArray_Append(a), val);
    }
    static inline void FLMutableArray_AppendUInt(FLMutableArray a, uint64_t val) {
        FLSlot_SetUInt(FLMutableArray_Append(a), val);
    }
    static inline void FLMutableArray_AppendFloat(FLMutableArray a, float val) {
        FLSlot_SetFloat(FLMutableArray_Append(a), val);
    }
    static inline void FLMutableArray_AppendDouble(FLMutableArray a, double val) {
        FLSlot_SetDouble(FLMutableArray_Append(a), val);
    }
    static inline void FLMutableArray_AppendString(FLMutableArray a, FLString val) {
        FLSlot_SetString(FLMutableArray_Append(a), val);
    }
    static inline void FLMutableArray_AppendData(FLMutableArray a, FLSlice val) {
        FLSlot_SetData(FLMutableArray_Append(a), val);
    }
    static inline void FLMutableArray_AppendValue(FLMutableArray a, FLValue val) {
        FLSlot_SetValue(FLMutableArray_Append(a), val);
    }
    static inline void FLMutableArray_AppendArray(FLMutableArray a, FLArray val) {
        FLSlot_SetValue(FLMutableArray_Append(a), (FLValue)val);
    }
    static inline void FLMutableArray_AppendDict(FLMutableArray a, FLDict val) {
        FLSlot_SetValue(FLMutableArray_Append(a), (FLValue)val);
    }
 
    static inline void FLMutableDict_SetNull(FLMutableDict d, FLString key) {
        FLSlot_SetNull(FLMutableDict_Set(d, key));
    }
    static inline void FLMutableDict_SetBool(FLMutableDict d, FLString key, bool val) {
        FLSlot_SetBool(FLMutableDict_Set(d, key), val);
    }
    static inline void FLMutableDict_SetInt(FLMutableDict d, FLString key, int64_t val) {
        FLSlot_SetInt(FLMutableDict_Set(d, key), val);
    }
    static inline void FLMutableDict_SetUInt(FLMutableDict d, FLString key, uint64_t val) {
        FLSlot_SetUInt(FLMutableDict_Set(d, key), val);
    }
    static inline void FLMutableDict_SetFloat(FLMutableDict d, FLString key, float val) {
        FLSlot_SetFloat(FLMutableDict_Set(d, key), val);
    }
    static inline void FLMutableDict_SetDouble(FLMutableDict d, FLString key, double val) {
        FLSlot_SetDouble(FLMutableDict_Set(d, key), val);
    }
    static inline void FLMutableDict_SetString(FLMutableDict d, FLString key, FLString val) {
        FLSlot_SetString(FLMutableDict_Set(d, key), val);
    }
    static inline void FLMutableDict_SetData(FLMutableDict d, FLString key, FLSlice val) {
        FLSlot_SetData(FLMutableDict_Set(d, key), val);
    }
    static inline void FLMutableDict_SetValue(FLMutableDict d, FLString key, FLValue val) {
        FLSlot_SetValue(FLMutableDict_Set(d, key), val);
    }
    static inline void FLMutableDict_SetArray(FLMutableDict d, FLString key, FLArray val) {
        FLSlot_SetValue(FLMutableDict_Set(d, key), (FLValue)val);
    }
    static inline void FLMutableDict_SetDict(FLMutableDict d, FLString key, FLDict val) {
        FLSlot_SetValue(FLMutableDict_Set(d, key), (FLValue)val);
    }
 
 
#ifdef __cplusplus
}
#endif
 
 
#ifdef __OBJC__
// When compiling as Objective-C, include CoreFoundation / Objective-C utilities:
#include "Fleece+CoreFoundation.h"
#endif
 
#endif // _FLEECE_H