JSONSerializers.h

Go to the documentation of this file.

/*
 * Objectively: Ultra-lightweight object oriented framework for GNU C.
 * Copyright (C) 2014 Jay Dolan <jay@jaydolan.com>
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 * claim that you wrote the original software. If you use this software
 * in a product, an acknowledgment in the product documentation would be
 * appreciated but is not required.
 *
 * 2. Altered source versions must be plainly marked as such, and must not be
 * misrepresented as being the original software.
 *
 * 3. This notice may not be removed or altered from any source distribution.
 */
 
#pragma once
 
#include <stddef.h>
#include <stdint.h>
 
#include <Objectively/Array.h>
#include <Objectively/Date.h>
#include <Objectively/Dictionary.h>
#include <Objectively/Set.h>
#include <Objectively/Object.h>
#include <Objectively/URL.h>
 
typedef struct JSONProperties JSONProperties;
typedef struct JSONProperty JSONProperty;
typedef struct JSONContext JSONContext;
 
typedef ident (*JSONSerializer)(const JSONProperties *properties,
                                const JSONProperty *property,
                                ident value,
                                ident data,
                                JSONContext *context);
 
typedef bool (*JSONDeserializer)(const JSONProperties *properties,
                                 const JSONProperty *property,
                                 const Object *value,
                                 ident field,
                                 JSONContext *context);
 
struct JSONProperty {
 
  const char *key;
 
  ptrdiff_t offset;
 
  size_t size;
 
  JSONSerializer serializer;
 
  JSONDeserializer deserializer;
 
  ident data;
};
 
struct JSONProperties {
 
  const char *name;
 
  size_t size;
 
  const JSONProperty *properties;
};
 
#define MakeJSONPropertyWithKey(Struct, field, key_, serializer_, deserializer_, data_) \
  (JSONProperty) { \
    .key = (key_), \
    .offset = (ptrdiff_t) offsetof(Struct, field), \
    .size = sizeof(((Struct *) NULL)->field), \
    .serializer = (serializer_), \
    .deserializer = (deserializer_), \
    .data = (data_) \
  }
 
#define MakeJSONProperty(Struct, field, serializer_, deserializer_, data_) \
  MakeJSONPropertyWithKey(Struct, field, #field, serializer_, deserializer_, data_)
 
#define MakeJSONProperties(Struct, ...) \
  (JSONProperties) { \
    .name = #Struct, \
    .size = sizeof(Struct), \
    .properties = (const JSONProperty[]) { \
      __VA_ARGS__, \
      (JSONProperty) { .key = NULL } \
    } \
  }
 
#pragma mark - Standard JSONSerializers
 
OBJECTIVELY_EXPORT ident JSONSerializeCharacters(const JSONProperties *properties,
                                                 const JSONProperty *property,
                                                 ident value,
                                                 ident data,
                                                 JSONContext *context);
 
OBJECTIVELY_EXPORT ident JSONSerializeCString(const JSONProperties *properties,
                                              const JSONProperty *property,
                                              ident value,
                                              ident data,
                                              JSONContext *context);
 
OBJECTIVELY_EXPORT ident JSONSerializeInt32(const JSONProperties *properties,
                                            const JSONProperty *property,
                                            ident value,
                                            ident data,
                                            JSONContext *context);
 
OBJECTIVELY_EXPORT ident JSONSerializeUint32(const JSONProperties *properties,
                                             const JSONProperty *property,
                                             ident value,
                                             ident data,
                                             JSONContext *context);
 
OBJECTIVELY_EXPORT ident JSONSerializeInt64(const JSONProperties *properties,
                                            const JSONProperty *property,
                                            ident value,
                                            ident data,
                                            JSONContext *context);
 
OBJECTIVELY_EXPORT ident JSONSerializeUint64(const JSONProperties *properties,
                                             const JSONProperty *property,
                                             ident value,
                                             ident data,
                                             JSONContext *context);
 
OBJECTIVELY_EXPORT ident JSONSerializeFloat(const JSONProperties *properties,
                                            const JSONProperty *property,
                                            ident value,
                                            ident data,
                                            JSONContext *context);
 
OBJECTIVELY_EXPORT ident JSONSerializeDouble(const JSONProperties *properties,
                                             const JSONProperty *property,
                                             ident value,
                                             ident data,
                                             JSONContext *context);
 
OBJECTIVELY_EXPORT ident JSONSerializeBoole(const JSONProperties *properties,
                                            const JSONProperty *property,
                                            ident value,
                                            ident data,
                                            JSONContext *context);
 
OBJECTIVELY_EXPORT ident JSONSerializeStruct(const JSONProperties *properties,
                                             const JSONProperty *property,
                                             ident value,
                                             ident data,
                                             JSONContext *context);
 
OBJECTIVELY_EXPORT ident JSONSerializeArray(const JSONProperties *properties,
                                            const JSONProperty *property,
                                            ident value,
                                            ident data,
                                            JSONContext *context);
 
#pragma mark - Standard JSONDeserializers
 
OBJECTIVELY_EXPORT bool JSONDeserializeCharacters(const JSONProperties *properties,
                                                  const JSONProperty *property,
                                                  const Object *value,
                                                  ident field,
                                                  JSONContext *context);
 
OBJECTIVELY_EXPORT bool JSONDeserializeCString(const JSONProperties *properties,
                                               const JSONProperty *property,
                                               const Object *value,
                                               ident field,
                                               JSONContext *context);
 
OBJECTIVELY_EXPORT bool JSONDeserializeInt32(const JSONProperties *properties,
                                             const JSONProperty *property,
                                             const Object *value,
                                             ident field,
                                             JSONContext *context);
 
OBJECTIVELY_EXPORT bool JSONDeserializeUint32(const JSONProperties *properties,
                                              const JSONProperty *property,
                                              const Object *value,
                                              ident field,
                                              JSONContext *context);
 
OBJECTIVELY_EXPORT bool JSONDeserializeInt64(const JSONProperties *properties,
                                             const JSONProperty *property,
                                             const Object *value,
                                             ident field,
                                             JSONContext *context);
 
OBJECTIVELY_EXPORT bool JSONDeserializeUint64(const JSONProperties *properties,
                                              const JSONProperty *property,
                                              const Object *value,
                                              ident field,
                                              JSONContext *context);
 
OBJECTIVELY_EXPORT bool JSONDeserializeFloat(const JSONProperties *properties,
                                             const JSONProperty *property,
                                             const Object *value,
                                             ident field,
                                             JSONContext *context);
 
OBJECTIVELY_EXPORT bool JSONDeserializeDouble(const JSONProperties *properties,
                                              const JSONProperty *property,
                                              const Object *value,
                                              ident field,
                                              JSONContext *context);
 
OBJECTIVELY_EXPORT bool JSONDeserializeBoole(const JSONProperties *properties,
                                             const JSONProperty *property,
                                             const Object *value,
                                             ident field,
                                             JSONContext *context);
 
OBJECTIVELY_EXPORT bool JSONDeserializeStruct(const JSONProperties *properties,
                                              const JSONProperty *property,
                                              const Object *value,
                                              ident field,
                                              JSONContext *context);
 
OBJECTIVELY_EXPORT bool JSONDeserializeArray(const JSONProperties *properties,
                                             const JSONProperty *property,
                                             const Object *value,
                                             ident field,
                                             JSONContext *context);
 
#pragma mark - JSONArrayProperties
 
#define JSONArrayProperties_NoCount ((ptrdiff_t) -1)
 
typedef struct {
 
  const JSONProperties *properties;
 
  size_t capacity;
 
  ptrdiff_t count;
 
} JSONArrayProperties;
 
#define MakeJSONArrayProperties(properties, capacity, count) \
  &(JSONArrayProperties){ .properties = (properties), .capacity = (capacity), .count = (count) }
 
# pragma mark - Object serializers
 
OBJECTIVELY_EXPORT ident JSONSerializeString(const JSONProperties *properties,
                                             const JSONProperty *property,
                                             ident value,
                                             ident data,
                                             JSONContext *context);
 
OBJECTIVELY_EXPORT bool JSONDeserializeString(const JSONProperties *properties,
                                              const JSONProperty *property,
                                              const Object *value,
                                              ident field,
                                              JSONContext *context);
 
OBJECTIVELY_EXPORT ident JSONSerializeURL(const JSONProperties *properties,
                                          const JSONProperty *property,
                                          ident value,
                                          ident data,
                                          JSONContext *context);
 
OBJECTIVELY_EXPORT bool JSONDeserializeURL(const JSONProperties *properties,
                                           const JSONProperty *property,
                                           const Object *value,
                                           ident field,
                                           JSONContext *context);
 
OBJECTIVELY_EXPORT ident JSONSerializeDate(const JSONProperties *properties,
                                           const JSONProperty *property,
                                           ident value,
                                           ident data,
                                           JSONContext *context);
 
OBJECTIVELY_EXPORT bool JSONDeserializeDate(const JSONProperties *properties,
                                            const JSONProperty *property,
                                            const Object *value,
                                            ident field,
                                            JSONContext *context);
 
OBJECTIVELY_EXPORT ident JSONSerializeObjectArray(const JSONProperties *properties,
                                                   const JSONProperty *property,
                                                   ident value,
                                                   ident data,
                                                   JSONContext *context);
 
OBJECTIVELY_EXPORT bool JSONDeserializeObjectArray(const JSONProperties *properties,
                                                    const JSONProperty *property,
                                                    const Object *value,
                                                    ident field,
                                                    JSONContext *context);
 
OBJECTIVELY_EXPORT ident JSONSerializeSet(const JSONProperties *properties,
                                                 const JSONProperty *property,
                                                 ident value,
                                                 ident data,
                                                 JSONContext *context);
 
OBJECTIVELY_EXPORT bool JSONDeserializeSet(const JSONProperties *properties,
                                                  const JSONProperty *property,
                                                  const Object *value,
                                                  ident field,
                                                  JSONContext *context);
 
OBJECTIVELY_EXPORT ident JSONSerializeDictionary(const JSONProperties *properties,
                                                        const JSONProperty *property,
                                                        ident value,
                                                        ident data,
                                                        JSONContext *context);
 
OBJECTIVELY_EXPORT bool JSONDeserializeDictionary(const JSONProperties *properties,
                                                         const JSONProperty *property,
                                                         const Object *value,
                                                         ident field,
                                                         JSONContext *context);