object.h

Go to the documentation of this file.

/*
 * Copyright 2015-2017 Two Pore Guys, Inc.
 * All rights reserved
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted providing that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 */

#ifndef LIBRPC_OBJECT_H
#define LIBRPC_OBJECT_H

#include <stdint.h>
#include <stdbool.h>
#include <stdarg.h>
#include <sys/uio.h>
#include <sys/types.h>

#ifdef __cplusplus
extern "C" {
#endif

struct rpc_object;

typedef enum {
    RPC_TYPE_NULL,          
    RPC_TYPE_BOOL,          
    RPC_TYPE_UINT64,        
    RPC_TYPE_INT64,         
    RPC_TYPE_DOUBLE,        
    RPC_TYPE_DATE,          
    RPC_TYPE_STRING,        
    RPC_TYPE_BINARY,        
    RPC_TYPE_FD,            
    RPC_TYPE_DICTIONARY,        
    RPC_TYPE_ARRAY,         
    RPC_TYPE_ERROR,         
#if defined(__linux__)
        RPC_TYPE_SHMEM,         
#endif
} rpc_type_t;

typedef struct rpc_object *rpc_object_t;

typedef bool (^rpc_array_applier_t)(size_t index, _Nonnull rpc_object_t value);

typedef _Nonnull rpc_object_t (^rpc_array_mapper_t)(size_t index,
    _Nonnull rpc_object_t value);

typedef bool (^rpc_dictionary_applier_t)(const char *_Nonnull key,
    _Nonnull rpc_object_t value);

typedef _Nonnull rpc_object_t (^rpc_dictionary_mapper_t)(
    const char *_Nonnull key, _Nonnull rpc_object_t value);

typedef int (^rpc_array_cmp_t)(_Nonnull rpc_object_t o1,
    _Nonnull rpc_object_t o2);

typedef void (^rpc_binary_destructor_t)(void *_Nullable);

#define RPC_ARRAY_APPLIER(_fn, _arg)                    \
    ^(size_t _index, rpc_object_t _value) {             \
                return ((bool)_fn(_arg, _index, _value));       \
        }

#define RPC_DICTIONARY_APPLIER(_fn, _arg)               \
    ^(const char *_key, rpc_object_t _value) {          \
                return ((bool)_fn(_arg, _key, _value));         \
        }

#define RPC_ARRAY_CMP(_fn, _arg)                    \
    ^(rpc_object_t _o1, rpc_object_t _o2) {             \
                return ((int)_fn(_arg, _o1, _o2));          \
        }

#define RPC_BINARY_DESTRUCTOR(_fn)                  \
    ^(void *block) {                        \
        _fn(block);                     \
    }

#define RPC_BINARY_DESTRUCTOR_ARG(_fn, _arg)                \
    ^(void *_block) {                       \
        _fn(_arg, _block);                  \
    }


_Nonnull rpc_object_t rpc_retain(_Nonnull rpc_object_t object);

int rpc_release_impl(_Nonnull rpc_object_t object);

int rpc_get_refcount(_Nullable rpc_object_t object);

size_t rpc_get_line_number(_Nonnull rpc_object_t object);

size_t rpc_get_column_number(_Nonnull rpc_object_t object);

_Nonnull rpc_object_t rpc_copy(_Nonnull rpc_object_t object);

int rpc_cmp(_Nullable rpc_object_t o1, _Nullable rpc_object_t o2);

bool rpc_equal(_Nullable rpc_object_t o1, _Nullable rpc_object_t o2);

size_t rpc_hash(_Nonnull rpc_object_t object);

char *_Nonnull rpc_copy_description(_Nonnull rpc_object_t object);

rpc_type_t rpc_get_type(_Nonnull rpc_object_t object);

const char *_Nullable rpc_get_type_name(rpc_type_t type);

#define rpc_is_error(_object)   (rpc_get_type(_object) == RPC_TYPE_ERROR)

#define rpc_release(_object)                        \
    do {                                \
        if (rpc_release_impl(_object) == 0)         \
            (_object) = NULL;               \
    } while(0)

#define rpc_swap(_old, _new)                        \
    do {                                \
        rpc_release(_old);                  \
        (_old) = (_new);                    \
    } while (0)

_Nullable rpc_object_t rpc_get_last_error(void);

_Nullable rpc_object_t rpc_object_pack(const char *_Nonnull fmt, ...);

_Nullable rpc_object_t rpc_object_vpack(const char *_Nonnull fmt, va_list ap);

int rpc_object_unpack(_Nonnull rpc_object_t, const char *_Nonnull fmt, ...);

int rpc_object_vunpack(_Nonnull rpc_object_t, const char *_Nonnull fmt,
    va_list ap);

_Nonnull rpc_object_t rpc_null_create(void);

_Nonnull rpc_object_t rpc_bool_create(bool value);

bool rpc_bool_get_value(_Nonnull rpc_object_t xbool);

_Nonnull rpc_object_t rpc_int64_create(int64_t value);

int64_t rpc_int64_get_value(_Nonnull rpc_object_t xint);

_Nonnull rpc_object_t rpc_uint64_create(uint64_t value);

uint64_t rpc_uint64_get_value(_Nonnull rpc_object_t xuint);

_Nonnull rpc_object_t rpc_double_create(double value);

double rpc_double_get_value(_Nonnull rpc_object_t xdouble);

_Nonnull rpc_object_t rpc_date_create(int64_t interval);

_Nonnull rpc_object_t rpc_date_create_from_current(void);

int64_t rpc_date_get_value(_Nonnull rpc_object_t xdate);

_Nonnull rpc_object_t rpc_data_create(const void *_Nullable bytes,
    size_t length, _Nullable rpc_binary_destructor_t destructor);

_Nonnull rpc_object_t rpc_data_create_iov(struct iovec *_Nonnull iov,
    size_t niov);

size_t rpc_data_get_length(_Nonnull rpc_object_t xdata);

const void *_Nullable rpc_data_get_bytes_ptr(_Nonnull rpc_object_t xdata);

size_t rpc_data_get_bytes(_Nonnull rpc_object_t xdata, void *_Nonnull buffer,
    size_t off, size_t length);

_Nonnull rpc_object_t rpc_string_create(const char *_Nonnull string);

_Nonnull rpc_object_t rpc_string_create_len(const char *_Nonnull string,
    size_t length);

_Nonnull rpc_object_t rpc_string_create_with_format(const char *_Nonnull fmt,
    ...);

_Nonnull rpc_object_t rpc_string_create_with_format_and_arguments(
    const char *_Nonnull fmt, va_list ap);

size_t rpc_string_get_length(_Nonnull rpc_object_t xstring);

const char *_Nullable rpc_string_get_string_ptr(_Nonnull rpc_object_t xstring);

_Nonnull rpc_object_t rpc_fd_create(int fd);

int rpc_fd_dup(_Nonnull rpc_object_t xfd);

int rpc_fd_get_value(_Nonnull rpc_object_t xfd);

_Nonnull rpc_object_t rpc_array_create(void);

_Nonnull rpc_object_t rpc_array_create_ex(
    const _Nonnull rpc_object_t *_Nonnull objects, size_t count,
    bool steal);

void rpc_array_set_value(_Nonnull rpc_object_t array, size_t index,
    _Nullable rpc_object_t value);

void rpc_array_steal_value(_Nonnull rpc_object_t array, size_t index,
    _Nullable rpc_object_t value);

void rpc_array_remove_index(_Nonnull rpc_object_t array, size_t index);

void rpc_array_remove_all(_Nonnull rpc_object_t array);

void rpc_array_append_value(_Nonnull rpc_object_t array,
    _Nonnull rpc_object_t value);

void rpc_array_append_stolen_value(_Nonnull rpc_object_t array,
    _Nonnull rpc_object_t value);

_Nullable rpc_object_t rpc_array_get_value(_Nonnull rpc_object_t array,
    size_t index);

size_t rpc_array_get_count(_Nonnull rpc_object_t array);

bool rpc_array_apply(_Nonnull rpc_object_t array,
    _Nonnull rpc_array_applier_t applier);

void rpc_array_map(_Nonnull rpc_object_t array,
    _Nonnull rpc_array_mapper_t mapper);

bool rpc_array_contains(_Nonnull rpc_object_t array,
    _Nonnull rpc_object_t value);

bool rpc_array_reverse_apply(_Nonnull rpc_object_t array,
    _Nonnull rpc_array_applier_t applier);

void rpc_array_sort(_Nonnull rpc_object_t array,
    _Nonnull rpc_array_cmp_t comparator);

_Nonnull rpc_object_t rpc_array_slice(_Nonnull rpc_object_t array,
    size_t start, ssize_t len);

void rpc_array_set_bool(_Nonnull rpc_object_t array, size_t index, bool value);

void rpc_array_set_int64(_Nonnull rpc_object_t array, size_t index,
    int64_t value);

void rpc_array_set_uint64(_Nonnull rpc_object_t array, size_t index,
    uint64_t value);

void rpc_array_set_double(_Nonnull rpc_object_t array, size_t index,
    double value);

void rpc_array_set_date(_Nonnull rpc_object_t array, size_t index,
    int64_t value);

void rpc_array_set_data(_Nonnull rpc_object_t array, size_t index,
    const void *_Nullable bytes,
    size_t length);

void rpc_array_set_string(_Nonnull rpc_object_t array, size_t index,
    const char *_Nonnull value);

void rpc_array_set_fd(_Nonnull rpc_object_t array, size_t index, int value);

bool rpc_array_get_bool(_Nonnull rpc_object_t array, size_t index);

int64_t rpc_array_get_int64(_Nonnull rpc_object_t array, size_t index);

uint64_t rpc_array_get_uint64(_Nonnull rpc_object_t array, size_t index);

double rpc_array_get_double(_Nonnull rpc_object_t array, size_t index);

int64_t rpc_array_get_date(_Nonnull rpc_object_t array, size_t index);

const void *_Nullable rpc_array_get_data(_Nonnull rpc_object_t array,
    size_t index, size_t *_Nullable length);

const char *_Nullable rpc_array_get_string(_Nonnull rpc_object_t array,
    size_t index);

int rpc_array_get_fd(_Nonnull rpc_object_t array, size_t index);

int rpc_array_dup_fd(_Nonnull rpc_object_t array, size_t index);

#if defined(__linux__)

_Nullable rpc_object_t rpc_shmem_create(size_t size);

void *_Nonnull rpc_shmem_map(_Nonnull rpc_object_t shmem);

void rpc_shmem_unmap(_Nonnull rpc_object_t shmem, void *_Nonnull addr);

size_t rpc_shmem_get_size(_Nonnull rpc_object_t shmem);
#endif

_Nonnull rpc_object_t rpc_error_create(int code, const char *_Nonnull msg,
    _Nullable rpc_object_t extra);

_Nonnull rpc_object_t rpc_error_create_with_stack(int code,
    const char *_Nonnull msg, _Nullable rpc_object_t extra,
    _Nullable rpc_object_t stack);

int rpc_error_get_code(_Nonnull rpc_object_t error);

const char *_Nullable rpc_error_get_message(_Nonnull rpc_object_t error);

_Nullable rpc_object_t rpc_error_get_extra(_Nonnull rpc_object_t error);

void rpc_error_set_extra(_Nonnull rpc_object_t error,
    _Nonnull rpc_object_t extra);

_Nullable rpc_object_t rpc_error_get_stack(_Nonnull rpc_object_t error);

_Nonnull rpc_object_t rpc_dictionary_create(void);

_Nonnull rpc_object_t rpc_dictionary_create_ex(
    const char *const _Nonnull *_Nullable keys,
    const _Nonnull rpc_object_t *_Nullable values, size_t count, bool steal);

void rpc_dictionary_set_value(_Nonnull rpc_object_t dictionary,
    const char *_Nonnull key, _Nonnull rpc_object_t value);

void rpc_dictionary_steal_value(_Nonnull rpc_object_t dictionary,
    const char *_Nonnull key, rpc_object_t _Nonnull value);

void rpc_dictionary_remove_key(_Nonnull rpc_object_t dictionary,
    const char *_Nonnull key);

void rpc_dictionary_remove_all(_Nonnull rpc_object_t dictionary);

_Nullable rpc_object_t rpc_dictionary_detach_key(
    _Nonnull rpc_object_t dictionary, const char *_Nonnull key);

_Nullable rpc_object_t rpc_dictionary_get_value(
    _Nonnull rpc_object_t dictionary, const char *_Nonnull key);

size_t rpc_dictionary_get_count(_Nonnull rpc_object_t dictionary);

bool rpc_dictionary_apply(_Nonnull rpc_object_t dictionary,
    _Nonnull rpc_dictionary_applier_t applier);

void rpc_dictionary_map(_Nonnull rpc_object_t dictionary,
    _Nonnull rpc_dictionary_mapper_t mapper);

bool rpc_dictionary_has_key(_Nonnull rpc_object_t dictionary,
    const char *_Nonnull key);

void rpc_dictionary_set_bool(_Nonnull rpc_object_t dictionary,
    const char *_Nonnull key, bool value);

void rpc_dictionary_set_int64(_Nonnull rpc_object_t dictionary,
    const char *_Nonnull key, int64_t value);

void rpc_dictionary_set_uint64(_Nonnull rpc_object_t dictionary,
    const char *_Nonnull key, uint64_t value);

void rpc_dictionary_set_double(_Nonnull rpc_object_t dictionary,
    const char *_Nonnull key, double value);

void rpc_dictionary_set_date(_Nonnull rpc_object_t dictionary,
    const char *_Nonnull key, int64_t value);

void rpc_dictionary_set_data(_Nonnull rpc_object_t dictionary,
    const char *_Nonnull key, const void *_Nonnull value, size_t length);

void rpc_dictionary_set_string(_Nonnull rpc_object_t dictionary,
    const char *_Nonnull key, const char *_Nonnull value);

void rpc_dictionary_set_fd(_Nonnull rpc_object_t dictionary,
    const char *_Nonnull key, int value);

bool rpc_dictionary_get_bool(_Nonnull rpc_object_t dictionary,
    const char *_Nonnull key);

int64_t rpc_dictionary_get_int64(_Nonnull rpc_object_t dictionary,
    const char *_Nonnull key);

uint64_t rpc_dictionary_get_uint64(_Nonnull rpc_object_t dictionary,
    const char *_Nonnull key);

double rpc_dictionary_get_double(_Nonnull rpc_object_t dictionary,
    const char *_Nonnull key);

int64_t rpc_dictionary_get_date(_Nonnull rpc_object_t dictionary,
    const char *_Nonnull key);

const void *_Nullable rpc_dictionary_get_data(_Nonnull rpc_object_t dictionary,
    const char *_Nonnull key, size_t *_Nullable length);

const char *_Nullable rpc_dictionary_get_string(
    _Nonnull rpc_object_t dictionary, const char *_Nonnull key);

int rpc_dictionary_get_fd(_Nonnull rpc_object_t dictionary,
    const char *_Nonnull key);

int rpc_dictionary_dup_fd(_Nonnull rpc_object_t dictionary,
    const char *_Nonnull key);

inline static void __rpc_raii_release(_Nonnull rpc_object_t *_Nullable object)
{
    rpc_release_impl(*object);
}

#define rpc_auto_object_t                       \
    __attribute__((cleanup(__rpc_raii_release))) rpc_object_t


#ifdef __cplusplus
}
#endif

#endif /* LIBRPC_OBJECT_H */