protected MemoryDataView(DataView.SafetyMode safety) { checkState(this instanceof DataContainer, "Cannot construct a root MemoryDataView without a container!"); this.path = of(); this.parent = this; this.container = (DataContainer) this; this.safety = checkNotNull(safety, "Safety mode"); }
/** * Method: then(DataQuery that) */ @Test public void testThen() { final DataQuery query = DataQuery.of("this", "testing"); final DataQuery other = DataQuery.of("this"); final DataQuery test = other.then(DataQuery.of("testing")); assertThat(query.equals(test), is(true)); assertThat(test.equals(query), is(true)); }
@Override public String toString() { final MoreObjects.ToStringHelper helper = MoreObjects.toStringHelper(this); if (!this.path.toString().isEmpty()) { helper.add("path", this.path); } helper.add("safety", this.safety.name()); return helper.add("map", this.map).toString(); } }
/** * Returns the parts of this query as individual queries. The returned list * is immutable. * * @return The constructed queries */ public List<DataQuery> getQueryParts() { if (this.queryParts == null) { ImmutableList.Builder<DataQuery> builder = ImmutableList.builder(); for (String part : getParts()) { builder.add(new DataQuery(part)); } this.queryParts = builder.build(); } return this.queryParts; }
/** * Returns a {@link DataQuery} where the last node is "popped" off. If this * query is already the top level query, then the {@link DataQuery#of()} is * returned. * * @return The next level query */ public DataQuery pop() { if (this.parts.size() <= 1) { return of(); } ImmutableList.Builder<String> builder = ImmutableList.builder(); for (int i = 0; i < this.parts.size() - 1; i++) { builder.add(this.parts.get(i)); } return new DataQuery(builder.build()); }
@Override public final boolean contains(DataQuery path) { checkNotNull(path, "path"); List<String> queryParts = path.getParts(); String key = queryParts.get(0); if (queryParts.size() == 1) { return this.map.containsKey(key); } Optional<DataView> subViewOptional = this.getUnsafeView(key); return subViewOptional.isPresent() && subViewOptional.get().contains(path.popFirst()); }
@Override public DataView remove(DataQuery path) { checkNotNull(path, "path"); List<String> parts = path.getParts(); if (parts.size() > 1) { String subKey = parts.get(0); DataQuery subQuery = of(subKey); Optional<DataView> subViewOptional = this.getUnsafeView(subQuery); if (!subViewOptional.isPresent()) { return this; } DataView subView = subViewOptional.get(); subView.remove(path.popFirst()); } else { this.map.remove(parts.get(0)); } return this; }
@Override public Set<DataQuery> getKeys(boolean deep) { ImmutableSet.Builder<DataQuery> builder = ImmutableSet.builder(); for (Map.Entry<String, Object> entry : this.map.entrySet()) { builder.add(of(entry.getKey())); } if (deep) { for (Map.Entry<String, Object> entry : this.map.entrySet()) { if (entry.getValue() instanceof DataView) { for (DataQuery query : ((DataView) entry.getValue()).getKeys(true)) { builder.add(of(entry.getKey()).then(query)); } } } } return builder.build(); }
/** * Method: equals(Object obj) */ @Test public void testEquals() { DataQuery query1 = DataQuery.of("test"); DataQuery query2 = DataQuery.of("test"); DataQuery nonEqual = DataQuery.of("nope"); assertThat(query1.equals(query1), is(true)); assertThat(query1.equals(query2), is(true)); assertThat(query1.equals(nonEqual), is(false)); }
/** * Method: pop() */ @Test public void testPop() { DataQuery prePopped = DataQuery.of("this", "test", "query"); DataQuery expected = DataQuery.of("this", "test"); assertThat(prePopped.pop().equals(expected), is(true)); DataQuery empty = DataQuery.of(); DataQuery emptyPopped = empty.pop(); assertThat(emptyPopped.equals(empty), is(true)); DataQuery single = DataQuery.of("single"); assertThat(single.pop().equals(empty), is(true)); }
sortFields.put(DataQueries.Created.toString(), session.getSortBy().getValue()); Document sorter = new Document("$sort", sortFields); groupFields.put(DataQueries.EventName.toString(), "$" + DataQueries.EventName); groupFields.put(DataQueries.Player.toString(), "$" + DataQueries.Player); groupFields.put(DataQueries.Cause.toString(), "$" + DataQueries.Cause); groupFields.put(DataQueries.Target.toString(), "$" + DataQueries.Target); groupFields.put(DataQueries.Entity.toString(), "$" + DataQueries.Entity.then(DataQueries.EntityType)); groupHolder.put(DataQueries.Count.toString(), new Document("$sum", 1)); data.set(DataQueries.Count, wrapper.get(DataQueries.Count.toString())); Result result = Result.from(wrapper.getString(DataQueries.EventName.toString()), !session.hasFlag(Flag.NO_GROUP)); if (document.containsKey(DataQueries.Player.toString())) { String uuid = document.getString(DataQueries.Player.toString()); data.set(DataQueries.Cause, uuid); data.set(DataQueries.Cause, document.getString(DataQueries.Cause.toString()));
/** * Method: getQueryParts() */ @Test public void testGetQueryParts() { final DataQuery full = DataQuery.of("this", "test", "query"); final DataQuery part1 = DataQuery.of("this"); final DataQuery part2 = DataQuery.of("test"); final DataQuery part3 = DataQuery.of("query"); final List<DataQuery> parts = full.getQueryParts(); final List<DataQuery> built = ImmutableList.of(part1, part2, part3); assertThat(parts.equals(built), is(true)); assertThat(built.equals(parts), is(true)); assertThat(built.containsAll(parts), is(true)); assertThat(parts.containsAll(built), is(true)); }
protected MemoryDataView(DataView parent, DataQuery path, DataView.SafetyMode safety) { checkArgument(path.getParts().size() >= 1, "Path must have at least one part"); this.parent = parent; this.container = parent.getContainer(); this.path = parent.getCurrentPath().then(path); this.safety = checkNotNull(safety, "Safety mode"); }
private void copyDataView(DataQuery path, DataView value) { Collection<DataQuery> valueKeys = value.getKeys(true); for (DataQuery oldKey : valueKeys) { set(path.then(oldKey), value.get(oldKey).get()); } }
@Override public String toString() { return asString('.'); }
/** * Constructs a query using the given parts. * * @param parts The parts * @return The newly constructed {@link DataQuery} */ public static DataQuery of(String... parts) { if (parts.length == 0) { return DataQuery.EMPTY; } return new DataQuery(parts); }
@Override public String getName() { List<String> parts = this.path.getParts(); return parts.isEmpty() ? "" : parts.get(parts.size() - 1); }