FLMutable.h

Go to the documentation of this file.

//
// FLMutable.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 _FLMUTABLE_H
#define _FLMUTABLE_H
 
#include "FLValue.h"
#include <stdarg.h>
 
FL_ASSUME_NONNULL_BEGIN
 
#ifdef __cplusplus
extern "C" {
#endif
 
    // This is the C API! For the C++ API, see Fleece.hh.
 

 

    typedef enum {
        kFLDefaultCopy        = 0,  
        kFLDeepCopy           = 1,  
        kFLCopyImmutables     = 2,  
        kFLDeepCopyImmutables = (kFLDeepCopy | kFLCopyImmutables), 
    } FLCopyFlags;
 
 
    //====== MUTABLE ARRAY
 


    NODISCARD FLEECE_PUBLIC FLMutableArray FL_NULLABLE FLArray_MutableCopy(FLArray FL_NULLABLE,
                                                   FLCopyFlags) FLAPI;

    NODISCARD FLEECE_PUBLIC FLMutableArray FL_NULLABLE FLMutableArray_New(void) FLAPI;

    inline FLMutableArray FL_NULLABLE FLMutableArray_Retain(FLMutableArray FL_NULLABLE d) {
        return (FLMutableArray)FLValue_Retain((FLValue)d);
    }

    inline void FLMutableArray_Release(FLMutableArray FL_NULLABLE d) {
        FLValue_Release((FLValue)d);
    }

    FLEECE_PUBLIC FLArray FL_NULLABLE FLMutableArray_GetSource(FLMutableArray FL_NULLABLE) FLAPI;

    FLEECE_PUBLIC bool FLMutableArray_IsChanged(FLMutableArray FL_NULLABLE) FLAPI;

    FLEECE_PUBLIC void FLMutableArray_SetChanged(FLMutableArray FL_NULLABLE,
                                   bool changed) FLAPI;

    FLEECE_PUBLIC void FLMutableArray_Insert(FLMutableArray FL_NULLABLE array,
                               uint32_t firstIndex,
                               uint32_t count) FLAPI;

    FLEECE_PUBLIC void FLMutableArray_Remove(FLMutableArray FL_NULLABLE array,
                               uint32_t firstIndex,
                               uint32_t count) FLAPI;

    FLEECE_PUBLIC void FLMutableArray_Resize(FLMutableArray FL_NULLABLE array,
                               uint32_t size) FLAPI;

    NODISCARD FLEECE_PUBLIC FLMutableArray FL_NULLABLE FLMutableArray_GetMutableArray(FLMutableArray FL_NULLABLE,
                                                              uint32_t index) FLAPI;

    NODISCARD FLEECE_PUBLIC FLMutableDict FL_NULLABLE FLMutableArray_GetMutableDict(FLMutableArray FL_NULLABLE,
                                                            uint32_t index) FLAPI;
 

    inline void FLMutableArray_SetNull(FLMutableArray, uint32_t index);
    inline void FLMutableArray_SetBool(FLMutableArray, uint32_t index, bool);
    inline void FLMutableArray_SetInt(FLMutableArray, uint32_t index, int64_t);
    inline void FLMutableArray_SetUInt(FLMutableArray, uint32_t index, uint64_t);
    inline void FLMutableArray_SetFloat(FLMutableArray, uint32_t index, float);
    inline void FLMutableArray_SetDouble(FLMutableArray, uint32_t index, double);
    inline void FLMutableArray_SetString(FLMutableArray, uint32_t index, FLString);
    inline void FLMutableArray_SetData(FLMutableArray, uint32_t index, FLSlice);
    inline void FLMutableArray_SetValue(FLMutableArray, uint32_t index, FLValue);
    inline void FLMutableArray_SetArray(FLMutableArray, uint32_t index, FLArray);
    inline void FLMutableArray_SetDict(FLMutableArray, uint32_t index, FLDict);

    inline void FLMutableArray_AppendNull(FLMutableArray);
    inline void FLMutableArray_AppendBool(FLMutableArray, bool);
    inline void FLMutableArray_AppendInt(FLMutableArray, int64_t);
    inline void FLMutableArray_AppendUInt(FLMutableArray, uint64_t);
    inline void FLMutableArray_AppendFloat(FLMutableArray, float);
    inline void FLMutableArray_AppendDouble(FLMutableArray, double);
    inline void FLMutableArray_AppendString(FLMutableArray, FLString);
    inline void FLMutableArray_AppendData(FLMutableArray, FLSlice);
    inline void FLMutableArray_AppendValue(FLMutableArray, FLValue);
    inline void FLMutableArray_AppendArray(FLMutableArray, FLArray);
    inline void FLMutableArray_AppendDict(FLMutableArray, FLDict);

 
 
    //====== MUTABLE DICT
 


    FLEECE_PUBLIC FLMutableDict FL_NULLABLE FLDict_MutableCopy(FLDict FL_NULLABLE source, FLCopyFlags) FLAPI;

    FLEECE_PUBLIC FLMutableDict FL_NULLABLE FLMutableDict_New(void) FLAPI;

    inline FLMutableDict FL_NULLABLE FLMutableDict_Retain(FLMutableDict FL_NULLABLE d) {
        return (FLMutableDict)FLValue_Retain((FLValue)d);
    }

    inline void FLMutableDict_Release(FLMutableDict FL_NULLABLE d) {
        FLValue_Release((FLValue)d);
    }

    FLEECE_PUBLIC FLDict FL_NULLABLE FLMutableDict_GetSource(FLMutableDict FL_NULLABLE) FLAPI;

    FLEECE_PUBLIC bool FLMutableDict_IsChanged(FLMutableDict FL_NULLABLE) FLAPI;

    FLEECE_PUBLIC void FLMutableDict_SetChanged(FLMutableDict FL_NULLABLE, bool) FLAPI;

    FLEECE_PUBLIC void FLMutableDict_Remove(FLMutableDict FL_NULLABLE, FLString key) FLAPI;

    FLEECE_PUBLIC void FLMutableDict_RemoveAll(FLMutableDict FL_NULLABLE) FLAPI;

    FLEECE_PUBLIC FLMutableArray FL_NULLABLE FLMutableDict_GetMutableArray(FLMutableDict FL_NULLABLE, FLString key) FLAPI;

    FLEECE_PUBLIC FLMutableDict FL_NULLABLE FLMutableDict_GetMutableDict(FLMutableDict FL_NULLABLE, FLString key) FLAPI;
 

    inline void FLMutableDict_SetNull(FLMutableDict, FLString key);
    inline void FLMutableDict_SetBool(FLMutableDict, FLString key, bool);
    inline void FLMutableDict_SetInt(FLMutableDict, FLString key, int64_t);
    inline void FLMutableDict_SetUInt(FLMutableDict, FLString key, uint64_t);
    inline void FLMutableDict_SetFloat(FLMutableDict, FLString key, float);
    inline void FLMutableDict_SetDouble(FLMutableDict, FLString key, double);
    inline void FLMutableDict_SetString(FLMutableDict, FLString key, FLString);
    inline void FLMutableDict_SetData(FLMutableDict, FLString key, FLSlice);
    inline void FLMutableDict_SetValue(FLMutableDict, FLString key, FLValue);
    inline void FLMutableDict_SetArray(FLMutableDict, FLString key, FLArray);
    inline void FLMutableDict_SetDict(FLMutableDict, FLString key, FLDict);

 
 
    //====== NEWSTRING, NEWDATA
 


    FLEECE_PUBLIC FLValue FL_NULLABLE FLValue_NewString(FLString) FLAPI;

    FLEECE_PUBLIC FLValue FL_NULLABLE FLValue_NewData(FLSlice) FLAPI;

 
 
    //====== VALUE SLOTS
 


    NODISCARD
    FLEECE_PUBLIC FLSlot FLMutableArray_Set(FLMutableArray, uint32_t index) FLAPI;

    NODISCARD
    FLEECE_PUBLIC FLSlot FLMutableArray_Append(FLMutableArray) FLAPI;

    NODISCARD
    FLEECE_PUBLIC FLSlot FLMutableDict_Set(FLMutableDict, FLString key) FLAPI;
 
 
    FLEECE_PUBLIC void FLSlot_SetNull(FLSlot) FLAPI;             
    FLEECE_PUBLIC void FLSlot_SetBool(FLSlot, bool) FLAPI;       
    FLEECE_PUBLIC void FLSlot_SetInt(FLSlot, int64_t) FLAPI;     
    FLEECE_PUBLIC void FLSlot_SetUInt(FLSlot, uint64_t) FLAPI;   
    FLEECE_PUBLIC void FLSlot_SetFloat(FLSlot, float) FLAPI;     
    FLEECE_PUBLIC void FLSlot_SetDouble(FLSlot, double) FLAPI;   
    FLEECE_PUBLIC void FLSlot_SetString(FLSlot, FLString) FLAPI; 
    FLEECE_PUBLIC void FLSlot_SetData(FLSlot, FLSlice) FLAPI;    
    FLEECE_PUBLIC void FLSlot_SetValue(FLSlot, FLValue) FLAPI;   
 
    inline void FLSlot_SetArray(FLSlot slot, FLArray array) {
        FLSlot_SetValue(slot, (FLValue)array);
    }
 
    inline void FLSlot_SetDict(FLSlot slot, FLDict dict) {
        FLSlot_SetValue(slot, (FLValue)dict);
    }

 
 
    //====== FORMATTED VALUE BUILDER
 


    NODISCARD
    FLEECE_PUBLIC FLValue FLValue_NewWithFormat(const char *format, ...) __printflike(1, 2);

    NODISCARD
    FLEECE_PUBLIC FLValue FLValue_NewWithFormatV(const char *format, va_list args);

    FLEECE_PUBLIC void FLMutableArray_UpdateWithFormat(FLMutableArray, const char *format, ...)
        __printflike(2, 3);

    FLEECE_PUBLIC void FLMutableDict_UpdateWithFormat(FLMutableDict, const char *format, ...)
        __printflike(2, 3);

    FLEECE_PUBLIC void FLValue_UpdateWithFormatV(FLValue, const char *format, va_list args);

 
 
    // implementations of the inline methods declared earlier:
 
    inline void FLMutableArray_SetNull(FLMutableArray a, uint32_t index) {
        FLSlot_SetNull(FLMutableArray_Set(a, index));
    }
    inline void FLMutableArray_SetBool(FLMutableArray a, uint32_t index, bool val) {
        FLSlot_SetBool(FLMutableArray_Set(a, index), val);
    }
    inline void FLMutableArray_SetInt(FLMutableArray a, uint32_t index, int64_t val) {
        FLSlot_SetInt(FLMutableArray_Set(a, index), val);
    }
    inline void FLMutableArray_SetUInt(FLMutableArray a, uint32_t index, uint64_t val) {
        FLSlot_SetUInt(FLMutableArray_Set(a, index), val);
    }
    inline void FLMutableArray_SetFloat(FLMutableArray a, uint32_t index, float val) {
        FLSlot_SetFloat(FLMutableArray_Set(a, index), val);
    }
    inline void FLMutableArray_SetDouble(FLMutableArray a, uint32_t index, double val) {
        FLSlot_SetDouble(FLMutableArray_Set(a, index), val);
    }
    inline void FLMutableArray_SetString(FLMutableArray a, uint32_t index, FLString val) {
        FLSlot_SetString(FLMutableArray_Set(a, index), val);
    }
    inline void FLMutableArray_SetData(FLMutableArray a, uint32_t index, FLSlice val) {
        FLSlot_SetData(FLMutableArray_Set(a, index), val);
    }
    inline void FLMutableArray_SetValue(FLMutableArray a, uint32_t index, FLValue val) {
        FLSlot_SetValue(FLMutableArray_Set(a, index), val);
    }
    inline void FLMutableArray_SetArray(FLMutableArray a, uint32_t index, FLArray val) {
        FLSlot_SetValue(FLMutableArray_Set(a, index), (FLValue)val);
    }
    inline void FLMutableArray_SetDict(FLMutableArray a, uint32_t index, FLDict val) {
        FLSlot_SetValue(FLMutableArray_Set(a, index), (FLValue)val);
    }
 
    inline void FLMutableArray_AppendNull(FLMutableArray a) {
        FLSlot_SetNull(FLMutableArray_Append(a));
    }
    inline void FLMutableArray_AppendBool(FLMutableArray a, bool val) {
        FLSlot_SetBool(FLMutableArray_Append(a), val);
    }
    inline void FLMutableArray_AppendInt(FLMutableArray a, int64_t val) {
        FLSlot_SetInt(FLMutableArray_Append(a), val);
    }
    inline void FLMutableArray_AppendUInt(FLMutableArray a, uint64_t val) {
        FLSlot_SetUInt(FLMutableArray_Append(a), val);
    }
    inline void FLMutableArray_AppendFloat(FLMutableArray a, float val) {
        FLSlot_SetFloat(FLMutableArray_Append(a), val);
    }
    inline void FLMutableArray_AppendDouble(FLMutableArray a, double val) {
        FLSlot_SetDouble(FLMutableArray_Append(a), val);
    }
    inline void FLMutableArray_AppendString(FLMutableArray a, FLString val) {
        FLSlot_SetString(FLMutableArray_Append(a), val);
    }
    inline void FLMutableArray_AppendData(FLMutableArray a, FLSlice val) {
        FLSlot_SetData(FLMutableArray_Append(a), val);
    }
    inline void FLMutableArray_AppendValue(FLMutableArray a, FLValue val) {
        FLSlot_SetValue(FLMutableArray_Append(a), val);
    }
    inline void FLMutableArray_AppendArray(FLMutableArray a, FLArray val) {
        FLSlot_SetValue(FLMutableArray_Append(a), (FLValue)val);
    }
    inline void FLMutableArray_AppendDict(FLMutableArray a, FLDict val) {
        FLSlot_SetValue(FLMutableArray_Append(a), (FLValue)val);
    }
 
    inline void FLMutableDict_SetNull(FLMutableDict d, FLString key) {
        FLSlot_SetNull(FLMutableDict_Set(d, key));
    }
    inline void FLMutableDict_SetBool(FLMutableDict d, FLString key, bool val) {
        FLSlot_SetBool(FLMutableDict_Set(d, key), val);
    }
    inline void FLMutableDict_SetInt(FLMutableDict d, FLString key, int64_t val) {
        FLSlot_SetInt(FLMutableDict_Set(d, key), val);
    }
    inline void FLMutableDict_SetUInt(FLMutableDict d, FLString key, uint64_t val) {
        FLSlot_SetUInt(FLMutableDict_Set(d, key), val);
    }
    inline void FLMutableDict_SetFloat(FLMutableDict d, FLString key, float val) {
        FLSlot_SetFloat(FLMutableDict_Set(d, key), val);
    }
    inline void FLMutableDict_SetDouble(FLMutableDict d, FLString key, double val) {
        FLSlot_SetDouble(FLMutableDict_Set(d, key), val);
    }
    inline void FLMutableDict_SetString(FLMutableDict d, FLString key, FLString val) {
        FLSlot_SetString(FLMutableDict_Set(d, key), val);
    }
    inline void FLMutableDict_SetData(FLMutableDict d, FLString key, FLSlice val) {
        FLSlot_SetData(FLMutableDict_Set(d, key), val);
    }
    inline void FLMutableDict_SetValue(FLMutableDict d, FLString key, FLValue val) {
        FLSlot_SetValue(FLMutableDict_Set(d, key), val);
    }
    inline void FLMutableDict_SetArray(FLMutableDict d, FLString key, FLArray val) {
        FLSlot_SetValue(FLMutableDict_Set(d, key), (FLValue)val);
    }
    inline void FLMutableDict_SetDict(FLMutableDict d, FLString key, FLDict val) {
        FLSlot_SetValue(FLMutableDict_Set(d, key), (FLValue)val);
    }
 

 
#ifdef __cplusplus
}
#endif
 
FL_ASSUME_NONNULL_END
 
#endif // _FLMUTABLE_H