How to use

DataContainer

in

org.spongepowered.api.data

@Override
public DataContainer toContainer() {
  return DataContainer.createNew()
      .set(Queries.CONTENT_VERSION, getContentVersion())
      .set(Queries.VARIABLE_CHANCE, this.chance)
      .set(Queries.VARIABLE_BASE, this.base)
      .set(Queries.VARIABLE_VARIANCE, this.inner);
}

@Test
public void testAbsents() {
  DataContainer container = DataContainer.createNew();
  DataQuery testQuery = of("foo", "bar", "baz");
  assertTrue(!container.get(testQuery).isPresent());
  assertTrue(!container.getBoolean(testQuery).isPresent());
  assertTrue(!container.getBooleanList(testQuery).isPresent());
  assertTrue(!container.getByteList(testQuery).isPresent());
  assertTrue(!container.getCharacterList(testQuery).isPresent());
  assertTrue(!container.getDouble(testQuery).isPresent());
  assertTrue(!container.getDoubleList(testQuery).isPresent());
  assertTrue(!container.getFloatList(testQuery).isPresent());
  assertTrue(!container.getInt(testQuery).isPresent());
  assertTrue(!container.getIntegerList(testQuery).isPresent());
  assertTrue(!container.getList(testQuery).isPresent());
  assertTrue(!container.getLong(testQuery).isPresent());
  assertTrue(!container.getLongList(testQuery).isPresent());
  assertTrue(!container.getMapList(testQuery).isPresent());
  assertTrue(!container.getShortList(testQuery).isPresent());
  assertTrue(!container.getString(testQuery).isPresent());
  assertTrue(!container.getStringList(testQuery).isPresent());
  assertTrue(!container.getView(testQuery).isPresent());
}

@Test
public void testLists() {
  DataContainer container = DataContainer.createNew();
  DataQuery query = of("foo");
  List<DataView> list = Lists.newArrayList();
  for (int i = 0; i < 1; i++) {
    DataContainer internal = DataContainer.createNew();
    internal.set(of("foo", "bar"), "foo.bar" + i);
    int[] ints = new int[] {0, 1, 2, 3, i};
    internal.set(of("ints"), Arrays.asList(ints));
    list.add(internal);
  }
  container.set(query, list);
  assertTrue(container.contains(query));
  List<DataView> queriedList = container.getViewList(query).get();
  assertTrue(queriedList.equals(list));
}

@Test
public void testCreateView() {
  DataContainer container = DataContainer.createNew();
  DataQuery tempQuery = of("foo", "bar", "baz");
  container.createView(tempQuery);
  assertTrue(container.getView(tempQuery).isPresent());
}

@Test
public void testEmptyQuery() {
  DataContainer container = DataContainer.createNew();
  DataQuery query = of("");
  container.set(query, "foo");
  assertTrue(container.get(query).isPresent());
  assertTrue(container.get(query).get().equals("foo"));
}

@Override
protected DataContainer fillContainer(DataContainer dataContainer) {
  return dataContainer.set(this.usedKey.getQuery(), this.value.name());
}

@Test
public void testNumbers() {
  DataContainer container = DataContainer.createNew();
  DataQuery testQuery = of("foo", "bar");
  container.set(testQuery, 1.0D);
  Optional<Integer> integerOptional = container.getInt(testQuery);
  assertTrue(integerOptional.isPresent());
  assertTrue(integerOptional.get() == 1);
  Optional<Long> longOptional = container.getLong(testQuery);
  assertTrue(longOptional.isPresent());
  assertTrue(longOptional.get() == 1L);
  Optional<Double> doubleOptional = container.getDouble(testQuery);
  assertTrue(doubleOptional.isPresent());
  assertTrue(doubleOptional.get() == 1.0D);
}

@Test
public void testNumberedLists() {
  DataContainer container = DataContainer.createNew();
  DataQuery testQuery = of("foo", "bar", "baz");
  List<Integer> intList = ImmutableList.of(1, 2, 3, 4);
  container.set(testQuery, intList);
  assertTrue(container.getIntegerList(testQuery).isPresent());
  assertTrue(container.getIntegerList(testQuery).get().equals(intList));
  List<Double> doubleList = ImmutableList.of(1.0D, 2.0D, 3.0D, 4.0D);
  container.set(testQuery, doubleList);
  assertTrue(container.getDoubleList(testQuery).isPresent());
  assertTrue(container.getDoubleList(testQuery).get().equals(doubleList));
  List<Short> shortList = ImmutableList.of((short) 1, (short) 2, (short) 3, (short) 4);
  container.set(testQuery, shortList);
  assertTrue(container.getShortList(testQuery).isPresent());
  assertTrue(container.getShortList(testQuery).get().equals(shortList));
  List<Byte> byteList = ImmutableList.of((byte) 1, (byte) 2, (byte) 3, (byte) 4);
  container.set(testQuery, byteList);
  assertTrue(container.getByteList(testQuery).isPresent());
  assertTrue(container.getByteList(testQuery).get().equals(byteList));
}

@Test
public void testCopy() {
  final DataContainer container = DataContainer.createNew();
  container.set(of("Foo"), "foo");
  final DataContainer newContainer = container.copy();
  assertTrue(container.equals(newContainer));
  container.set(of("Foo", "bar"), "foo.bar");
  final DataView internal = container.getView(of("Foo")).get().copy();
  final DataContainer internalCopy = DataContainer.createNew().set(of("bar"), "foo.bar");
  assertTrue(internal.equals(internalCopy));
}

@Test
public void testSetData() {
  DataContainer container = DataContainer.createNew();
  DataQuery testQuery = of('.', "foo.bar");
  container.set(testQuery, 1);
  Optional<Integer> optional = container.getInt(testQuery);
  assertTrue(optional.isPresent());
}

@Test
public void testContainsEmpty() {
  DataContainer container = DataContainer.createNew();
  DataQuery query = of("");
  assertTrue(!container.contains(query));
  container.set(query, "foo");
  assertTrue(container.contains(query));
  query = of('.', "foo.bar");
  assertTrue(!container.contains(query));
  container.set(query, "baz");
  assertTrue(container.contains(query));
}

@Test
public void testString() {
  DataContainer container = DataContainer.createNew();
  DataQuery testQuery = of("foo", "bar");
  container.set(testQuery, "foo");
  Optional<String> stringOptional = container.getString(testQuery);
  assertTrue(stringOptional.isPresent());
  assertTrue(stringOptional.get().equals("foo"));
}

@Test
public void testGetSerializableList() throws Exception {
  initGame();
  List<SimpleData> list = Lists.newArrayList();
  for (int i = 0; i < 1000; i++) {
    String number = Integer.toString(i);
    list.add(new SimpleData(i, 0.1 * i, "i", Lists.asList(number, new String[] {" foo", "bar"})));
  }
  DataContainer container = DataContainer.createNew();
  container.set(of("foo", "bar"), list);
  assertTrue(container.contains(of("foo", "bar")));
  Optional<List<SimpleData>> fromContainer = container.getSerializableList(of("foo", "bar"), SimpleData.class);
  assertTrue(fromContainer.isPresent());
  List<SimpleData> memoryList = fromContainer.get();
  assertTrue(Objects.equal(memoryList, list));
}

@Test
public void testBoolean() {
  DataContainer container = DataContainer.createNew();
  DataQuery testQuery = of("foo", "bar");
  container.set(testQuery, false);
  Optional<Boolean> booleanOptional = container.getBoolean(testQuery);
  assertTrue(booleanOptional.isPresent());
  assertTrue(!booleanOptional.get());
}

@Test
public void testDeepSerialization() {
  List<List<?>> values = Lists.newArrayList();
  List<List<?>> sub = Lists.newArrayList();
  values.add(sub);
  SimpleData data1 = new SimpleData(1, 2.0, "3", Arrays.asList("foo", "bar", "baz"));
  SimpleData data2 = new SimpleData(2, 3.0, "4", Arrays.asList("bar", "baz", "foo"));
  SimpleData data3 = new SimpleData(3, 4.0, "5", Arrays.asList("baz", "foo", "bar"));
  sub.add(ImmutableList.of(data1));
  sub.add(ImmutableList.of(data2));
  DataContainer main = DataContainer.createNew();
  main.set(DataQuery.of("ROOT"), data3);
  main.set(DataQuery.of("SINGLE"), ImmutableList.of(data2));
  main.set(DataQuery.of("SUB"), values);
  main.getMap(of()).get();
}

  /**
   * Helper method to translate Player UUIDs to names.
   *
   * @param results List of results
   * @param uuidsPendingLookup Lists of UUIDs pending lookup
   * @return CompletableFuture
   */
  public static CompletableFuture<List<Result>> translateUuidsToNames(List<Result> results, List<UUID> uuidsPendingLookup) {
    CompletableFuture<List<Result>> future = new CompletableFuture<>();

    CompletableFuture<Collection<GameProfile>> futures = Sponge.getServer().getGameProfileManager().getAllById(uuidsPendingLookup, true);
    futures.thenAccept((profiles) -> {
      for (GameProfile profile : profiles) {
        for (Result r : results) {
          Optional<Object> cause = r.data.get(DataQueries.Cause);
          if (cause.isPresent() && cause.get().equals(profile.getUniqueId().toString())) {
            r.data.set(DataQueries.Cause, profile.getName().orElse("unknown"));
          }
        }
      }

      future.complete(results);
    });

    return future;
  }
}

/**
 * Helper method for formatting entity container data.
 * @param entity
 */
private void writeEntity(Entity entity) {
  checkNotNull(entity);
  DataContainer entityData = entity.toContainer();
  Optional<DataView> position = entityData.getView(DataQueries.Position);
  if (position.isPresent()) {
    position.get().set(DataQueries.WorldUuid, entityData.get(DataQueries.WorldUuid).get());
    data.set(DataQueries.Location, position.get());
    entityData.remove(DataQueries.Position);
    entityData.remove(DataQueries.WorldUuid);
  }
  Optional<DataView> optionalUnsafeData = entityData.getView(DataQueries.UnsafeData);
  if (optionalUnsafeData.isPresent()) {
    DataView unsafeData = optionalUnsafeData.get();
    unsafeData.remove(DataQueries.Rotation);
    unsafeData.remove(DataQueries.Pos);
    entityData.set(DataQueries.UnsafeData, unsafeData);
  }
  data.set(DataQueries.Target, entity.getType().getId().replace("_", " "));
  data.set(DataQueries.Entity, entityData);
}

DataContainer schematic = DataContainer.createNew(SafetyMode.NO_DATA_CLONED);
schematic.set(DataQuery.of("Width"), w);
schematic.set(DataQuery.of("Height"), h);
schematic.set(DataQuery.of("Length"), l);
schematic.set(DataQuery.of("Version"), 1);
DataView metadata = schematic.createView(DataQuery.of("Metadata"));
metadata.set(DataQuery.of("Name"), name);
schematic.set(DataQuery.of("Offset"), offset);
schematic.set(DataQuery.of("BlockData"), buffer.toByteArray());

@Test
public void testCreateDataView() {
  DataContainer.createNew();
}

  /**
   * Removes unnecessary/duplicate data from a BlockSnapshot's DataContainer.
   *
   * @param blockSnapshot Block Snapshot.
   * @return DataContainer Formatted Data Container.
   */
  private DataContainer formatBlockDataContainer(BlockSnapshot blockSnapshot) {
    DataContainer block = blockSnapshot.toContainer();
    block.remove(DataQueries.WorldUuid);
    block.remove(DataQueries.Position);
    Optional<Object> optionalUnsafeData = block.get(DataQueries.UnsafeData);
    if (optionalUnsafeData.isPresent()) {
      DataView unsafeData = (DataView) optionalUnsafeData.get();
      unsafeData.remove(DataQueries.X);
      unsafeData.remove(DataQueries.Y);
      unsafeData.remove(DataQueries.Z);
      block.set(DataQueries.UnsafeData, unsafeData);
    }
    return block;
  }
}