Nullable arrays

[vkx86]

Hello,

Tried variable-length arrays - works perfectly, but...
I have an input, that can contain null-able arrays, such as:

...,"CmdParams":null,...
...,"CmdParams":["param_1","param_2"],...

It would be nice that json_struct can handle these (just as zero size JS::ArrayVariableContent<>) - json_struct is just perfect for my needs (except that issue).

[jorgen]

Hi,
You can decorate your types with other types :D

So for a variable-length array you can define

JS::Nullable<JS::ArrayVariableContent<....>> foo;
Then it can be null or have som value.

If you want it to also be optional then it can be something like:
JS::Optional<JS::Nullable<JS::ArrayVariableContent<...>>> foo;
Foo will be nested with some data members which is unfortunate, ie to get the content of the array you will have to do:
foo.data.data.data. An early version of json_struct used inheritance instead of member variables for JS::Optional and JS::Nullable but there was problems with a compiler. I can not remember which compiler it was, but allas, its a pretty big source incompatible break now, so the api cant change.

[jorgen]

Optionally you can make your own type with a typehandler. This is pretty trivial. This is the whole implementation for ArrayVariableContent:

template <typename T, size_t COUNT>
struct ArrayVariableContent
{
  T data[COUNT];
  size_t size = 0;
};

template <typename T, size_t COUNT>
struct TypeHandler<ArrayVariableContent<T, COUNT>>
{
  static inline Error to(ArrayVariableContent<T, COUNT> &to_type, ParseContext &context)
  {
    if (context.token.value_type != Type::ArrayStart)
      return JS::Error::ExpectedArrayStart;

    context.nextToken();
    for (size_t i = 0; i < COUNT; i++)
    {
      if (context.error != JS::Error::NoError)
        return context.error;
      if (context.token.value_type == Type::ArrayEnd)
      {
        to_type.size = i;
        break;
      }
      context.error = TypeHandler<T>::to(to_type.data[i], context);
      if (context.error != JS::Error::NoError)
        return context.error;

      context.nextToken();
    }

    if (context.token.value_type != Type::ArrayEnd)
      return JS::Error::ExpectedArrayEnd;
    return context.error;
  }

  static inline void from(const ArrayVariableContent<T, COUNT> &from_type, Token &token, Serializer &serializer)
  {
    token.value_type = Type::ArrayStart;
    token.value = DataRef("[");
    serializer.write(token);

    token.name = DataRef("");
    for (size_t i = 0; i < from_type.size; i++)
      TypeHandler<T>::from(from_type.data[i], token, serializer);

    token.name = DataRef("");
    token.value_type = Type::ArrayEnd;
    token.value = DataRef("]");
    serializer.write(token);
  }
};

Then you can add a null check in the to handler.

Also when you write your own type its trivial to make it optional by adding
typedef bool IsOptionalType;
to the type declaration, like its done here:
https://github.com/jorgen/json_struct/blob/master/include/json_struct/json_struct.h#L2311
or you can add the IsOptionalType SFINAE like its done for std::optional
https://github.com/jorgen/json_struct/blob/master/include/json_struct/json_struct.h#L2527

Maybe we should have something like this for null as well, although I think the concept is different.

[vkx86]

My attempt that I'd did before posting here was:

if (context.token.value_type == Type::Null) {
return JS::Error::NoError;
 }

if (context.token.value_type != Type::ArrayStart)
 return JS::Error::ExpectedArrayStart;

That kinda fixed things, but context.parseTo still returned "JS::Error::NeedMoreData".

Awesome support, Jørgen!