Tabnine Logo
DataContainer
Code IndexAdd Tabnine to your IDE (free)

How to use
DataContainer
in
org.spongepowered.api.data

Best Java code snippets using org.spongepowered.api.data.DataContainer (Showing top 20 results out of 315)

origin: SpongePowered/SpongeAPI

@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);
}
origin: SpongePowered/SpongeAPI

@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());
}
origin: SpongePowered/SpongeAPI

@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));
}
origin: SpongePowered/SpongeAPI

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

@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"));
}
origin: SpongePowered/SpongeAPI

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

@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);
}
origin: SpongePowered/SpongeAPI

@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));
}
origin: SpongePowered/SpongeAPI

@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));
}
origin: SpongePowered/SpongeAPI

@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());
}
origin: SpongePowered/SpongeAPI

@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));
}
origin: SpongePowered/SpongeAPI

@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"));
}
origin: SpongePowered/SpongeAPI

@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));
}
origin: SpongePowered/SpongeAPI

@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());
}
origin: SpongePowered/SpongeAPI

@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();
}
origin: prism/Prism

  /**
   * 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;
  }
}
origin: prism/Prism

/**
 * 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);
}
origin: TVPT/VoxelSniper

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());
origin: SpongePowered/SpongeAPI

@Test
public void testCreateDataView() {
  DataContainer.createNew();
}
origin: prism/Prism

  /**
   * 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;
  }
}
org.spongepowered.api.dataDataContainer

Javadoc

Represents a data structure that contains data. A DataContainer is an object that can be considered a root DataView.

Most used methods

  • set
  • createNew
    Creates a new DataContainer with the provided org.spongepowered.api.data.DataView.SafetyMode.
  • get
  • contains
  • getInt
  • getSerializable
  • getString
  • getView
  • createView
  • getLong
  • copy
  • getBoolean
  • copy,
  • getBoolean,
  • getBooleanList,
  • getByteList,
  • getCharacterList,
  • getDouble,
  • getDoubleList,
  • getFloatList,
  • getIntegerList,
  • getList

Popular in Java

  • Reactive rest calls using spring rest template
  • runOnUiThread (Activity)
  • getApplicationContext (Context)
  • scheduleAtFixedRate (ScheduledExecutorService)
  • Window (java.awt)
    A Window object is a top-level window with no borders and no menubar. The default layout for a windo
  • BigInteger (java.math)
    An immutable arbitrary-precision signed integer.FAST CRYPTOGRAPHY This implementation is efficient f
  • Socket (java.net)
    Provides a client-side TCP socket.
  • TreeSet (java.util)
    TreeSet is an implementation of SortedSet. All optional operations (adding and removing) are support
  • ReentrantLock (java.util.concurrent.locks)
    A reentrant mutual exclusion Lock with the same basic behavior and semantics as the implicit monitor
  • JFileChooser (javax.swing)
  • Top Sublime Text plugins
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now