/* IBM_PROLOG_BEGIN_TAG                                                   */
/* This is an automatically generated prolog.                             */
/*                                                                        */
/* $Source: clib/value.h $                                                */
/*                                                                        */
/* OpenPOWER FFS Project                                                  */
/*                                                                        */
/* Contributors Listed Below - COPYRIGHT 2014,2015                        */
/* [+] International Business Machines Corp.                              */
/*                                                                        */
/*                                                                        */
/* 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.                         */
/*                                                                        */
/* IBM_PROLOG_END_TAG                                                     */

/*!
 * @file value.h
 * @brief Value Container
 * @details Values are a kind of variant structure that can contain
 *          values of different types
 * @author Shaun Wetzstein <shaun@us.ibm.com>
 * @date 2010-2011
 */

#ifndef __VALUE_H__
#define __VALUE_H__

#include <stdint.h>
#include <stdbool.h>

#include "libclib.h"

/* ======================================================================= */

typedef enum value_type_enum value_type_t;	//!< Alias for the @em value_type_enum enum
typedef struct value value_t;	//!< Alias for the @em value  class

/*!
 * @brief Value types
 * @details Supported value type
 */
enum value_type_enum {
	VT_UNKNOWN = 0,		//!< Uninitialized or unknown type
	VT_I8,			//!<  8-bit signed integer type
	VT_I16,			//!< 16-bit signed integer type
	VT_I32,			//!< 32-bit signed integer type
	VT_I64,			//!< 64-bit signed integer type
	VT_U8,			//!<  8-bit unsigned integer type
	VT_U16,			//!< 16-bit unsigned integer type
	VT_U32,			//!< 32-bit unsigned integer type
	VT_U64,			//!< 64-bit unsigned integer type
	VT_REAL32,		//!< 32-bit float type
	VT_REAL64,		//!< 64-bit float type
	VT_STR,			//!< Character string type
	VT_STR_INLINE,		//!< Character string inline type
	VT_STR_OFF,		//!< Character string offset type
	VT_STR_CONST,		//!< Constant character string type
	VT_BLOB,		//!< Blob type
	VT_BLOB_INLINE,		//!< Blob inline type
	VT_BLOB_OFF,		//!< Blob offset type
	VT_BLOB_FILE,		//!< Blob file type
} /*! @cond */ __packed /*! @endcond */ ;

/*! @cond */
#ifndef VALUE_PAD_DEFAULT
#define VALUE_PAD_DEFAULT 12
#endif
/*! @endcond */ ;

/*!
 * @brief value container
 */
struct value {
	uint32_t type:8,	//!< Value type
	 size:24;		//!< Value size (in bytes)

	union {
		int8_t i8;	//!<  8-bit signed integer
		int16_t i16;	//!< 16-bit signed integer
		int32_t i32;	//!< 32-bit signed integer
		int64_t i64;	//!< 64-bit signed integer

		uint8_t u8;	//!<  8-bit unsigned integer
		uint16_t u16;	//!< 16-bit unsigned integer
		uint32_t u32;	//!< 32-bit unsigned integer
		uint64_t u64;	//!< 64-bit unsigned integer

		float r32;	//!< 32-bit float
		double r64;	//!< 64-bit float

		void *ptr;	//!< pointer

		uint8_t data[VALUE_PAD_DEFAULT];
	};			//!< Anonymous variant record
};

/* ==================================================================== */

/*! @cond */
#define value_type(...) STRCAT(value_type, NARGS(__VA_ARGS__))(__VA_ARGS__)
static inline value_type_t value_type1(const value_t * self)
{
	return self ? self->type : VT_UNKNOWN;
}

static inline void value_type2(value_t * self, value_type_t type)
{
	if (self != NULL)
		self->type = type;
}

/*! @endcond */

/*! @cond */
#define value_size(...) STRCAT(value_size, NARGS(__VA_ARGS__))(__VA_ARGS__)
static inline uint32_t value_size1(const value_t * self)
{
	return self ? self->size : 0;
}

static inline void value_size2(value_t * self, uint32_t size)
{
	if (self != NULL)
		self->size = size;
}

/*! @endcond */

/*!
 * @brief Clear the contents of a @em value
 * @memberof value
 * @param self [in] value object @em self pointer
 */
static inline void value_clear(value_t * self)
{
	if (self != NULL) {
		if (self->type == VT_BLOB || self->type == VT_STR)
			if (self->ptr != NULL)
				free(self->ptr);
		memset(self, 0, sizeof *self);
	}
}

#define value_i8(...) STRCAT(value_i8_, NARGS(__VA_ARGS__))(__VA_ARGS__)
static inline int8_t value_i8_1(const value_t * v)
{
	assert(value_type(v) == VT_I8);
	return v->i8;
}

static inline value_t *value_i8_2(value_t * v, const int8_t i8)
{
	value_clear(v), v->type = VT_I8, v->i8 = i8, v->size = sizeof(i8);
	return v;
}

#define value_i16(...) STRCAT(value_i16_, NARGS(__VA_ARGS__))(__VA_ARGS__)
static inline int16_t value_i16_1(const value_t * v)
{
	assert(value_type(v) == VT_I16);
	return v->i16;
}

static inline value_t *value_i16_2(value_t * v, const int16_t i16)
{
	value_clear(v), v->type = VT_I16, v->i16 = i16, v->size = sizeof(i16);
	return v;
}

#define value_i32(...) STRCAT(value_i32_, NARGS(__VA_ARGS__))(__VA_ARGS__)
static inline int32_t value_i32_1(const value_t * v)
{
	assert(value_type(v) == VT_I32);
	return v->i32;
}

static inline value_t *value_i32_2(value_t * v, const int32_t i32)
{
	value_clear(v), v->type = VT_I32, v->i32 = i32, v->size = sizeof(i32);
	return v;
}

#define value_i64(...) STRCAT(value_i64_, NARGS(__VA_ARGS__))(__VA_ARGS__)
static inline int64_t value_i64_1(const value_t * v)
{
	assert(value_type(v) == VT_I64);
	return v->i64;
}

static inline value_t *value_i64_2(value_t * v, const int64_t i64)
{
	value_clear(v), v->type = VT_I64, v->i64 = i64, v->size = sizeof(i64);
	return v;
}

#define value_u8(...) STRCAT(value_u8_, NARGS(__VA_ARGS__))(__VA_ARGS__)
static inline uint8_t value_u8_1(const value_t * v)
{
	assert(value_type(v) == VT_U8);
	return v->u8;
}

static inline value_t *value_u8_2(value_t * v, const uint8_t u8)
{
	value_clear(v), v->type = VT_U8, v->u8 = u8, v->size = sizeof(u8);
	return v;
}

#define value_u16(...) STRCAT(value_u16_, NARGS(__VA_ARGS__))(__VA_ARGS__)
static inline uint16_t value_u16_1(const value_t * v)
{
	assert(value_type(v) == VT_U16);
	return v->u16;
}

static inline value_t *value_u16_2(value_t * v, const uint16_t u16)
{
	value_clear(v), v->type = VT_U16, v->u16 = u16, v->size = sizeof(u16);
	return v;
}

#define value_u32(...) STRCAT(value_u32_, NARGS(__VA_ARGS__))(__VA_ARGS__)
static inline uint32_t value_u32_1(const value_t * v)
{
	assert(value_type(v) == VT_U32);
	return v->u32;
}

static inline value_t *value_u32_2(value_t * v, const uint32_t u32)
{
	value_clear(v), v->type = VT_U32, v->u32 = u32, v->size = sizeof(u32);
	return v;
}

#define value_u64(...) STRCAT(value_u64_, NARGS(__VA_ARGS__))(__VA_ARGS__)
static inline uint64_t value_u64_1(const value_t * v)
{
	assert(value_type(v) == VT_U64);
	return v->u64;
}

static inline value_t *value_u64_2(value_t * v, const uint64_t u64)
{
	value_clear(v), v->type = VT_U64, v->u64 = u64, v->size = sizeof(u64);
	return v;
}

#define value_float(...) STRCAT(value_float_, NARGS(__VA_ARGS__))(__VA_ARGS__)
static inline float value_float1(const value_t * v)
{
	assert(value_type(v) == VT_REAL32);
	return v->r32;
}

static inline value_t *value_float2(value_t * v, const float r32)
{
	value_clear(v), v->type = VT_REAL32, v->r32 = r32, v->size =
	    sizeof(r32);
	return v;
}

#define value_double(...) STRCAT(value_double, NARGS(__VA_ARGS__))(__VA_ARGS__)
static inline double value_double1(const value_t * v)
{
	assert(value_type(v) == VT_REAL64);
	return v->r64;
}

static inline value_t *value_double2(value_t * v, const double r64)
{
	value_clear(v), v->type = VT_REAL64, v->r64 = r64, v->size =
	    sizeof(r64);
	return v;
}

#define value_blob(...) STRCAT(value_blob, NARGS(__VA_ARGS__))(__VA_ARGS__)
/*! @cond */
static inline void *value_blob1(const value_t * v)
{
	if (value_type(v) == VT_BLOB)
		return v->ptr;
	else if (value_type(v) == VT_BLOB_INLINE)
		return (void *)v->data;
	else if (value_type(v) == VT_BLOB_OFF)
		return NULL;
	else if (value_type(v) == VT_BLOB_FILE) ;
	else {
		UNEXPECTED("invalid value_t blob type '%d'", value_type(v));
	}

	return NULL;
}

static inline value_t *value_blob4(value_t * self, const void *blob, size_t len,
				   size_t pad)
{
	value_clear(self);

	if (pad <= len) {
		self->ptr = malloc(len + 1);
		self->type = VT_BLOB;

		memcpy(self->ptr, blob, len);
		memset(self->ptr + len, 0, 1);
	} else {
		self->type = VT_BLOB_INLINE;

		memcpy(self->data, blob, len);
		self->data[len] = '\0';
	}

	self->size = len;

	return self;
}

static inline value_t *value_blob3(value_t * self, const void *blob, size_t len)
{
	return value_blob4(self, blob, len, VALUE_PAD_DEFAULT);
}

static inline value_t *value_blob2(value_t * self, const char *path)
{
	value_t *rc = value_blob4(self, path, strlen(path), VALUE_PAD_DEFAULT);
	if (rc != NULL)
		value_type(rc, VT_BLOB_FILE);
	return rc;
}

/*! @endcond */

#define value_string(...) STRCAT(value_string, NARGS(__VA_ARGS__))(__VA_ARGS__)
/*! @cond */
static inline char *value_string1(const value_t * v)
{
	if (value_type(v) == VT_STR)
		return (char *)v->ptr;
	else if (value_type(v) == VT_STR_INLINE)
		return (char *)v->data;
	else if (value_type(v) == VT_STR_OFF) ;
	else {
		UNEXPECTED("invalid value string type '%d'", value_type(v));
	}

	return NULL;
}

static inline value_t *value_string4(value_t * self, const char *str,
				     size_t len, size_t pad)
{
	value_blob(self, (const char *)str, len, pad);

	if (self->type == VT_BLOB)
		self->type = VT_STR;
	else if (self->type == VT_BLOB_INLINE)
		self->type = VT_STR_INLINE;

	return self;
}

static inline value_t *value_string3(value_t * self, const char *str,
				     size_t len)
{
	return value_string4(self, str, len, VALUE_PAD_DEFAULT);
}

static inline value_t *value_string2(value_t * self, const char *str)
{
	return value_string4(self, str, strlen(str), VALUE_PAD_DEFAULT);
}

static inline value_t *value_set_string_const(value_t * self, const char *str,
					      size_t len)
{
	value_clear(self);

	self->type = VT_STR_CONST;
	self->ptr = (void *)str;
	self->size = len;

	return self;
}

static inline value_t *value_set_string_offset(value_t * self, size_t off,
					       size_t len)
{
	value_clear(self);

	self->type = VT_STR_OFF;
	self->u32 = off;
	self->size = len;

	return self;
}

/*! @endcond */

/*!
 * @brief Pretty print the contents of a @em value to stdout
 * @memberof value
 * @param self [in] value object @em self pointer
 * @param out [in] output stream
 */
extern void value_dump(const value_t * self, FILE * out)
/*! @cond */
__nonnull((1, 2)) /*! @endcond */ ;

/*! @cond */
#define __choose__	__builtin_choose_expr
#define __compat__	__builtin_types_compatible_p
#define __const__	__builtin_constant_p
/*! @endcond */

/*!
 * @fn T value_get(const value * self, T)
 * @brief Return a @em value as primitive type @em T
 * @note @em T can be one fo the following types:
 *       - @em char, @em int8_t
 *       - @em short, @em int16_t
 *       - @em int, @em long @em int32_t
 *       - @em long @em long, @em int64_t
 *       - @em unsigned @em char, @em uint8_t
 *       - @em unsigned @em short, @em uint16_t
 *       - @em unsigned @em int, @em long @em uint32_t
 *       - @em unsigned @em long @em long, @em uint64_t
 *       - @em float, @em double
 *       - @em char @em *, @em unsigned @em char @em *
 * @memberof value
 * @param self [in] value object @em self pointer
 * @param T [in] Type to cast
 * @throws ASSERTION if T is not equal to the object's type
 */

#if DELETE
/*! @cond */
#define value_get(v, T)	({					\
    __choose__(__compat__(T, char),				\
           value_get_int8((v)),					\
    __choose__(__compat__(T, int8_t),				\
           value_get_int8((v)),					\
    __choose__(__compat__(T, short),				\
           value_get_int16((v)),				\
    __choose__(__compat__(T, int16_t),				\
           value_get_int16((v)),				\
    __choose__(__compat__(T, int),				\
           value_get_int32((v)),				\
    __choose__(__compat__(T, long),				\
           value_get_int32((v)),				\
    __choose__(__compat__(T, int32_t),				\
           value_get_int32((v)),				\
    __choose__(__compat__(T, long long),			\
           value_get_int64((v)),				\
    __choose__(__compat__(T, int64_t),				\
           value_get_int64((v)),				\
    __choose__(__compat__(T, unsigned char),			\
           value_get_uint8((v)),				\
    __choose__(__compat__(T, uint8_t),				\
           value_get_uint8((v)),				\
    __choose__(__compat__(T, unsigned short),			\
           value_get_uint16((v)),				\
    __choose__(__compat__(T, uint16_t),				\
           value_get_uint16((v)),				\
    __choose__(__compat__(T, unsigned int),			\
           value_get_uint32((v)),				\
    __choose__(__compat__(T, unsigned long),			\
           value_get_uint32((v)),				\
    __choose__(__compat__(T, uint32_t),				\
           value_get_uint32((v)),				\
    __choose__(__compat__(T, unsigned long long),		\
           value_get_uint64((v)),				\
    __choose__(__compat__(T, uint64_t),				\
           value_get_uint64((v)),				\
    __choose__(__compat__(T, float),				\
           value_get_float((v)),				\
    __choose__(__compat__(T, double),				\
           value_get_double((v)),				\
    __choose__(__compat__(T, char *),				\
           value_get_string((v)),				\
    __choose__(__compat__(T, unsigned char *),			\
           value_get_string((v)),				\
    0xDEADBEEF))))))))))))))))))))));				\
})
/*! @endcond */
#endif
/*!
 * @fn void value_set(const value * self, T v)
 * @brief Assign a @em value to @em T v
 * @memberof value
 * @param self [in] value object @em self pointer
 * @param v [in] value to assign
 */

#if 0
/*! @cond */
#define value_set(v, x)	({						\
     __choose__(__compat__(typeof (x), char),				\
           value_set_int8((v),(int8_t)(intptr_t)(x)),			\
    __choose__(__compat__(typeof (x), int8_t),				\
           value_set_int8((v),(int8_t)(intptr_t)(x)),			\
    __choose__(__compat__(typeof (x), short),				\
           value_set_int16((v),(int16_t)(intptr_t)(x)),			\
    __choose__(__compat__(typeof (x), int16_t),				\
           value_set_int16((v),(int16_t)(intptr_t)(x)),			\
    __choose__(__compat__(typeof (x), int),				\
           value_set_int32((v),(int32_t)(intptr_t)(x)),			\
    __choose__(__compat__(typeof (x), long),				\
           value_set_int32((v),(int32_t)(intptr_t)(x)),			\
    __choose__(__compat__(typeof (x), int32_t),				\
           value_set_int32((v),(int32_t)(intptr_t)(x)),			\
    __choose__(__compat__(typeof (x), long long),			\
           value_set_int64((v),(int64_t)(intptr_t)(x)),			\
    __choose__(__compat__(typeof (x), int64_t),				\
           value_set_int64((v),(int64_t)(intptr_t)(x)),			\
    __choose__(__compat__(typeof (x), unsigned char),			\
           value_set_uint8((v),(uint8_t)(intptr_t)(x)),			\
    __choose__(__compat__(typeof (x), uint8_t),				\
           value_set_uint8((v),(uint8_t)(intptr_t)(x)),			\
    __choose__(__compat__(typeof (x), unsigned short),			\
           value_set_uint16((v),(uint16_t)(intptr_t)(x)),		\
    __choose__(__compat__(typeof (x), uint16_t),			\
           value_set_uint16((v),(uint16_t)(intptr_t)(x)),		\
    __choose__(__compat__(typeof (x), unsigned int),			\
           value_set_uint32((v),(uint32_t)(intptr_t)(x)),		\
    __choose__(__compat__(typeof (x), unsigned long),			\
           value_set_uint32((v),(uint32_t)(intptr_t)(x)),		\
    __choose__(__compat__(typeof (x), uint32_t),			\
           value_set_uint32((v),(uint32_t)(intptr_t)(x)),		\
    __choose__(__compat__(typeof (x), unsigned long long),		\
           value_set_uint64((v),(uint64_t)(intptr_t)(x)),		\
    __choose__(__compat__(typeof (x), uint64_t),			\
           value_set_uint64((v),(uint64_t)(intptr_t)(x)),		\
    __choose__(__compat__(typeof (x), float),				\
           value_set_float((v),(float)(intptr_t)(x)),			\
    __choose__(__compat__(typeof (x), double),				\
           value_set_double((v),(double)(intptr_t)(x)),			\
    __choose__(__compat__(typeof (x), char *),				\
        __choose__(__const__((x)),					\
            value_set_string_const((v),(const char *)(intptr_t)(x),	\
                                   strlen((const char *)(intptr_t)(x))),\
           value_set_string((v),(char *)(intptr_t)(x),			\
                            strlen((const char *)(intptr_t)(x)))),	\
    __choose__(__compat__(typeof (x), unsigned char *),			\
        __choose__(__const__((x)),					\
            value_set_string_const((v),(const char *)(intptr_t)(x),	\
                                   strlen((const char *)(intptr_t)(x))),\
            value_set_string((v),(const char *)(intptr_t)(x),		\
                             strlen((const char *)(intptr_t)(x)))),	\
   ((void)0)))))))))))))))))))))));					\
})
/*! @endcond */
#endif

/* ==================================================================== */

#endif				/* __VALUE_H__ */