structs.h

Go to the documentation of this file.

#ifndef REFLECTIVE_RAPIDJSON_TESTS_STRUCTS_H
#define REFLECTIVE_RAPIDJSON_TESTS_STRUCTS_H
 
#include <c++utilities/chrono/datetime.h>
#include <c++utilities/chrono/timespan.h>
 
// including this header should *not* cause the code generator to generate code for the
// contained structs as well (to prevent violating the one definition rule)
#include "./morestructs.h"
 
#include "../../lib/binary/reflector-chronoutilities.h"
#include "../../lib/binary/serializable.h"
#include "../../lib/json/reflector-chronoutilities.h"
#include "../../lib/json/serializable.h"
 
#include <deque>
#include <list>
#include <string>
#include <vector>
 
using namespace std;
using namespace ReflectiveRapidJSON;

struct TestStruct : public JsonSerializable<TestStruct>, public BinarySerializable<TestStruct> {
    int someInt = 0;
    size_t someSize = 1;
    string someString = "foo";
    string yetAnotherString = "bar";
    static constexpr const char *staticMember = "static members are just ignored";
    static int anotherStaticMember;
 
private:
    string privateString = "not going to be serialized";
};
 
// forward declarations shouldn't cause the generator to emit the code multiple times
struct TestStruct;
struct TestStruct;
struct TestStruct;
 
class JsonGeneratorTests;

struct NestedTestStruct : public JsonSerializable<NestedTestStruct> {
    REFLECTIVE_RAPIDJSON_ENABLE_PRIVATE_MEMBERS(NestedTestStruct);
 
    friend class JsonGeneratorTests;
 
    list<vector<TestStruct>> nested;
    unique_ptr<TestStruct> ptr;
 
private:
    deque<double> deq;
};

struct AnotherTestStruct : public JsonSerializable<AnotherTestStruct>, public BinarySerializable<AnotherTestStruct> {
    vector<string> arrayOfStrings{ "a", "b", "cd" };
};

struct DerivedTestStruct : public TestStruct, public JsonSerializable<DerivedTestStruct>, public BinarySerializable<DerivedTestStruct> {
    bool someBool = true;
};

struct NonSerializable {
    int ignored = 25;
};

struct MultipleDerivedTestStruct : public TestStruct,
                                   public AnotherTestStruct,
                                   public NonSerializable,
                                   public JsonSerializable<MultipleDerivedTestStruct> {
    bool someBool = false;
};

struct StructWithCustomTypes : public JsonSerializable<StructWithCustomTypes> {
    CppUtilities::DateTime dt = CppUtilities::DateTime::fromDateAndTime(2017, 4, 2, 15, 31, 21, 165.125);
    CppUtilities::TimeSpan ts = CppUtilities::TimeSpan::fromHours(3.25) + CppUtilities::TimeSpan::fromSeconds(19.125);
};

struct NotJsonSerializable {
    std::string butSerializableAnyways = "useful to adapt 3rd party structs";
};

struct NestedNotJsonSerializable {
    NotJsonSerializable asMember;
    vector<NotJsonSerializable> asArrayElement;
    tuple<int, NotJsonSerializable> asTupleElement;
};
 
// make "NotJsonSerializable" and "NestedNotJsonSerializable" serializable
REFLECTIVE_RAPIDJSON_MAKE_JSON_SERIALIZABLE(NotJsonSerializable);
REFLECTIVE_RAPIDJSON_MAKE_JSON_SERIALIZABLE(NestedNotJsonSerializable);

struct OtherNotJsonSerializable {
    std::string codeIsGenerated = "for this despite missing REFLECTIVE_RAPIDJSON_ADAPT_JSON_SERIALIZABLE";
};

struct ReallyNotJsonSerializable {
    std::string notSerializable;
};
 
//REFLECTIVE_RAPIDJSON_ADAPT_JSON_SERIALIZABLE(NotJsonSerializable);
 
#endif // REFLECTIVE_RAPIDJSON_TESTS_STRUCTS_H