How to use

contains

method

in

org.spongepowered.api.data.DataContainer

@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 testGetSerializable() throws Exception {
  initGame();
  List<String> myList = ImmutableList.of("foo", "bar", "baz");
  SimpleData temp = new SimpleData(1, 2.0, "foo", myList);
  DataContainer container = temp.toContainer();
  Optional<SimpleData> fromContainer = container.getSerializable(of(), SimpleData.class);
  assertTrue(fromContainer.isPresent());
  assertTrue(Objects.equal(fromContainer.get(), temp));
  assertTrue(container.contains(of("myStringList")));
  assertTrue(container.getStringList(of("myStringList")).get().equals(myList));
}

@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 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));
}

@Override
public Optional<FriendsData> from(DataContainer container) {
  if (container.contains(MyHomes.FRIENDS)) {
    List<UUID> friends = container.getObjectList(MyHomes.FRIENDS.getQuery(), UUID.class).get();
    return Optional.of(setValue(friends));
  }
  return Optional.empty();
}

@Override
public Optional<BlockBagData> from(DataContainer container) {
  if (container.contains(CraftBookKeys.BLOCK_BAG.getQuery())) {
    return Optional.of(new BlockBagData(container.getLong(CraftBookKeys.BLOCK_BAG.getQuery()).get()));
  }
  return Optional.empty();
}

@Override
public Optional<KeyLockData> from(DataContainer container) {
  if (container.contains(CraftBookKeys.KEY_LOCK.getQuery())) {
    return Optional.of(new KeyLockData(container.getSerializable(CraftBookKeys.KEY_LOCK.getQuery(), ItemStackSnapshot.class).get()));
  }
  return Optional.empty();
}

@Override
public Optional<NamespaceData> from(DataContainer container) {
  if (container.contains(CraftBookKeys.NAMESPACE.getQuery())) {
    return Optional.of(new NamespaceData(container.getString(CraftBookKeys.NAMESPACE.getQuery()).get()));
  }
  return Optional.empty();
}

@Override
public Optional<ICData> from(DataContainer container) {
  if (container.contains(CraftBookKeys.IC_DATA.getQuery())) {
    try {
      Class<SerializedICData> clazz = (Class<SerializedICData>) Class.forName(container.getString(DataQuery.of("ICDataClass")).orElse(SerializedICData.class.getName()));
      return Optional.of(new ICData(container.getSerializable(CraftBookKeys.IC_DATA.getQuery(), clazz).get()));
    } catch (ClassNotFoundException e) {
      e.printStackTrace();
    }
  }
  return Optional.empty();
}

@Override
public Optional<EmbeddedBlockBagData> from(DataContainer container) {
  if (container.contains(CraftBookKeys.EMBEDDED_BLOCK_BAG.getQuery())) {
    return Optional.of(new EmbeddedBlockBagData(container.getSerializable(CraftBookKeys.EMBEDDED_BLOCK_BAG.getQuery(),
        EmbeddedBlockBag.class).get()));
  }
  return Optional.empty();
}

@Override
public Optional<LastPowerData> from(DataContainer container) {
  if (container.contains(CraftBookKeys.LAST_POWER.getQuery())) {
    return Optional.of(new LastPowerData(container.getInt(CraftBookKeys.LAST_POWER.getQuery()).get()));
  }
  return Optional.empty();
}

@Override
public Optional<HomeData> from(DataContainer container) {
  if (!container.contains(MyHomes.DEFAULT_HOME, MyHomes.HOMES)) {
    return Optional.empty();
  }
  // Loads the structure defined in toContainer
  this.defaultHome = container.getSerializable(MyHomes.DEFAULT_HOME.getQuery(), Home.class).get();
  // Loads the map of homes
  this.homes = Maps.newHashMap();
  DataView homes = container.getView(MyHomes.HOMES.getQuery()).get();
  for (DataQuery homeQuery : homes.getKeys(false)) {
    homes.getSerializable(homeQuery, Home.class)
        .ifPresent(home -> this.homes.put(homeQuery.toString(), home));
  }
  return Optional.of(this);
}