com.squareup.moshi.JsonWriter Java Examples

/**
 * Recursively writes the respective roots forming a json object that resembles the {@code path}
 * wrapping the type of the {@code adapter}.
 */
private static <T> void toJson(JsonAdapter<T> adapter, JsonWriter writer, T value,
    String[] path, int index) throws IOException {
  if (value != null || writer.getSerializeNulls()) {
    if (index == path.length) {
      adapter.toJson(writer, value);
    } else {
      writer.beginObject();
      writer.name(path[index]);
      toJson(adapter, writer, value, path, ++index);
      writer.endObject();
    }
  } else {
    // If we don't propagate the null value the writer will throw.
    writer.nullValue();
  }
}
 

private String createJsonObject(final Map<String, Object> parameterMap) throws IOException {
  Buffer b = new Buffer();
  JsonWriter writer = JsonWriter.of(b);
  writer.beginObject();
  for (Entry<String, Object> pair : parameterMap.entrySet()) {
    String name = pair.getKey();
    Object value = pair.getValue();
    if (value instanceof Number) {
      Number number = (Number) value;
      writer.name(name).value(number);
    } else if (value instanceof String) {
      writer.name(name).value((String) value);
    } else if (value instanceof Boolean) {
      writer.name(name).value((Boolean) value);
    } else {
      writer.name(name).value(String.valueOf(value));
    }
  }
  writer.endObject();
  return b.readString(Charset.forName("utf-8"));
}
 

@Override public void toJson(JsonWriter writer, Object value) throws IOException {
  Class<?> type = value.getClass();
  int labelIndex = subtypes.indexOf(type);
  if (labelIndex == -1) {
    throw new IllegalArgumentException("Expected one of "
        + subtypes
        + " but found "
        + value
        + ", a "
        + value.getClass()
        + ". Register this subtype.");
  }
  JsonAdapter<Object> adapter = jsonAdapters.get(labelIndex);
  writer.beginObject();
  writer.name(labelKey).value(labels.get(labelIndex));
  int flattenToken = writer.beginFlatten();
  adapter.toJson(writer, value);
  writer.endFlatten(flattenToken);
  writer.endObject();
}
 

private void displayCurrentSessionData(PrintStream writer) {
    Activity activity = activityProvider.getCurrentActivity();
    if (activity instanceof SessionDetailsActivity) {
        try {
            // Use reflection to access private "session" field
            Field field = SessionDetailsActivity.class.getDeclaredField("session");
            field.setAccessible(true);
            Session session = (Session) field.get(activity);

            // Convert sessions to a human readable json
            Buffer buffer = new Buffer();
            JsonWriter jsonWriter = JsonWriter.of(buffer);
            jsonWriter.setIndent("  ");
            moshi.adapter(Session.class).toJson(jsonWriter, session);
            String sessionJson = buffer.readUtf8();

            writer.println(sessionJson);
        } catch (Exception e) {
            writer.println(e.getMessage());
        }
    } else {
        writer.println("SessionDetailsActivity not visible");
    }
}
 

@Override
public void toJson(JsonWriter writer, HasMany<T> value) throws IOException {
    writer.beginObject();
    writer.name("data");
    if (!value.hasData) {
        writeNull(writer, true);
    } else {
        writer.beginArray();
        for (ResourceIdentifier resource : value.linkedResources) {
            resourceIdentifierJsonAdapter.toJson(writer, resource);
        }
        writer.endArray();
    }
    writeNullable(writer, jsonBufferJsonAdapter, "meta", value.getMeta());
    writeNullable(writer, jsonBufferJsonAdapter, "links", value.getLinks());
    writer.endObject();
}
 

@Override public void toJson(JsonWriter writer, T value) throws IOException {
  if (isNotEmpty(value)) {
    delegate.toJson(writer, value);
  } else {
    // We'll need to consume this property otherwise we'll get an IllegalArgumentException.
    delegate.toJson(writer, null);
  }
}
 

@Override
public void toJson(JsonWriter writer, ResourceIdentifier value) throws IOException {
    writer.beginObject();
    writer.name("type").value(value.getType());
    writer.name("id").value(value.getId());
    writeNullable(writer, jsonBufferJsonAdapter, "meta", value.getMeta());
    writer.endObject();
}
 

@Override public void toJson(JsonWriter writer, @Nullable T value) throws IOException {
  if (value == null) {
    writer.nullValue();
  } else {
    delegate.toJson(writer, value);
  }
}
 

@Override
public void toJson(JsonWriter writer, @Nullable T value) throws IOException {
  if (value == null) {
    throw new JsonDataException("Unexpected null at " + writer.getPath());
  } else {
    delegate.toJson(writer, value);
  }
}
 

@Override public synchronized void toJson(JsonWriter writer, Date value) throws IOException {
  if (value == null) {
    writer.nullValue();
  } else {
    String string = Iso8601Utils.format(value);
    writer.value(string);
  }
}
 

@Override public void toJson(JsonWriter writer, T value) throws IOException {
  if (value == null) {
    throw new NullPointerException(
        "value was null! Wrap in .nullSafe() to write nullable values.");
  }
  writer.value(nameStrings[value.ordinal()]);
}
 

@Override public void toJson(JsonWriter writer, SortedSet<T> set) throws IOException {
  writer.beginArray();
  for (T element : set) {
    elementAdapter.toJson(writer, element);
  }
  writer.endArray();
}
 

@Test public void testModelListAdapter() throws IOException {
  Buffer buffer = new Buffer();
  JsonWriter jsonWriter = JsonWriter.of(buffer);
  JsonAdapter<List<Nation>> adapter =
      moshi.adapter(Types.newParameterizedType(List.class, Nation.class));
  Nation nation = Nation.create(1, 1, "foo", "bar", "baz");
  List<Nation> nations = Collections.singletonList(nation);
  adapter.toJson(jsonWriter, nations);
  String json = buffer.readUtf8();
  buffer = new Buffer().writeUtf8(json);
  JsonReader jsonReader = JsonReader.of(buffer);
  assertThat(adapter.fromJson(jsonReader)).isEqualTo(nations);
}
 

@Override public void toJson(JsonWriter writer, List<T> value) throws IOException {
  writer.beginObject();
  writer.name(type.getSimpleName().toLowerCase());
  writer.beginArray();
  JsonAdapter<T> adapter = moshi.adapter(type);
  for (T n : value) {
    adapter.toJson(writer, n);
  }
  writer.endArray();
  writer.endObject();
}
 

@Override public void toJson(JsonWriter writer, T value) throws IOException {
  if (serialize) {
    delegate.toJson(writer, value);
  } else {
    // We'll need to consume this property otherwise we'll get an IllegalArgumentException.
    delegate.toJson(writer, null);
  }
}
 

public static <T> void writeNullableValue(JsonWriter writer, JsonAdapter<T> adapter, T value, boolean enforced) throws IOException {
    if (value != null) {
        adapter.toJson(writer, value);
    } else {
        writeNull(writer, enforced);
    }
}
 

public static void writeNull(JsonWriter writer, boolean enforced) throws IOException {
    if (enforced) {
        boolean serializeFlag = writer.getSerializeNulls();
        try {
            writer.setSerializeNulls(true);
            writer.nullValue();
        } finally {
            writer.setSerializeNulls(serializeFlag);
        }
    } else {
        writer.nullValue();
    }
}
 

@Override
public void toJson(JsonWriter writer, HasOne<T> value) throws IOException {
    writer.beginObject();
    writeNullable(writer, resourceIdentifierJsonAdapter, "data", value.linkedResource, true);
    writeNullable(writer, jsonBufferJsonAdapter, "meta", value.getMeta());
    writeNullable(writer, jsonBufferJsonAdapter, "links", value.getLinks());
    writer.endObject();
}
 

@Test public void maintainsPreviousSerializationValue() throws Exception {
  JsonAdapter<Data1> adapter = moshi.adapter(Data1.class);
  Data1 data1 = new Data1();

  JsonWriter writer1 = JsonWriter.of(new Buffer());
  writer1.setSerializeNulls(true);
  adapter.toJson(writer1, data1);
  assertThat(writer1.getSerializeNulls()).isTrue();

  JsonWriter writer2 = JsonWriter.of(new Buffer());
  writer2.setSerializeNulls(false);
  adapter.toJson(writer2, data1);
  assertThat(writer2.getSerializeNulls()).isFalse();
}
 

@Override
public void toJson(JsonWriter writer, Error value) throws IOException {
    writer.beginObject();
    writer.name("id").value(value.getId());
    writer.name("status").value(value.getStatus());
    writer.name("code").value(value.getCode());
    writer.name("title").value(value.getTitle());
    writer.name("detail").value(value.getDetail());
    writeNullable(writer, jsonBufferJsonAdapter, "source", value.getSource());
    writeNullable(writer, jsonBufferJsonAdapter, "meta", value.getMeta());
    writeNullable(writer, jsonBufferJsonAdapter, "links", value.getLinks());
    writer.endObject();
}
 

@Override public void toJson(JsonWriter writer, T value) throws IOException {
  writer.value(nameStrings[value.ordinal()]);
}
 

public static void dump(JsonReader reader, JsonWriter writer) throws IOException {
    int nested = 0;
    boolean nullFlag = writer.getSerializeNulls();
    writer.setSerializeNulls(true);
    try {
        while (reader.peek() != JsonReader.Token.END_DOCUMENT) {
            switch (reader.peek()) {
                case BEGIN_ARRAY:
                    nested++;
                    reader.beginArray();
                    writer.beginArray();
                    break;
                case END_ARRAY:
                    reader.endArray();
                    writer.endArray();
                    if (0 == --nested) return;
                    break;
                case BEGIN_OBJECT:
                    nested++;
                    reader.beginObject();
                    writer.beginObject();
                    break;
                case END_OBJECT:
                    reader.endObject();
                    writer.endObject();
                    if (0 == --nested) return;
                    break;
                case NAME:
                    writer.name(reader.nextName());
                    break;
                case NUMBER:
                    Double doubleValue = reader.nextDouble();
                    if (Math.floor(doubleValue) == doubleValue) {
                        writer.value(doubleValue.longValue());
                    } else {
                        writer.value(doubleValue);
                    }
                    break;
                case BOOLEAN:
                    writer.value(reader.nextBoolean());
                    break;
                case STRING:
                    writer.value(reader.nextString());
                    break;
                case NULL:
                    reader.nextNull();
                    writer.nullValue();
                    break;
            }
        }
    } finally {
        writer.setSerializeNulls(nullFlag);
    }
}
 

public static <T> void writeNullable(JsonWriter writer, JsonAdapter<T> valueAdapter, String name, T value) throws IOException {
    writeNullable(writer, valueAdapter, name, value, false);
}
 

public static <T> void writeNullable(JsonWriter writer, JsonAdapter<T> valueAdapter, String name, T value, boolean enforced) throws IOException {
    writer.name(name);
    writeNullableValue(writer, valueAdapter, value, enforced);
}
 

@Override public void toJson(JsonWriter writer, ByteString value) throws IOException {
  String string = value.base64();
  writer.value(string);
}
 

@Override public void toJson(JsonWriter writer, Object value) throws IOException {
  delegate.toJson(writer, new Envelope<>(value));
}
 

@Override public void toJson(JsonWriter writer, T value) throws IOException {
  delegate.toJson(writer, value);
}
 

@ToJson void toJson(JsonWriter writer, Card value,
    @CardString JsonAdapter<Card> stringAdapter) throws IOException {
  stringAdapter.toJson(writer, value);
}
 

@Override public void toJson(JsonWriter writer, T value) throws IOException {
  writer.value(nameStrings[value.ordinal()]);
}
 

@ToJson
public void write(JsonWriter jsonWriter, AnInterface anInterface) throws IOException {
    jsonWriter.beginObject();
    jsonWriter.name("name").value(anInterface.getName());
    jsonWriter.endObject();
}