From 64a2ced471cbf4808378cc9930ad1a293d141431 Mon Sep 17 00:00:00 2001 From: javierlores Date: Wed, 3 Apr 2019 07:18:47 -0600 Subject: [PATCH 01/13] created Order Builder --- .../concourse/order/AscendingSymbol.java | 27 ++++ .../concourse/order/BaseOrderSymbol.java | 38 +++++ .../concourse/order/BuildableState.java | 44 ++++++ .../com/cinchapi/concourse/order/ByState.java | 134 +++++++++++++++++ .../concourse/order/DescendingSymbol.java | 27 ++++ .../cinchapi/concourse/order/KeySymbol.java | 50 +++++++ .../com/cinchapi/concourse/order/Order.java | 115 +++++++++++++++ .../cinchapi/concourse/order/OrderSymbol.java | 24 ++++ .../concourse/order/SortOrderState.java | 42 ++++++ .../cinchapi/concourse/order/StartState.java | 43 ++++++ .../com/cinchapi/concourse/order/State.java | 46 ++++++ .../cinchapi/concourse/order/ThenState.java | 135 ++++++++++++++++++ .../cinchapi/concourse/order/OrderTest.java | 77 ++++++++++ 13 files changed, 802 insertions(+) create mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/order/AscendingSymbol.java create mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BaseOrderSymbol.java create mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BuildableState.java create mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ByState.java create mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/order/DescendingSymbol.java create mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/order/KeySymbol.java create mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java create mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/order/OrderSymbol.java create mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderState.java create mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartState.java create mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/order/State.java create mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenState.java create mode 100644 concourse-driver-java/src/test/java/com/cinchapi/concourse/order/OrderTest.java diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/AscendingSymbol.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/AscendingSymbol.java new file mode 100644 index 0000000000..8a1c21e790 --- /dev/null +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/AscendingSymbol.java @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2013-2019 Cinchapi Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.cinchapi.concourse.order; + +/** + * A {@link OrderSymbol} that represents an ascending order + */ +public class AscendingSymbol extends BaseOrderSymbol { + + @Override + public String toString() { + return "ascending"; + } +} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BaseOrderSymbol.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BaseOrderSymbol.java new file mode 100644 index 0000000000..b4e5bbb6c2 --- /dev/null +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BaseOrderSymbol.java @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2013-2019 Cinchapi Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.cinchapi.concourse.order; + +/** + * An abstract implementation of the {@link OrderSymbol} interface that provides + * {@link #hashCode()} and {@link #equals(Object)}. + */ +public class BaseOrderSymbol implements OrderSymbol { + + @Override + public int hashCode() { + return toString().hashCode(); + } + + @Override + public boolean equals(Object obj) { + if(obj.getClass() == getClass()) { + return toString().equals(obj.toString()); + } + else { + return false; + } + } +} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BuildableState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BuildableState.java new file mode 100644 index 0000000000..df6c75a4ea --- /dev/null +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BuildableState.java @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2013-2019 Cinchapi Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.cinchapi.concourse.order; + +/** + * The base class for a Sort Order state that can be transformed into a complete + * and well-formed {@link Order}. + * + */ +public abstract class BuildableState extends State { + + /** + * Construct a new instance. + * + * @param Order + */ + protected BuildableState(Order Order) { + super(Order); + } + + /** + * Build and return the {@link Order}. + * + * @return the built Order + */ + public final Order build() { + order.close(); + return order; + } + +} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ByState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ByState.java new file mode 100644 index 0000000000..5b16bb5ec7 --- /dev/null +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ByState.java @@ -0,0 +1,134 @@ +/* + * Copyright (c) 2013-2019 Cinchapi Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.cinchapi.concourse.order; + +/** + * The {@link State} that expects the next token to be a sort order or a new key + * to sort by. + */ +public class ByState extends BuildableState { + + /** + * Construct a new instance. + * + * @param Order + */ + protected ByState(Order Order) { + super(Order); + } + + /** + * Add an ascending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState ascending() { + order.add(new AscendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add an ascending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState increasing() { + order.add(new AscendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add an ascending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState smallestFirst() { + order.add(new AscendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add an ascending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState largestLast() { + order.add(new AscendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add a descending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState descending() { + order.add(new DescendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add a descending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState decreasing() { + order.add(new DescendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add a descending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState reversed() { + order.add(new DescendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add a descending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState largestFirst() { + order.add(new DescendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add a descending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState smallestLast() { + order.add(new DescendingSymbol()); + return new SortOrderState(order); + } + + /** + * Adds a new {@link KeySymbol} to sort by to the {@link Order} that is + * building. Adds an implicit Ascending sort order to the prior key + * + * @return the builder + */ + public ThenState then(String key) { + order.add(new AscendingSymbol()); + order.add(new KeySymbol(key)); + return new ThenState(order); + } +} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/DescendingSymbol.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/DescendingSymbol.java new file mode 100644 index 0000000000..05eca591d9 --- /dev/null +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/DescendingSymbol.java @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2013-2019 Cinchapi Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.cinchapi.concourse.order; + +/** + * A {@link OrderSymbol} that represents an descending order + */ +public class DescendingSymbol extends BaseOrderSymbol { + + @Override + public String toString() { + return "descending"; + } +} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/KeySymbol.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/KeySymbol.java new file mode 100644 index 0000000000..3dbfc25df3 --- /dev/null +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/KeySymbol.java @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2013-2019 Cinchapi Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.cinchapi.concourse.order; + +/** + * A {@link OrderSymbol} that contains a key to sort by. + */ +public final class KeySymbol extends BaseOrderSymbol { + + /** + * The content of the {@link OrderSymbol}. + */ + private final String key; + + /** + * Construct a new instance. + * + * @param key + */ + public KeySymbol(String key) { + this.key = key; + } + + /** + * Return the key associated with this {@link OrderSymbol}. + * + * @return the key + */ + public String key() { + return key; + } + + @Override + public String toString() { + return key(); + } +} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java new file mode 100644 index 0000000000..d40109710c --- /dev/null +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java @@ -0,0 +1,115 @@ +/* + * Copyright (c) 2013-2019 Cinchapi Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.cinchapi.concourse.order; + +import java.util.Collections; +import java.util.List; +import java.util.Objects; + +import com.cinchapi.ccl.grammar.ParenthesisSymbol; +import com.cinchapi.ccl.grammar.Symbol; +import com.google.common.base.Preconditions; +import com.google.common.collect.Lists; + +/** + * A {@link Order} is an object that is used to encapsulate the semantics of + * a sort order. Any given time, objects of this class can exist in one + * of two modes: {@code building} or {@code built}. When a Order is + * {@code built}, it is guaranteed to represent a fully and well formed sort order + * that can be processed. On the other hand, when a Order is {@code building} + * it is in an incomplete state. + *

+ * This class is the public interface to Order construction. It is meant to + * be used in a chained manner, where the caller initially calls + * {@link Order#where()} and continues to construct the Order using the + * options available from each subsequently returned state. + *

+ * + */ +public class Order implements OrderSymbol { + + /** + * Start building a new {@link Order}. + * + * @return the Order builder + */ + public static StartState where() { + return new StartState(new Order()); + } + + /** + * A flag that indicates whether this {@link Order} has been built. + */ + private boolean built = false; + + /** + * The collection of {@link OrderSymbol}s that make up this {@link Order}. + */ + private List orderSymbols; + + /** + * Construct a new instance. + */ + protected Order() { + this.orderSymbols = Lists.newArrayList(); + } + + @Override + public boolean equals(Object obj) { + if(obj instanceof Order) { + return Objects.equals(orderSymbols, ((Order) obj).orderSymbols); + } + else { + return false; + } + } + + @Override + public int hashCode() { + return Objects.hash(orderSymbols); + } + + /** + * Add a {@link OrderSymbol} to this {@link Order}. + * + * @param orderSymbol + */ + protected void add(OrderSymbol orderSymbol) { + Preconditions.checkState(!built, + "Cannot add a order symbol to a built Order"); + orderSymbols.add(orderSymbol); + } + + /** + * Mark this {@link Order} as {@code built}. + */ + protected void close() { + built = !built ? true : built; + if (orderSymbols.get(orderSymbols.size()-1) instanceof KeySymbol) { + orderSymbols.add(new AscendingSymbol()); + } + } + + /** + * Return the order list of {@link OrderSymbol} that make up this {@link Order}. + * + * @return orderSymbols + */ + protected List getOrderSymbols() { + return Collections.unmodifiableList(orderSymbols); + } + +} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/OrderSymbol.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/OrderSymbol.java new file mode 100644 index 0000000000..64cb7208ef --- /dev/null +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/OrderSymbol.java @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2013-2019 Cinchapi Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.cinchapi.concourse.order; + +import javax.annotation.concurrent.Immutable; + +/** + * A {@link OrderSymbol} is a terminal or non-terminal component in a an {@link Order} + */ +@Immutable +public interface OrderSymbol {/* marker */} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderState.java new file mode 100644 index 0000000000..623f8db858 --- /dev/null +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderState.java @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2013-2019 Cinchapi Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.cinchapi.concourse.order; + +/** + * The {@link State} that expects the current token to be a sort key. + */ +public class SortOrderState extends BuildableState { + + /** + * Construct a new instance. + * + * @param Order + */ + protected SortOrderState(Order Order) { + super(Order); + } + + /** + * Add a {@code key} to the Order that is building. + * + * @param key + * @return the builder + */ + public ThenState then(String key) { + order.add(new KeySymbol(key)); + return new ThenState(order); + } +} \ No newline at end of file diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartState.java new file mode 100644 index 0000000000..811f7988a0 --- /dev/null +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartState.java @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2013-2019 Cinchapi Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.cinchapi.concourse.order; + +/** + * The {@link StartState} marks the logical beginning of a new {@link Order}. + */ +public class StartState extends State { + + /** + * Construct a new instance. + * + * @param Order + */ + public StartState(Order Order) { + super(Order); + } + + /** + * Add a {@code key} to the Order that is building. + * + * @param key + * @return the builder + */ + public ByState by(String key) { + order.add(new KeySymbol(key)); + return new ByState(order); + } + +} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/State.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/State.java new file mode 100644 index 0000000000..72cbe8229b --- /dev/null +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/State.java @@ -0,0 +1,46 @@ + +/* + * Copyright (c) 2013-2019 Cinchapi Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.cinchapi.concourse.order; +/** + * This is the base class and marker for any valid state in the {@link Order} + * builder. Each {@link State} is passed the current {@link Order} and holds + * a reference. For any method called from the state, a {@link OrderSymbol} is added + * to the {@code Order} or the {@code Order} is returned. + *

+ * For the purposes of a builder, a {@link State} typically describes what was + * most recently consumed. + *

+ * + * @author Javier Lores + */ +public abstract class State { + + /** + * A reference to the {@link Order} that is being built. + */ + protected final Order order; + + /** + * Construct a new instance. + * + * @param order + */ + protected State(Order order) { + this.order = order; + } + +} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenState.java new file mode 100644 index 0000000000..06ab13c9c5 --- /dev/null +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenState.java @@ -0,0 +1,135 @@ +/* + * Copyright (c) 2013-2019 Cinchapi Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.cinchapi.concourse.order; + +/** + * The {@link State} that expects the current token to be a sort order or a + * sort key. + */ +public class ThenState extends BuildableState { + + /** + * Construct a new instance. + * + * @param Order + */ + protected ThenState(Order Order) { + super(Order); + } + + /** + * Add an ascending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState ascending() { + order.add(new AscendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add an ascending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState increasing() { + order.add(new AscendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add an ascending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState smallestFirst() { + order.add(new AscendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add an ascending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState largestLast() { + order.add(new AscendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add a descending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState descending() { + order.add(new AscendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add a descending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState decreasing() { + order.add(new DescendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add a descending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState reversed() { + order.add(new DescendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add a descending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState largestFirst() { + order.add(new DescendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add a descending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState smallestLast() { + order.add(new DescendingSymbol()); + return new SortOrderState(order); + } + + /** + * Adds a new {@link KeySymbol} to sort by to the {@link Order} that is + * building. Adds an implicit Ascending sort order to the prior key + * + * @return the builder + */ + public ThenState then(String key) { + order.add(new AscendingSymbol()); + order.add(new KeySymbol(key)); + return new ThenState(order); + } + +} \ No newline at end of file diff --git a/concourse-driver-java/src/test/java/com/cinchapi/concourse/order/OrderTest.java b/concourse-driver-java/src/test/java/com/cinchapi/concourse/order/OrderTest.java new file mode 100644 index 0000000000..c108ca0064 --- /dev/null +++ b/concourse-driver-java/src/test/java/com/cinchapi/concourse/order/OrderTest.java @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2013-2019 Cinchapi Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.cinchapi.concourse.order; + +import com.google.common.collect.Lists; +import org.junit.Assert; +import org.junit.Test; + +import java.util.List; + +/** + * Unit tests for the {@link com.cinchapi.concourse.order.Order} building + * functionality. + */ +public class OrderTest { + + @Test + public void testDefaultSortOrder() { + List expected = Lists.newArrayList(new KeySymbol("foo"), + new AscendingSymbol()); + Order order = Order.where().by("foo").build(); + Assert.assertEquals(expected, order.getOrderSymbols()); + } + + @Test + public void testAscendingSortOrder() { + List expected = Lists.newArrayList(new KeySymbol("foo"), + new AscendingSymbol()); + Order order = Order.where().by("foo").ascending().build(); + Assert.assertEquals(expected, order.getOrderSymbols()); + } + + @Test + public void testDescendingSortOrder() { + List expected = Lists.newArrayList(new KeySymbol("foo"), + new DescendingSymbol()); + Order order = Order.where().by("foo").descending().build(); + Assert.assertEquals(expected, order.getOrderSymbols()); + } + + @Test + public void testMultipleSortKeysSortOrder() { + List expected = Lists.newArrayList(new KeySymbol("foo"), + new AscendingSymbol(), new KeySymbol("bar"), new AscendingSymbol()); + Order order = Order.where().by("foo").then("bar").ascending().build(); + Assert.assertEquals(expected, order.getOrderSymbols()); + } + + @Test + public void testMultipleSortKeysWithImplicitSortOrders() { + List expected = Lists.newArrayList(new KeySymbol("foo"), + new AscendingSymbol(), new KeySymbol("bar"), new AscendingSymbol(), + new KeySymbol("zoo"), new AscendingSymbol()); + Order order = Order.where().by("foo").then("bar").then("zoo").build(); + Assert.assertEquals(expected, order.getOrderSymbols()); + } + + @Test(expected = IllegalStateException.class) + public void testCannotAddSymbolToBuiltOrder() { + Order order = Order.where().by("foo").build(); + order.add(new KeySymbol("baz")); + } + +} From 372abd9de681e7fadd9f1caecc3e957f551dbf44 Mon Sep 17 00:00:00 2001 From: javierlores Date: Wed, 3 Apr 2019 12:24:08 -0600 Subject: [PATCH 02/13] Removed where chained call --- .../com/cinchapi/concourse/order/ByState.java | 134 ------------------ .../com/cinchapi/concourse/order/Order.java | 8 +- .../cinchapi/concourse/order/StartState.java | 107 ++++++++++++-- .../cinchapi/concourse/order/OrderTest.java | 12 +- 4 files changed, 110 insertions(+), 151 deletions(-) delete mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ByState.java diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ByState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ByState.java deleted file mode 100644 index 5b16bb5ec7..0000000000 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ByState.java +++ /dev/null @@ -1,134 +0,0 @@ -/* - * Copyright (c) 2013-2019 Cinchapi Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.cinchapi.concourse.order; - -/** - * The {@link State} that expects the next token to be a sort order or a new key - * to sort by. - */ -public class ByState extends BuildableState { - - /** - * Construct a new instance. - * - * @param Order - */ - protected ByState(Order Order) { - super(Order); - } - - /** - * Add an ascending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState ascending() { - order.add(new AscendingSymbol()); - return new SortOrderState(order); - } - - /** - * Add an ascending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState increasing() { - order.add(new AscendingSymbol()); - return new SortOrderState(order); - } - - /** - * Add an ascending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState smallestFirst() { - order.add(new AscendingSymbol()); - return new SortOrderState(order); - } - - /** - * Add an ascending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState largestLast() { - order.add(new AscendingSymbol()); - return new SortOrderState(order); - } - - /** - * Add a descending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState descending() { - order.add(new DescendingSymbol()); - return new SortOrderState(order); - } - - /** - * Add a descending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState decreasing() { - order.add(new DescendingSymbol()); - return new SortOrderState(order); - } - - /** - * Add a descending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState reversed() { - order.add(new DescendingSymbol()); - return new SortOrderState(order); - } - - /** - * Add a descending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState largestFirst() { - order.add(new DescendingSymbol()); - return new SortOrderState(order); - } - - /** - * Add a descending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState smallestLast() { - order.add(new DescendingSymbol()); - return new SortOrderState(order); - } - - /** - * Adds a new {@link KeySymbol} to sort by to the {@link Order} that is - * building. Adds an implicit Ascending sort order to the prior key - * - * @return the builder - */ - public ThenState then(String key) { - order.add(new AscendingSymbol()); - order.add(new KeySymbol(key)); - return new ThenState(order); - } -} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java index d40109710c..05957686b9 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java @@ -34,7 +34,7 @@ *

* This class is the public interface to Order construction. It is meant to * be used in a chained manner, where the caller initially calls - * {@link Order#where()} and continues to construct the Order using the + * {@link Order#by and continues to construct the Order using the * options available from each subsequently returned state. *

* @@ -46,8 +46,10 @@ public class Order implements OrderSymbol { * * @return the Order builder */ - public static StartState where() { - return new StartState(new Order()); + public static StartState by(String key) { + Order order = new Order(); + order.add(new KeySymbol(key)); + return new StartState(order); } /** diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartState.java index 811f7988a0..7f57d34447 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartState.java @@ -16,28 +16,119 @@ package com.cinchapi.concourse.order; /** - * The {@link StartState} marks the logical beginning of a new {@link Order}. + * The {@link State} that expects the next token to be a sort order or a new key + * to sort by. */ -public class StartState extends State { +public class StartState extends BuildableState { /** * Construct a new instance. * * @param Order */ - public StartState(Order Order) { + protected StartState(Order Order) { super(Order); } /** - * Add a {@code key} to the Order that is building. + * Add an ascending sort order to the {@link Order} that is building * - * @param key * @return the builder */ - public ByState by(String key) { - order.add(new KeySymbol(key)); - return new ByState(order); + public SortOrderState ascending() { + order.add(new AscendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add an ascending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState increasing() { + order.add(new AscendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add an ascending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState smallestFirst() { + order.add(new AscendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add an ascending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState largestLast() { + order.add(new AscendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add a descending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState descending() { + order.add(new DescendingSymbol()); + return new SortOrderState(order); } + /** + * Add a descending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState decreasing() { + order.add(new DescendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add a descending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState reversed() { + order.add(new DescendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add a descending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState largestFirst() { + order.add(new DescendingSymbol()); + return new SortOrderState(order); + } + + /** + * Add a descending sort order to the {@link Order} that is building + * + * @return the builder + */ + public SortOrderState smallestLast() { + order.add(new DescendingSymbol()); + return new SortOrderState(order); + } + + /** + * Adds a new {@link KeySymbol} to sort by to the {@link Order} that is + * building. Adds an implicit Ascending sort order to the prior key + * + * @return the builder + */ + public ThenState then(String key) { + order.add(new AscendingSymbol()); + order.add(new KeySymbol(key)); + return new ThenState(order); + } } diff --git a/concourse-driver-java/src/test/java/com/cinchapi/concourse/order/OrderTest.java b/concourse-driver-java/src/test/java/com/cinchapi/concourse/order/OrderTest.java index c108ca0064..aced919319 100644 --- a/concourse-driver-java/src/test/java/com/cinchapi/concourse/order/OrderTest.java +++ b/concourse-driver-java/src/test/java/com/cinchapi/concourse/order/OrderTest.java @@ -31,7 +31,7 @@ public class OrderTest { public void testDefaultSortOrder() { List expected = Lists.newArrayList(new KeySymbol("foo"), new AscendingSymbol()); - Order order = Order.where().by("foo").build(); + Order order = Order.by("foo").build(); Assert.assertEquals(expected, order.getOrderSymbols()); } @@ -39,7 +39,7 @@ public void testDefaultSortOrder() { public void testAscendingSortOrder() { List expected = Lists.newArrayList(new KeySymbol("foo"), new AscendingSymbol()); - Order order = Order.where().by("foo").ascending().build(); + Order order = Order.by("foo").ascending().build(); Assert.assertEquals(expected, order.getOrderSymbols()); } @@ -47,7 +47,7 @@ public void testAscendingSortOrder() { public void testDescendingSortOrder() { List expected = Lists.newArrayList(new KeySymbol("foo"), new DescendingSymbol()); - Order order = Order.where().by("foo").descending().build(); + Order order = Order.by("foo").descending().build(); Assert.assertEquals(expected, order.getOrderSymbols()); } @@ -55,7 +55,7 @@ public void testDescendingSortOrder() { public void testMultipleSortKeysSortOrder() { List expected = Lists.newArrayList(new KeySymbol("foo"), new AscendingSymbol(), new KeySymbol("bar"), new AscendingSymbol()); - Order order = Order.where().by("foo").then("bar").ascending().build(); + Order order = Order.by("foo").then("bar").ascending().build(); Assert.assertEquals(expected, order.getOrderSymbols()); } @@ -64,13 +64,13 @@ public void testMultipleSortKeysWithImplicitSortOrders() { List expected = Lists.newArrayList(new KeySymbol("foo"), new AscendingSymbol(), new KeySymbol("bar"), new AscendingSymbol(), new KeySymbol("zoo"), new AscendingSymbol()); - Order order = Order.where().by("foo").then("bar").then("zoo").build(); + Order order = Order.by("foo").then("bar").then("zoo").build(); Assert.assertEquals(expected, order.getOrderSymbols()); } @Test(expected = IllegalStateException.class) public void testCannotAddSymbolToBuiltOrder() { - Order order = Order.where().by("foo").build(); + Order order = Order.by("foo").build(); order.add(new KeySymbol("baz")); } From df8f8b573993c20c370a0b5d39694c6f09642c63 Mon Sep 17 00:00:00 2001 From: javierlores Date: Wed, 3 Apr 2019 14:17:21 -0600 Subject: [PATCH 03/13] Fixed Order --- .../concourse/order/AscendingSymbol.java | 27 ------- .../concourse/order/BaseOrderSymbol.java | 38 --------- .../concourse/order/DescendingSymbol.java | 27 ------- .../cinchapi/concourse/order/KeySymbol.java | 50 ------------ .../com/cinchapi/concourse/order/Order.java | 37 ++++----- .../cinchapi/concourse/order/SortOrder.java | 77 +++++++++++++++++++ .../concourse/order/SortOrderState.java | 2 +- .../{OrderSymbol.java => SortOrderType.java} | 10 +-- .../cinchapi/concourse/order/StartState.java | 25 +++--- .../cinchapi/concourse/order/ThenState.java | 23 +++--- .../cinchapi/concourse/order/OrderTest.java | 36 +++++---- 11 files changed, 141 insertions(+), 211 deletions(-) delete mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/order/AscendingSymbol.java delete mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BaseOrderSymbol.java delete mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/order/DescendingSymbol.java delete mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/order/KeySymbol.java create mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrder.java rename concourse-driver-java/src/main/java/com/cinchapi/concourse/order/{OrderSymbol.java => SortOrderType.java} (77%) diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/AscendingSymbol.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/AscendingSymbol.java deleted file mode 100644 index 8a1c21e790..0000000000 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/AscendingSymbol.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright (c) 2013-2019 Cinchapi Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.cinchapi.concourse.order; - -/** - * A {@link OrderSymbol} that represents an ascending order - */ -public class AscendingSymbol extends BaseOrderSymbol { - - @Override - public String toString() { - return "ascending"; - } -} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BaseOrderSymbol.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BaseOrderSymbol.java deleted file mode 100644 index b4e5bbb6c2..0000000000 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BaseOrderSymbol.java +++ /dev/null @@ -1,38 +0,0 @@ -/* - * Copyright (c) 2013-2019 Cinchapi Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.cinchapi.concourse.order; - -/** - * An abstract implementation of the {@link OrderSymbol} interface that provides - * {@link #hashCode()} and {@link #equals(Object)}. - */ -public class BaseOrderSymbol implements OrderSymbol { - - @Override - public int hashCode() { - return toString().hashCode(); - } - - @Override - public boolean equals(Object obj) { - if(obj.getClass() == getClass()) { - return toString().equals(obj.toString()); - } - else { - return false; - } - } -} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/DescendingSymbol.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/DescendingSymbol.java deleted file mode 100644 index 05eca591d9..0000000000 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/DescendingSymbol.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright (c) 2013-2019 Cinchapi Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.cinchapi.concourse.order; - -/** - * A {@link OrderSymbol} that represents an descending order - */ -public class DescendingSymbol extends BaseOrderSymbol { - - @Override - public String toString() { - return "descending"; - } -} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/KeySymbol.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/KeySymbol.java deleted file mode 100644 index 3dbfc25df3..0000000000 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/KeySymbol.java +++ /dev/null @@ -1,50 +0,0 @@ -/* - * Copyright (c) 2013-2019 Cinchapi Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.cinchapi.concourse.order; - -/** - * A {@link OrderSymbol} that contains a key to sort by. - */ -public final class KeySymbol extends BaseOrderSymbol { - - /** - * The content of the {@link OrderSymbol}. - */ - private final String key; - - /** - * Construct a new instance. - * - * @param key - */ - public KeySymbol(String key) { - this.key = key; - } - - /** - * Return the key associated with this {@link OrderSymbol}. - * - * @return the key - */ - public String key() { - return key; - } - - @Override - public String toString() { - return key(); - } -} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java index 05957686b9..eb2be702a8 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java @@ -19,8 +19,6 @@ import java.util.List; import java.util.Objects; -import com.cinchapi.ccl.grammar.ParenthesisSymbol; -import com.cinchapi.ccl.grammar.Symbol; import com.google.common.base.Preconditions; import com.google.common.collect.Lists; @@ -39,7 +37,7 @@ *

* */ -public class Order implements OrderSymbol { +public class Order { /** * Start building a new {@link Order}. @@ -48,7 +46,7 @@ public class Order implements OrderSymbol { */ public static StartState by(String key) { Order order = new Order(); - order.add(new KeySymbol(key)); + order.add(new SortOrder(key)); return new StartState(order); } @@ -58,21 +56,21 @@ public static StartState by(String key) { private boolean built = false; /** - * The collection of {@link OrderSymbol}s that make up this {@link Order}. + * The collection of {@link SortOrder}s that make up this {@link Order} */ - private List orderSymbols; + private List sortOrders; /** * Construct a new instance. */ protected Order() { - this.orderSymbols = Lists.newArrayList(); + this.sortOrders = Lists.newArrayList(); } @Override public boolean equals(Object obj) { if(obj instanceof Order) { - return Objects.equals(orderSymbols, ((Order) obj).orderSymbols); + return Objects.equals(sortOrders, ((Order) obj).sortOrders); } else { return false; @@ -81,18 +79,18 @@ public boolean equals(Object obj) { @Override public int hashCode() { - return Objects.hash(orderSymbols); + return Objects.hash(sortOrders); } /** - * Add a {@link OrderSymbol} to this {@link Order}. + * Add a {@link SortOrder} to this {@link Order}. * - * @param orderSymbol + * @param sortOrder */ - protected void add(OrderSymbol orderSymbol) { + protected void add(SortOrder sortOrder) { Preconditions.checkState(!built, - "Cannot add a order symbol to a built Order"); - orderSymbols.add(orderSymbol); + "Cannot add a sort order to a built Order"); + sortOrders.add(sortOrder); } /** @@ -100,18 +98,15 @@ protected void add(OrderSymbol orderSymbol) { */ protected void close() { built = !built ? true : built; - if (orderSymbols.get(orderSymbols.size()-1) instanceof KeySymbol) { - orderSymbols.add(new AscendingSymbol()); - } } /** - * Return the order list of {@link OrderSymbol} that make up this {@link Order}. + * Return the order list of {@link SortOrder} that make up this {@link Order}. * - * @return orderSymbols + * @return sortOrders */ - protected List getOrderSymbols() { - return Collections.unmodifiableList(orderSymbols); + protected List getSortOrders() { + return Collections.unmodifiableList(sortOrders); } } diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrder.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrder.java new file mode 100644 index 0000000000..6b0de28a4c --- /dev/null +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrder.java @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2013-2019 Cinchapi Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.cinchapi.concourse.order; + +/** + * Represents a sort order on a key. + */ +public class SortOrder { + + /** + * The key to sort on + */ + private String key; + + /** + * The order to sort in + */ + private SortOrderType sortOrderType; + + /** + * Constructs an instance + * + * @param key + * @param sortOrderType + */ + public SortOrder(String key, SortOrderType sortOrderType) { + this.key = key; + this.sortOrderType = sortOrderType; + } + + /** + * Constructs an instance with a default Ascending order + * @param key + */ + public SortOrder(String key) { + this.key = key; + this.sortOrderType = SortOrderType.ASCENDING; + } + + /** + * Changes the sort order to descending + */ + public void descending() { + sortOrderType = SortOrderType.DESCENDING; + } + + /** + * CHanges the sort order to ascending + */ + public void ascending() { + sortOrderType = SortOrderType.ASCENDING; + } + + @Override + public boolean equals(Object obj) { + if(obj.getClass() == getClass()) { + return ((SortOrder) obj).key == key && + ((SortOrder) obj).sortOrderType == sortOrderType; + } + else { + return false; + } + } +} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderState.java index 623f8db858..4bdd4686d9 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderState.java @@ -36,7 +36,7 @@ protected SortOrderState(Order Order) { * @return the builder */ public ThenState then(String key) { - order.add(new KeySymbol(key)); + order.add(new SortOrder(key)); return new ThenState(order); } } \ No newline at end of file diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/OrderSymbol.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderType.java similarity index 77% rename from concourse-driver-java/src/main/java/com/cinchapi/concourse/order/OrderSymbol.java rename to concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderType.java index 64cb7208ef..eab119b253 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/OrderSymbol.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderType.java @@ -15,10 +15,10 @@ */ package com.cinchapi.concourse.order; -import javax.annotation.concurrent.Immutable; - /** - * A {@link OrderSymbol} is a terminal or non-terminal component in a an {@link Order} + * Represents a sort order type */ -@Immutable -public interface OrderSymbol {/* marker */} +public enum SortOrderType { + ASCENDING, + DESCENDING +} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartState.java index 7f57d34447..efa8dabe21 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartState.java @@ -36,7 +36,7 @@ protected StartState(Order Order) { * @return the builder */ public SortOrderState ascending() { - order.add(new AscendingSymbol()); + order.getSortOrders().get(order.getSortOrders().size()-1).ascending(); return new SortOrderState(order); } @@ -46,7 +46,7 @@ public SortOrderState ascending() { * @return the builder */ public SortOrderState increasing() { - order.add(new AscendingSymbol()); + order.getSortOrders().get(order.getSortOrders().size()-1).ascending(); return new SortOrderState(order); } @@ -56,7 +56,7 @@ public SortOrderState increasing() { * @return the builder */ public SortOrderState smallestFirst() { - order.add(new AscendingSymbol()); + order.getSortOrders().get(order.getSortOrders().size()-1).ascending(); return new SortOrderState(order); } @@ -66,7 +66,7 @@ public SortOrderState smallestFirst() { * @return the builder */ public SortOrderState largestLast() { - order.add(new AscendingSymbol()); + order.getSortOrders().get(order.getSortOrders().size()-1).ascending(); return new SortOrderState(order); } @@ -76,7 +76,7 @@ public SortOrderState largestLast() { * @return the builder */ public SortOrderState descending() { - order.add(new DescendingSymbol()); + order.getSortOrders().get(order.getSortOrders().size()-1).descending(); return new SortOrderState(order); } @@ -86,7 +86,7 @@ public SortOrderState descending() { * @return the builder */ public SortOrderState decreasing() { - order.add(new DescendingSymbol()); + order.getSortOrders().get(order.getSortOrders().size()-1).descending(); return new SortOrderState(order); } @@ -96,7 +96,7 @@ public SortOrderState decreasing() { * @return the builder */ public SortOrderState reversed() { - order.add(new DescendingSymbol()); + order.getSortOrders().get(order.getSortOrders().size()-1).descending(); return new SortOrderState(order); } @@ -106,7 +106,7 @@ public SortOrderState reversed() { * @return the builder */ public SortOrderState largestFirst() { - order.add(new DescendingSymbol()); + order.getSortOrders().get(order.getSortOrders().size()-1).descending(); return new SortOrderState(order); } @@ -116,19 +116,18 @@ public SortOrderState largestFirst() { * @return the builder */ public SortOrderState smallestLast() { - order.add(new DescendingSymbol()); + order.getSortOrders().get(order.getSortOrders().size()-1).descending(); return new SortOrderState(order); } /** - * Adds a new {@link KeySymbol} to sort by to the {@link Order} that is - * building. Adds an implicit Ascending sort order to the prior key + * Adds a new {@link SortOrder} to sort by to the {@link Order} that is + * building. * * @return the builder */ public ThenState then(String key) { - order.add(new AscendingSymbol()); - order.add(new KeySymbol(key)); + order.add(new SortOrder(key)); return new ThenState(order); } } diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenState.java index 06ab13c9c5..313f14a827 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenState.java @@ -36,7 +36,7 @@ protected ThenState(Order Order) { * @return the builder */ public SortOrderState ascending() { - order.add(new AscendingSymbol()); + order.getSortOrders().get(order.getSortOrders().size()-1).ascending(); return new SortOrderState(order); } @@ -46,7 +46,7 @@ public SortOrderState ascending() { * @return the builder */ public SortOrderState increasing() { - order.add(new AscendingSymbol()); + order.getSortOrders().get(order.getSortOrders().size()-1).ascending(); return new SortOrderState(order); } @@ -56,7 +56,7 @@ public SortOrderState increasing() { * @return the builder */ public SortOrderState smallestFirst() { - order.add(new AscendingSymbol()); + order.getSortOrders().get(order.getSortOrders().size()-1).ascending(); return new SortOrderState(order); } @@ -66,7 +66,7 @@ public SortOrderState smallestFirst() { * @return the builder */ public SortOrderState largestLast() { - order.add(new AscendingSymbol()); + order.getSortOrders().get(order.getSortOrders().size()-1).ascending(); return new SortOrderState(order); } @@ -76,7 +76,7 @@ public SortOrderState largestLast() { * @return the builder */ public SortOrderState descending() { - order.add(new AscendingSymbol()); + order.getSortOrders().get(order.getSortOrders().size()-1).descending(); return new SortOrderState(order); } @@ -86,7 +86,7 @@ public SortOrderState descending() { * @return the builder */ public SortOrderState decreasing() { - order.add(new DescendingSymbol()); + order.getSortOrders().get(order.getSortOrders().size()-1).descending(); return new SortOrderState(order); } @@ -96,7 +96,7 @@ public SortOrderState decreasing() { * @return the builder */ public SortOrderState reversed() { - order.add(new DescendingSymbol()); + order.getSortOrders().get(order.getSortOrders().size()-1).descending(); return new SortOrderState(order); } @@ -106,7 +106,7 @@ public SortOrderState reversed() { * @return the builder */ public SortOrderState largestFirst() { - order.add(new DescendingSymbol()); + order.getSortOrders().get(order.getSortOrders().size()-1).descending(); return new SortOrderState(order); } @@ -116,19 +116,18 @@ public SortOrderState largestFirst() { * @return the builder */ public SortOrderState smallestLast() { - order.add(new DescendingSymbol()); + order.getSortOrders().get(order.getSortOrders().size()-1).descending(); return new SortOrderState(order); } /** - * Adds a new {@link KeySymbol} to sort by to the {@link Order} that is + * Adds a new {@link SortOrder} to sort by to the {@link Order} that is * building. Adds an implicit Ascending sort order to the prior key * * @return the builder */ public ThenState then(String key) { - order.add(new AscendingSymbol()); - order.add(new KeySymbol(key)); + order.add(new SortOrder(key)); return new ThenState(order); } diff --git a/concourse-driver-java/src/test/java/com/cinchapi/concourse/order/OrderTest.java b/concourse-driver-java/src/test/java/com/cinchapi/concourse/order/OrderTest.java index aced919319..8d90df222a 100644 --- a/concourse-driver-java/src/test/java/com/cinchapi/concourse/order/OrderTest.java +++ b/concourse-driver-java/src/test/java/com/cinchapi/concourse/order/OrderTest.java @@ -29,49 +29,51 @@ public class OrderTest { @Test public void testDefaultSortOrder() { - List expected = Lists.newArrayList(new KeySymbol("foo"), - new AscendingSymbol()); + List expected = Lists.newArrayList( + new SortOrder("foo", SortOrderType.ASCENDING)); Order order = Order.by("foo").build(); - Assert.assertEquals(expected, order.getOrderSymbols()); + Assert.assertEquals(expected, order.getSortOrders()); } @Test public void testAscendingSortOrder() { - List expected = Lists.newArrayList(new KeySymbol("foo"), - new AscendingSymbol()); + List expected = Lists.newArrayList( + new SortOrder("foo", SortOrderType.ASCENDING)); Order order = Order.by("foo").ascending().build(); - Assert.assertEquals(expected, order.getOrderSymbols()); + Assert.assertEquals(expected, order.getSortOrders()); } @Test public void testDescendingSortOrder() { - List expected = Lists.newArrayList(new KeySymbol("foo"), - new DescendingSymbol()); + List expected = Lists.newArrayList( + new SortOrder("foo", SortOrderType.DESCENDING)); Order order = Order.by("foo").descending().build(); - Assert.assertEquals(expected, order.getOrderSymbols()); + Assert.assertEquals(expected, order.getSortOrders()); } @Test public void testMultipleSortKeysSortOrder() { - List expected = Lists.newArrayList(new KeySymbol("foo"), - new AscendingSymbol(), new KeySymbol("bar"), new AscendingSymbol()); + List expected = Lists.newArrayList( + new SortOrder("foo", SortOrderType.ASCENDING), + new SortOrder("bar", SortOrderType.ASCENDING)); Order order = Order.by("foo").then("bar").ascending().build(); - Assert.assertEquals(expected, order.getOrderSymbols()); + Assert.assertEquals(expected, order.getSortOrders()); } @Test public void testMultipleSortKeysWithImplicitSortOrders() { - List expected = Lists.newArrayList(new KeySymbol("foo"), - new AscendingSymbol(), new KeySymbol("bar"), new AscendingSymbol(), - new KeySymbol("zoo"), new AscendingSymbol()); + List expected = Lists.newArrayList( + new SortOrder("foo", SortOrderType.ASCENDING), + new SortOrder("bar", SortOrderType.ASCENDING), + new SortOrder("zoo", SortOrderType.ASCENDING)); Order order = Order.by("foo").then("bar").then("zoo").build(); - Assert.assertEquals(expected, order.getOrderSymbols()); + Assert.assertEquals(expected, order.getSortOrders()); } @Test(expected = IllegalStateException.class) public void testCannotAddSymbolToBuiltOrder() { Order order = Order.by("foo").build(); - order.add(new KeySymbol("baz")); + order.add(new SortOrder("Bar", SortOrderType.ASCENDING)); } } From 7bd1440febb3e04a71e6a88e87d5aad7596870ff Mon Sep 17 00:00:00 2001 From: javierlores Date: Wed, 3 Apr 2019 14:23:55 -0600 Subject: [PATCH 04/13] spotless apply --- .../com/cinchapi/concourse/order/Order.java | 6 +++-- .../cinchapi/concourse/order/SortOrder.java | 5 ++-- .../concourse/order/SortOrderType.java | 3 +-- .../cinchapi/concourse/order/StartState.java | 23 +++++++++++-------- .../com/cinchapi/concourse/order/State.java | 7 +++--- .../cinchapi/concourse/order/ThenState.java | 23 +++++++++++-------- .../cinchapi/concourse/order/OrderTest.java | 17 +++++++------- 7 files changed, 48 insertions(+), 36 deletions(-) diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java index eb2be702a8..9dad475421 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java @@ -26,7 +26,8 @@ * A {@link Order} is an object that is used to encapsulate the semantics of * a sort order. Any given time, objects of this class can exist in one * of two modes: {@code building} or {@code built}. When a Order is - * {@code built}, it is guaranteed to represent a fully and well formed sort order + * {@code built}, it is guaranteed to represent a fully and well formed sort + * order * that can be processed. On the other hand, when a Order is {@code building} * it is in an incomplete state. *

@@ -101,7 +102,8 @@ protected void close() { } /** - * Return the order list of {@link SortOrder} that make up this {@link Order}. + * Return the order list of {@link SortOrder} that make up this + * {@link Order}. * * @return sortOrders */ diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrder.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrder.java index 6b0de28a4c..3337a48afc 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrder.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrder.java @@ -43,6 +43,7 @@ public SortOrder(String key, SortOrderType sortOrderType) { /** * Constructs an instance with a default Ascending order + * * @param key */ public SortOrder(String key) { @@ -67,8 +68,8 @@ public void ascending() { @Override public boolean equals(Object obj) { if(obj.getClass() == getClass()) { - return ((SortOrder) obj).key == key && - ((SortOrder) obj).sortOrderType == sortOrderType; + return ((SortOrder) obj).key == key + && ((SortOrder) obj).sortOrderType == sortOrderType; } else { return false; diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderType.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderType.java index eab119b253..79d43ef97a 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderType.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderType.java @@ -19,6 +19,5 @@ * Represents a sort order type */ public enum SortOrderType { - ASCENDING, - DESCENDING + ASCENDING, DESCENDING } diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartState.java index efa8dabe21..34297c6b98 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartState.java @@ -36,7 +36,7 @@ protected StartState(Order Order) { * @return the builder */ public SortOrderState ascending() { - order.getSortOrders().get(order.getSortOrders().size()-1).ascending(); + order.getSortOrders().get(order.getSortOrders().size() - 1).ascending(); return new SortOrderState(order); } @@ -46,7 +46,7 @@ public SortOrderState ascending() { * @return the builder */ public SortOrderState increasing() { - order.getSortOrders().get(order.getSortOrders().size()-1).ascending(); + order.getSortOrders().get(order.getSortOrders().size() - 1).ascending(); return new SortOrderState(order); } @@ -56,7 +56,7 @@ public SortOrderState increasing() { * @return the builder */ public SortOrderState smallestFirst() { - order.getSortOrders().get(order.getSortOrders().size()-1).ascending(); + order.getSortOrders().get(order.getSortOrders().size() - 1).ascending(); return new SortOrderState(order); } @@ -66,7 +66,7 @@ public SortOrderState smallestFirst() { * @return the builder */ public SortOrderState largestLast() { - order.getSortOrders().get(order.getSortOrders().size()-1).ascending(); + order.getSortOrders().get(order.getSortOrders().size() - 1).ascending(); return new SortOrderState(order); } @@ -76,7 +76,8 @@ public SortOrderState largestLast() { * @return the builder */ public SortOrderState descending() { - order.getSortOrders().get(order.getSortOrders().size()-1).descending(); + order.getSortOrders().get(order.getSortOrders().size() - 1) + .descending(); return new SortOrderState(order); } @@ -86,7 +87,8 @@ public SortOrderState descending() { * @return the builder */ public SortOrderState decreasing() { - order.getSortOrders().get(order.getSortOrders().size()-1).descending(); + order.getSortOrders().get(order.getSortOrders().size() - 1) + .descending(); return new SortOrderState(order); } @@ -96,7 +98,8 @@ public SortOrderState decreasing() { * @return the builder */ public SortOrderState reversed() { - order.getSortOrders().get(order.getSortOrders().size()-1).descending(); + order.getSortOrders().get(order.getSortOrders().size() - 1) + .descending(); return new SortOrderState(order); } @@ -106,7 +109,8 @@ public SortOrderState reversed() { * @return the builder */ public SortOrderState largestFirst() { - order.getSortOrders().get(order.getSortOrders().size()-1).descending(); + order.getSortOrders().get(order.getSortOrders().size() - 1) + .descending(); return new SortOrderState(order); } @@ -116,7 +120,8 @@ public SortOrderState largestFirst() { * @return the builder */ public SortOrderState smallestLast() { - order.getSortOrders().get(order.getSortOrders().size()-1).descending(); + order.getSortOrders().get(order.getSortOrders().size() - 1) + .descending(); return new SortOrderState(order); } diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/State.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/State.java index 72cbe8229b..8f2345876a 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/State.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/State.java @@ -1,4 +1,3 @@ - /* * Copyright (c) 2013-2019 Cinchapi Inc. * @@ -15,17 +14,17 @@ * limitations under the License. */ package com.cinchapi.concourse.order; + /** * This is the base class and marker for any valid state in the {@link Order} * builder. Each {@link State} is passed the current {@link Order} and holds - * a reference. For any method called from the state, a {@link OrderSymbol} is added + * a reference. For any method called from the state, a {@link SortOrder} is + * added * to the {@code Order} or the {@code Order} is returned. *

* For the purposes of a builder, a {@link State} typically describes what was * most recently consumed. *

- * - * @author Javier Lores */ public abstract class State { diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenState.java index 313f14a827..0d14837956 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenState.java @@ -36,7 +36,7 @@ protected ThenState(Order Order) { * @return the builder */ public SortOrderState ascending() { - order.getSortOrders().get(order.getSortOrders().size()-1).ascending(); + order.getSortOrders().get(order.getSortOrders().size() - 1).ascending(); return new SortOrderState(order); } @@ -46,7 +46,7 @@ public SortOrderState ascending() { * @return the builder */ public SortOrderState increasing() { - order.getSortOrders().get(order.getSortOrders().size()-1).ascending(); + order.getSortOrders().get(order.getSortOrders().size() - 1).ascending(); return new SortOrderState(order); } @@ -56,7 +56,7 @@ public SortOrderState increasing() { * @return the builder */ public SortOrderState smallestFirst() { - order.getSortOrders().get(order.getSortOrders().size()-1).ascending(); + order.getSortOrders().get(order.getSortOrders().size() - 1).ascending(); return new SortOrderState(order); } @@ -66,7 +66,7 @@ public SortOrderState smallestFirst() { * @return the builder */ public SortOrderState largestLast() { - order.getSortOrders().get(order.getSortOrders().size()-1).ascending(); + order.getSortOrders().get(order.getSortOrders().size() - 1).ascending(); return new SortOrderState(order); } @@ -76,7 +76,8 @@ public SortOrderState largestLast() { * @return the builder */ public SortOrderState descending() { - order.getSortOrders().get(order.getSortOrders().size()-1).descending(); + order.getSortOrders().get(order.getSortOrders().size() - 1) + .descending(); return new SortOrderState(order); } @@ -86,7 +87,8 @@ public SortOrderState descending() { * @return the builder */ public SortOrderState decreasing() { - order.getSortOrders().get(order.getSortOrders().size()-1).descending(); + order.getSortOrders().get(order.getSortOrders().size() - 1) + .descending(); return new SortOrderState(order); } @@ -96,7 +98,8 @@ public SortOrderState decreasing() { * @return the builder */ public SortOrderState reversed() { - order.getSortOrders().get(order.getSortOrders().size()-1).descending(); + order.getSortOrders().get(order.getSortOrders().size() - 1) + .descending(); return new SortOrderState(order); } @@ -106,7 +109,8 @@ public SortOrderState reversed() { * @return the builder */ public SortOrderState largestFirst() { - order.getSortOrders().get(order.getSortOrders().size()-1).descending(); + order.getSortOrders().get(order.getSortOrders().size() - 1) + .descending(); return new SortOrderState(order); } @@ -116,7 +120,8 @@ public SortOrderState largestFirst() { * @return the builder */ public SortOrderState smallestLast() { - order.getSortOrders().get(order.getSortOrders().size()-1).descending(); + order.getSortOrders().get(order.getSortOrders().size() - 1) + .descending(); return new SortOrderState(order); } diff --git a/concourse-driver-java/src/test/java/com/cinchapi/concourse/order/OrderTest.java b/concourse-driver-java/src/test/java/com/cinchapi/concourse/order/OrderTest.java index 8d90df222a..6148994596 100644 --- a/concourse-driver-java/src/test/java/com/cinchapi/concourse/order/OrderTest.java +++ b/concourse-driver-java/src/test/java/com/cinchapi/concourse/order/OrderTest.java @@ -15,11 +15,12 @@ */ package com.cinchapi.concourse.order; -import com.google.common.collect.Lists; +import java.util.List; + import org.junit.Assert; import org.junit.Test; -import java.util.List; +import com.google.common.collect.Lists; /** * Unit tests for the {@link com.cinchapi.concourse.order.Order} building @@ -29,24 +30,24 @@ public class OrderTest { @Test public void testDefaultSortOrder() { - List expected = Lists.newArrayList( - new SortOrder("foo", SortOrderType.ASCENDING)); + List expected = Lists + .newArrayList(new SortOrder("foo", SortOrderType.ASCENDING)); Order order = Order.by("foo").build(); Assert.assertEquals(expected, order.getSortOrders()); } @Test public void testAscendingSortOrder() { - List expected = Lists.newArrayList( - new SortOrder("foo", SortOrderType.ASCENDING)); + List expected = Lists + .newArrayList(new SortOrder("foo", SortOrderType.ASCENDING)); Order order = Order.by("foo").ascending().build(); Assert.assertEquals(expected, order.getSortOrders()); } @Test public void testDescendingSortOrder() { - List expected = Lists.newArrayList( - new SortOrder("foo", SortOrderType.DESCENDING)); + List expected = Lists + .newArrayList(new SortOrder("foo", SortOrderType.DESCENDING)); Order order = Order.by("foo").descending().build(); Assert.assertEquals(expected, order.getSortOrders()); } From d5fe5bdc9256f7af2cf5fd53b752668635f06652 Mon Sep 17 00:00:00 2001 From: javierlores Date: Thu, 4 Apr 2019 07:22:28 -0600 Subject: [PATCH 05/13] Renamed classes --- .../{BuildableState.java => BuildableOrderState.java} | 4 ++-- .../main/java/com/cinchapi/concourse/order/Order.java | 4 ++-- .../concourse/order/{State.java => OrderState.java} | 8 ++++---- .../com/cinchapi/concourse/order/SortOrderState.java | 8 ++++---- .../order/{StartState.java => StartOrderState.java} | 10 +++++----- .../order/{ThenState.java => ThenOrderState.java} | 10 +++++----- 6 files changed, 22 insertions(+), 22 deletions(-) rename concourse-driver-java/src/main/java/com/cinchapi/concourse/order/{BuildableState.java => BuildableOrderState.java} (90%) rename concourse-driver-java/src/main/java/com/cinchapi/concourse/order/{State.java => OrderState.java} (82%) rename concourse-driver-java/src/main/java/com/cinchapi/concourse/order/{StartState.java => StartOrderState.java} (93%) rename concourse-driver-java/src/main/java/com/cinchapi/concourse/order/{ThenState.java => ThenOrderState.java} (93%) diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BuildableState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BuildableOrderState.java similarity index 90% rename from concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BuildableState.java rename to concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BuildableOrderState.java index df6c75a4ea..c5f7e6fa49 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BuildableState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BuildableOrderState.java @@ -20,14 +20,14 @@ * and well-formed {@link Order}. * */ -public abstract class BuildableState extends State { +public abstract class BuildableOrderState extends OrderState { /** * Construct a new instance. * * @param Order */ - protected BuildableState(Order Order) { + protected BuildableOrderState(Order Order) { super(Order); } diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java index 9dad475421..957d4e50fe 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java @@ -45,10 +45,10 @@ public class Order { * * @return the Order builder */ - public static StartState by(String key) { + public static StartOrderState by(String key) { Order order = new Order(); order.add(new SortOrder(key)); - return new StartState(order); + return new StartOrderState(order); } /** diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/State.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/OrderState.java similarity index 82% rename from concourse-driver-java/src/main/java/com/cinchapi/concourse/order/State.java rename to concourse-driver-java/src/main/java/com/cinchapi/concourse/order/OrderState.java index 8f2345876a..c9972ad2af 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/State.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/OrderState.java @@ -17,16 +17,16 @@ /** * This is the base class and marker for any valid state in the {@link Order} - * builder. Each {@link State} is passed the current {@link Order} and holds + * builder. Each {@link OrderState} is passed the current {@link Order} and holds * a reference. For any method called from the state, a {@link SortOrder} is * added * to the {@code Order} or the {@code Order} is returned. *

- * For the purposes of a builder, a {@link State} typically describes what was + * For the purposes of a builder, a {@link OrderState} typically describes what was * most recently consumed. *

*/ -public abstract class State { +public abstract class OrderState { /** * A reference to the {@link Order} that is being built. @@ -38,7 +38,7 @@ public abstract class State { * * @param order */ - protected State(Order order) { + protected OrderState(Order order) { this.order = order; } diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderState.java index 4bdd4686d9..59764cd482 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderState.java @@ -16,9 +16,9 @@ package com.cinchapi.concourse.order; /** - * The {@link State} that expects the current token to be a sort key. + * The {@link OrderState} that expects the current token to be a sort key. */ -public class SortOrderState extends BuildableState { +public class SortOrderState extends BuildableOrderState { /** * Construct a new instance. @@ -35,8 +35,8 @@ protected SortOrderState(Order Order) { * @param key * @return the builder */ - public ThenState then(String key) { + public ThenOrderState then(String key) { order.add(new SortOrder(key)); - return new ThenState(order); + return new ThenOrderState(order); } } \ No newline at end of file diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartOrderState.java similarity index 93% rename from concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartState.java rename to concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartOrderState.java index 34297c6b98..e253ac9042 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartOrderState.java @@ -16,17 +16,17 @@ package com.cinchapi.concourse.order; /** - * The {@link State} that expects the next token to be a sort order or a new key + * The {@link OrderState} that expects the next token to be a sort order or a new key * to sort by. */ -public class StartState extends BuildableState { +public class StartOrderState extends BuildableOrderState { /** * Construct a new instance. * * @param Order */ - protected StartState(Order Order) { + protected StartOrderState(Order Order) { super(Order); } @@ -131,8 +131,8 @@ public SortOrderState smallestLast() { * * @return the builder */ - public ThenState then(String key) { + public ThenOrderState then(String key) { order.add(new SortOrder(key)); - return new ThenState(order); + return new ThenOrderState(order); } } diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenOrderState.java similarity index 93% rename from concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenState.java rename to concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenOrderState.java index 0d14837956..13fa5df86c 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenOrderState.java @@ -16,17 +16,17 @@ package com.cinchapi.concourse.order; /** - * The {@link State} that expects the current token to be a sort order or a + * The {@link OrderState} that expects the current token to be a sort order or a * sort key. */ -public class ThenState extends BuildableState { +public class ThenOrderState extends BuildableOrderState { /** * Construct a new instance. * * @param Order */ - protected ThenState(Order Order) { + protected ThenOrderState(Order Order) { super(Order); } @@ -131,9 +131,9 @@ public SortOrderState smallestLast() { * * @return the builder */ - public ThenState then(String key) { + public ThenOrderState then(String key) { order.add(new SortOrder(key)); - return new ThenState(order); + return new ThenOrderState(order); } } \ No newline at end of file From f2c6eefb52b8657722c7bf57a4e62d6953af2dd8 Mon Sep 17 00:00:00 2001 From: javierlores Date: Thu, 4 Apr 2019 07:26:17 -0600 Subject: [PATCH 06/13] Moved files to lang.sort package --- .../{order => lang/sort}/BuildableOrderState.java | 2 +- .../com/cinchapi/concourse/{order => lang/sort}/Order.java | 2 +- .../concourse/{order => lang/sort}/OrderState.java | 2 +- .../cinchapi/concourse/{order => lang/sort}/SortOrder.java | 2 +- .../concourse/{order => lang/sort}/SortOrderState.java | 2 +- .../concourse/{order => lang/sort}/SortOrderType.java | 2 +- .../concourse/{order => lang/sort}/StartOrderState.java | 2 +- .../concourse/{order => lang/sort}/ThenOrderState.java | 2 +- .../cinchapi/concourse/{order => lang/sort}/OrderTest.java | 7 +++++-- 9 files changed, 13 insertions(+), 10 deletions(-) rename concourse-driver-java/src/main/java/com/cinchapi/concourse/{order => lang/sort}/BuildableOrderState.java (96%) rename concourse-driver-java/src/main/java/com/cinchapi/concourse/{order => lang/sort}/Order.java (98%) rename concourse-driver-java/src/main/java/com/cinchapi/concourse/{order => lang/sort}/OrderState.java (96%) rename concourse-driver-java/src/main/java/com/cinchapi/concourse/{order => lang/sort}/SortOrder.java (97%) rename concourse-driver-java/src/main/java/com/cinchapi/concourse/{order => lang/sort}/SortOrderState.java (96%) rename concourse-driver-java/src/main/java/com/cinchapi/concourse/{order => lang/sort}/SortOrderType.java (94%) rename concourse-driver-java/src/main/java/com/cinchapi/concourse/{order => lang/sort}/StartOrderState.java (98%) rename concourse-driver-java/src/main/java/com/cinchapi/concourse/{order => lang/sort}/ThenOrderState.java (98%) rename concourse-driver-java/src/test/java/com/cinchapi/concourse/{order => lang/sort}/OrderTest.java (91%) diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BuildableOrderState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/BuildableOrderState.java similarity index 96% rename from concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BuildableOrderState.java rename to concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/BuildableOrderState.java index c5f7e6fa49..019124bd5f 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/BuildableOrderState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/BuildableOrderState.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.cinchapi.concourse.order; +package com.cinchapi.concourse.lang.sort; /** * The base class for a Sort Order state that can be transformed into a complete diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Order.java similarity index 98% rename from concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java rename to concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Order.java index 957d4e50fe..decd7812c9 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/Order.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Order.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.cinchapi.concourse.order; +package com.cinchapi.concourse.lang.sort; import java.util.Collections; import java.util.List; diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/OrderState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderState.java similarity index 96% rename from concourse-driver-java/src/main/java/com/cinchapi/concourse/order/OrderState.java rename to concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderState.java index c9972ad2af..d30d6224bb 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/OrderState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderState.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.cinchapi.concourse.order; +package com.cinchapi.concourse.lang.sort; /** * This is the base class and marker for any valid state in the {@link Order} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrder.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/SortOrder.java similarity index 97% rename from concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrder.java rename to concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/SortOrder.java index 3337a48afc..8b4052254e 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrder.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/SortOrder.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.cinchapi.concourse.order; +package com.cinchapi.concourse.lang.sort; /** * Represents a sort order on a key. diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/SortOrderState.java similarity index 96% rename from concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderState.java rename to concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/SortOrderState.java index 59764cd482..c9462eb7c6 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/SortOrderState.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.cinchapi.concourse.order; +package com.cinchapi.concourse.lang.sort; /** * The {@link OrderState} that expects the current token to be a sort key. diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderType.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/SortOrderType.java similarity index 94% rename from concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderType.java rename to concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/SortOrderType.java index 79d43ef97a..c6de480e13 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/SortOrderType.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/SortOrderType.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.cinchapi.concourse.order; +package com.cinchapi.concourse.lang.sort; /** * Represents a sort order type diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartOrderState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/StartOrderState.java similarity index 98% rename from concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartOrderState.java rename to concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/StartOrderState.java index e253ac9042..c8405ceb70 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/StartOrderState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/StartOrderState.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.cinchapi.concourse.order; +package com.cinchapi.concourse.lang.sort; /** * The {@link OrderState} that expects the next token to be a sort order or a new key diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenOrderState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/ThenOrderState.java similarity index 98% rename from concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenOrderState.java rename to concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/ThenOrderState.java index 13fa5df86c..d9e0edc7cd 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/order/ThenOrderState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/ThenOrderState.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.cinchapi.concourse.order; +package com.cinchapi.concourse.lang.sort; /** * The {@link OrderState} that expects the current token to be a sort order or a diff --git a/concourse-driver-java/src/test/java/com/cinchapi/concourse/order/OrderTest.java b/concourse-driver-java/src/test/java/com/cinchapi/concourse/lang/sort/OrderTest.java similarity index 91% rename from concourse-driver-java/src/test/java/com/cinchapi/concourse/order/OrderTest.java rename to concourse-driver-java/src/test/java/com/cinchapi/concourse/lang/sort/OrderTest.java index 6148994596..c7bfb7328a 100644 --- a/concourse-driver-java/src/test/java/com/cinchapi/concourse/order/OrderTest.java +++ b/concourse-driver-java/src/test/java/com/cinchapi/concourse/lang/sort/OrderTest.java @@ -13,17 +13,20 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.cinchapi.concourse.order; +package com.cinchapi.concourse.lang.sort; import java.util.List; +import com.cinchapi.concourse.lang.sort.Order; +import com.cinchapi.concourse.lang.sort.SortOrder; +import com.cinchapi.concourse.lang.sort.SortOrderType; import org.junit.Assert; import org.junit.Test; import com.google.common.collect.Lists; /** - * Unit tests for the {@link com.cinchapi.concourse.order.Order} building + * Unit tests for the {@link Order} building * functionality. */ public class OrderTest { From cfcd4f9b88963f5ccf6d45986f2c5cf10183bfb8 Mon Sep 17 00:00:00 2001 From: javierlores Date: Thu, 4 Apr 2019 07:42:28 -0600 Subject: [PATCH 07/13] Added Sort alias for Order --- .../com/cinchapi/concourse/lang/Language.java | 3 +- .../cinchapi/concourse/lang/sort/Sort.java | 31 +++++++++++++++++++ .../concourse/lang/sort/OrderTest.java | 8 +++++ 3 files changed, 40 insertions(+), 2 deletions(-) create mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Sort.java diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/Language.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/Language.java index 34269c2ad0..4d7488ea4b 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/Language.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/Language.java @@ -63,8 +63,7 @@ else if(tsymbol.getType() == TSymbolType.KEY) { else if(tsymbol.getType() == TSymbolType.VALUE) { Object symbol = Convert.stringToJava(tsymbol.getSymbol()); if(symbol instanceof String && !symbol.equals(tsymbol.getSymbol()) - && AnyStrings.isWithinQuotes(tsymbol.getSymbol(), - TAG_MARKER)) { + && AnyStrings.isWithinQuotes(tsymbol.getSymbol())) { // CON-634: This is an obscure corner case where the surrounding // quotes on the original tsymbol were necessary to escape a // keyword, but got dropped because of the logic in diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Sort.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Sort.java new file mode 100644 index 0000000000..801aec1658 --- /dev/null +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Sort.java @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2013-2019 Cinchapi Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.cinchapi.concourse.lang.sort; + +/** + * Serves as an alias for {@link Order} + */ +public class Sort { + /** + * Start building a new {@link Order}. + * + * @return the Order builder + */ + public static StartOrderState by(String key) { + return Order.by(key); + } + +} diff --git a/concourse-driver-java/src/test/java/com/cinchapi/concourse/lang/sort/OrderTest.java b/concourse-driver-java/src/test/java/com/cinchapi/concourse/lang/sort/OrderTest.java index c7bfb7328a..c251dcc26c 100644 --- a/concourse-driver-java/src/test/java/com/cinchapi/concourse/lang/sort/OrderTest.java +++ b/concourse-driver-java/src/test/java/com/cinchapi/concourse/lang/sort/OrderTest.java @@ -80,4 +80,12 @@ public void testCannotAddSymbolToBuiltOrder() { order.add(new SortOrder("Bar", SortOrderType.ASCENDING)); } + @Test + public void testAlias() { + List expected = Lists + .newArrayList(new SortOrder("foo", SortOrderType.ASCENDING)); + Order order = Sort.by("foo").build(); + Assert.assertEquals(expected, order.getSortOrders()); + } + } From 3051f2162a100504527f2c0a59e37a7c74cf6d32 Mon Sep 17 00:00:00 2001 From: javierlores Date: Thu, 4 Apr 2019 07:54:10 -0600 Subject: [PATCH 08/13] Spotless apply --- .../java/com/cinchapi/concourse/lang/sort/OrderState.java | 6 ++++-- .../com/cinchapi/concourse/lang/sort/StartOrderState.java | 3 ++- .../java/com/cinchapi/concourse/lang/sort/OrderTest.java | 5 +---- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderState.java index d30d6224bb..59ef7ef90c 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderState.java @@ -17,12 +17,14 @@ /** * This is the base class and marker for any valid state in the {@link Order} - * builder. Each {@link OrderState} is passed the current {@link Order} and holds + * builder. Each {@link OrderState} is passed the current {@link Order} and + * holds * a reference. For any method called from the state, a {@link SortOrder} is * added * to the {@code Order} or the {@code Order} is returned. *

- * For the purposes of a builder, a {@link OrderState} typically describes what was + * For the purposes of a builder, a {@link OrderState} typically describes what + * was * most recently consumed. *

*/ diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/StartOrderState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/StartOrderState.java index c8405ceb70..ea59d72c09 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/StartOrderState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/StartOrderState.java @@ -16,7 +16,8 @@ package com.cinchapi.concourse.lang.sort; /** - * The {@link OrderState} that expects the next token to be a sort order or a new key + * The {@link OrderState} that expects the next token to be a sort order or a + * new key * to sort by. */ public class StartOrderState extends BuildableOrderState { diff --git a/concourse-driver-java/src/test/java/com/cinchapi/concourse/lang/sort/OrderTest.java b/concourse-driver-java/src/test/java/com/cinchapi/concourse/lang/sort/OrderTest.java index c251dcc26c..82bedbe235 100644 --- a/concourse-driver-java/src/test/java/com/cinchapi/concourse/lang/sort/OrderTest.java +++ b/concourse-driver-java/src/test/java/com/cinchapi/concourse/lang/sort/OrderTest.java @@ -17,16 +17,13 @@ import java.util.List; -import com.cinchapi.concourse.lang.sort.Order; -import com.cinchapi.concourse.lang.sort.SortOrder; -import com.cinchapi.concourse.lang.sort.SortOrderType; import org.junit.Assert; import org.junit.Test; import com.google.common.collect.Lists; /** - * Unit tests for the {@link Order} building + * Unit tests for the {@link com.cinchapi.concourse.lang.sort.Order} building * functionality. */ public class OrderTest { From 281c1df55d88c7c46879809ed7833b1822c8b53c Mon Sep 17 00:00:00 2001 From: javierlores Date: Thu, 4 Apr 2019 07:54:56 -0600 Subject: [PATCH 09/13] Readded removed line --- .../src/main/java/com/cinchapi/concourse/lang/Language.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/Language.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/Language.java index 4d7488ea4b..fdcfb79cd1 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/Language.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/Language.java @@ -63,7 +63,8 @@ else if(tsymbol.getType() == TSymbolType.KEY) { else if(tsymbol.getType() == TSymbolType.VALUE) { Object symbol = Convert.stringToJava(tsymbol.getSymbol()); if(symbol instanceof String && !symbol.equals(tsymbol.getSymbol()) - && AnyStrings.isWithinQuotes(tsymbol.getSymbol())) { + && AnyStrings.isWithinQuotes(tsymbol.getSymbol(), + TAG_MARKER)) { // CON-634: This is an obscure corner case where the surrounding // quotes on the original tsymbol were necessary to escape a // keyword, but got dropped because of the logic in From 98abde93012739b6fffb736902312d25b402b05e Mon Sep 17 00:00:00 2001 From: javierlores Date: Thu, 4 Apr 2019 07:56:20 -0600 Subject: [PATCH 10/13] SpotlessApply --- .../src/main/java/com/cinchapi/concourse/lang/Language.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/Language.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/Language.java index fdcfb79cd1..34269c2ad0 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/Language.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/Language.java @@ -64,7 +64,7 @@ else if(tsymbol.getType() == TSymbolType.VALUE) { Object symbol = Convert.stringToJava(tsymbol.getSymbol()); if(symbol instanceof String && !symbol.equals(tsymbol.getSymbol()) && AnyStrings.isWithinQuotes(tsymbol.getSymbol(), - TAG_MARKER)) { + TAG_MARKER)) { // CON-634: This is an obscure corner case where the surrounding // quotes on the original tsymbol were necessary to escape a // keyword, but got dropped because of the logic in From 1aa7d807866a7253926e4f9437e47024f1c769df Mon Sep 17 00:00:00 2001 From: Jeff Nelson Date: Sat, 6 Apr 2019 18:00:54 -0400 Subject: [PATCH 11/13] Refactor Order builder a bit --- .../lang/sort/BuildableOrderState.java | 6 +- .../concourse/lang/sort/Direction.java | 60 ++++++++ .../cinchapi/concourse/lang/sort/Order.java | 79 +++++----- .../concourse/lang/sort/OrderByState.java | 129 ++++++++++++++++ ...rderType.java => OrderDirectionState.java} | 21 ++- ...ortOrderState.java => OrderThenState.java} | 23 ++- .../cinchapi/concourse/lang/sort/Sort.java | 3 +- .../concourse/lang/sort/SortOrder.java | 78 ---------- .../concourse/lang/sort/StartOrderState.java | 139 ------------------ .../concourse/lang/sort/ThenOrderState.java | 139 ------------------ .../concourse/lang/sort/OrderTest.java | 54 +++---- 11 files changed, 288 insertions(+), 443 deletions(-) create mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Direction.java create mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderByState.java rename concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/{SortOrderType.java => OrderDirectionState.java} (62%) rename concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/{SortOrderState.java => OrderThenState.java} (60%) delete mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/SortOrder.java delete mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/StartOrderState.java delete mode 100644 concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/ThenOrderState.java diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/BuildableOrderState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/BuildableOrderState.java index 019124bd5f..b17eb6c630 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/BuildableOrderState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/BuildableOrderState.java @@ -25,10 +25,10 @@ public abstract class BuildableOrderState extends OrderState { /** * Construct a new instance. * - * @param Order + * @param order */ - protected BuildableOrderState(Order Order) { - super(Order); + protected BuildableOrderState(Order order) { + super(order); } /** diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Direction.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Direction.java new file mode 100644 index 0000000000..a935fde7e4 --- /dev/null +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Direction.java @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2013-2019 Cinchapi Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.cinchapi.concourse.lang.sort; + +/** + * Sort directions. + * + * @author Jeff Nelson + */ +enum Direction { + + ASCENDING(1), DESCENDING(-1); + + /** + * Return the default {@link Direction}. + * + * @return the default + */ + static Direction $default() { + return Direction.ASCENDING; + } + + /** + * The coefficient is multiplied by the result of a {@link Comparator} to + * sort elements in forward or reverse order. + */ + private final int coefficient; + + /** + * Construct a new instance. + * + * @param coefficient + */ + Direction(int coefficient) { + this.coefficient = coefficient; + } + + /** + * Return the coefficient associated with this {@link Direction}. + * + * @return the coefficient + */ + public int coefficient() { + return coefficient; + } + +} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Order.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Order.java index decd7812c9..60287d83eb 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Order.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Order.java @@ -15,40 +15,53 @@ */ package com.cinchapi.concourse.lang.sort; -import java.util.Collections; -import java.util.List; +import java.util.LinkedHashMap; import java.util.Objects; +import javax.annotation.Nullable; + +import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Preconditions; -import com.google.common.collect.Lists; +import com.google.common.collect.Maps; /** - * A {@link Order} is an object that is used to encapsulate the semantics of - * a sort order. Any given time, objects of this class can exist in one - * of two modes: {@code building} or {@code built}. When a Order is + * {@link Order} encapsulates the semantics of a result set sorting. Any given + * time, objects of this class can exist in one of two modes: {@code building} + * or {@code built}. When an Order is * {@code built}, it is guaranteed to represent a fully and well formed sort - * order - * that can be processed. On the other hand, when a Order is {@code building} - * it is in an incomplete state. + * order that can be processed. On the other hand, when a Order is + * {@code building} it is in an incomplete state. *

* This class is the public interface to Order construction. It is meant to * be used in a chained manner, where the caller initially calls - * {@link Order#by and continues to construct the Order using the + * {@link Order#by} and continues to construct the Order using the * options available from each subsequently returned state. *

* */ -public class Order { +public final class Order { + + /** + * A mapping from each key to direction ordinal (e.g. 1 for ASC and -1 for + * DESC) in the constructed {@link Order}. + */ + @VisibleForTesting + final LinkedHashMap spec; + + /** + * The last key that was {@link #add(String, Direction) added}. + */ + @Nullable + protected String lastKey; /** * Start building a new {@link Order}. * * @return the Order builder */ - public static StartOrderState by(String key) { + public static OrderByState by(String key) { Order order = new Order(); - order.add(new SortOrder(key)); - return new StartOrderState(order); + return new OrderByState(order, key, Direction.$default()); } /** @@ -56,22 +69,17 @@ public static StartOrderState by(String key) { */ private boolean built = false; - /** - * The collection of {@link SortOrder}s that make up this {@link Order} - */ - private List sortOrders; - /** * Construct a new instance. */ - protected Order() { - this.sortOrders = Lists.newArrayList(); + private Order() { + this.spec = Maps.newLinkedHashMap(); } @Override public boolean equals(Object obj) { if(obj instanceof Order) { - return Objects.equals(sortOrders, ((Order) obj).sortOrders); + return Objects.equals(spec, ((Order) obj).spec); } else { return false; @@ -80,18 +88,19 @@ public boolean equals(Object obj) { @Override public int hashCode() { - return Objects.hash(sortOrders); + return spec.hashCode(); } /** - * Add a {@link SortOrder} to this {@link Order}. - * - * @param sortOrder + * Add to the order {@link #spec}. + * + * @param key + * @param direction */ - protected void add(SortOrder sortOrder) { - Preconditions.checkState(!built, - "Cannot add a sort order to a built Order"); - sortOrders.add(sortOrder); + final void add(String key, Direction direction) { + Preconditions.checkState(!built, "Cannot modify a built Order"); + spec.put(key, direction.coefficient()); + this.lastKey = key; } /** @@ -101,14 +110,4 @@ protected void close() { built = !built ? true : built; } - /** - * Return the order list of {@link SortOrder} that make up this - * {@link Order}. - * - * @return sortOrders - */ - protected List getSortOrders() { - return Collections.unmodifiableList(sortOrders); - } - } diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderByState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderByState.java new file mode 100644 index 0000000000..f0436ed883 --- /dev/null +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderByState.java @@ -0,0 +1,129 @@ +/* + * Copyright (c) 2013-2019 Cinchapi Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.cinchapi.concourse.lang.sort; + +/** + * The {@link OrderState} that expects the next token to be a sort order or a + * new key + * to sort by. + */ +public class OrderByState extends BuildableOrderState { + + /** + * Construct a new instance. + * + * @param order + */ + OrderByState(Order order, String key, Direction direction) { + super(order); + order.add(key, direction); + } + + /** + * Add the {@link Direction#ASCENDING} direction to the last key that + * was specified in {@link Order} that is building + * + * @return the builder + */ + public OrderDirectionState ascending() { + return new OrderDirectionState(order, order.lastKey, + Direction.ASCENDING); + } + + /** + * Alias for {@link #descending()}. + * + * @return the builder + */ + public OrderDirectionState decreasing() { + return descending(); + } + + /** + * Add the {@link Direction#DESCENDING} direction to the last key that + * was specified in {@link Order} that is building + * + * @return the builder + */ + public OrderDirectionState descending() { + return new OrderDirectionState(order, order.lastKey, + Direction.DESCENDING); + } + + /** + * Alias for {@link #ascending()}. + * + * @return the builder + */ + public OrderDirectionState increasing() { + return ascending(); + } + + /** + * Alias for {@link #descending()}. + * + * @return the builder + */ + public OrderDirectionState largestFirst() { + return descending(); + } + + /** + * Alias for {@link #ascending()}. + * + * @return the builder + */ + public OrderDirectionState largestLast() { + return ascending(); + } + + /** + * Alias for {@link #descending()}. + * + * @return the builder + */ + public OrderDirectionState reversed() { + return descending(); + } + + /** + * Alias for {@link #ascending()}. + * + * @return the builder + */ + public OrderDirectionState smallestFirst() { + return ascending(); + } + + /** + * Alias for {@link #descending()}. + * + * @return the builder + */ + public OrderDirectionState smallestLast() { + return descending(); + } + + /** + * Adds a new {@link SortOrder} to sort by to the {@link Order} that is + * building. + * + * @return the builder + */ + public OrderThenState then() { + return new OrderThenState(order); + } +} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/SortOrderType.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderDirectionState.java similarity index 62% rename from concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/SortOrderType.java rename to concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderDirectionState.java index c6de480e13..7c10ab68c2 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/SortOrderType.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderDirectionState.java @@ -16,8 +16,23 @@ package com.cinchapi.concourse.lang.sort; /** - * Represents a sort order type + * + * + * @author Jeff Nelson */ -public enum SortOrderType { - ASCENDING, DESCENDING +public class OrderDirectionState extends BuildableOrderState { + + /** + * Construct a new instance. + * @param order + */ + OrderDirectionState(Order order, String key, Direction direction) { + super(order); + order.add(key, direction); + } + + public OrderThenState then() { + return new OrderThenState(order); + } + } diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/SortOrderState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderThenState.java similarity index 60% rename from concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/SortOrderState.java rename to concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderThenState.java index c9462eb7c6..90581383eb 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/SortOrderState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderThenState.java @@ -16,27 +16,22 @@ package com.cinchapi.concourse.lang.sort; /** - * The {@link OrderState} that expects the current token to be a sort key. + * The {@link OrderThenState} is simply a bridge that allows a transition back + * to a {@link OrderByState}. */ -public class SortOrderState extends BuildableOrderState { +public class OrderThenState extends OrderState { /** * Construct a new instance. * - * @param Order + * @param order */ - protected SortOrderState(Order Order) { - super(Order); + OrderThenState(Order order) { + super(order); } - /** - * Add a {@code key} to the Order that is building. - * - * @param key - * @return the builder - */ - public ThenOrderState then(String key) { - order.add(new SortOrder(key)); - return new ThenOrderState(order); + public OrderByState by(String key) { + return new OrderByState(order, key, Direction.$default()); } + } \ No newline at end of file diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Sort.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Sort.java index 801aec1658..546a64f5a5 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Sort.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Sort.java @@ -19,12 +19,13 @@ * Serves as an alias for {@link Order} */ public class Sort { + /** * Start building a new {@link Order}. * * @return the Order builder */ - public static StartOrderState by(String key) { + public static OrderByState by(String key) { return Order.by(key); } diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/SortOrder.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/SortOrder.java deleted file mode 100644 index 8b4052254e..0000000000 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/SortOrder.java +++ /dev/null @@ -1,78 +0,0 @@ -/* - * Copyright (c) 2013-2019 Cinchapi Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.cinchapi.concourse.lang.sort; - -/** - * Represents a sort order on a key. - */ -public class SortOrder { - - /** - * The key to sort on - */ - private String key; - - /** - * The order to sort in - */ - private SortOrderType sortOrderType; - - /** - * Constructs an instance - * - * @param key - * @param sortOrderType - */ - public SortOrder(String key, SortOrderType sortOrderType) { - this.key = key; - this.sortOrderType = sortOrderType; - } - - /** - * Constructs an instance with a default Ascending order - * - * @param key - */ - public SortOrder(String key) { - this.key = key; - this.sortOrderType = SortOrderType.ASCENDING; - } - - /** - * Changes the sort order to descending - */ - public void descending() { - sortOrderType = SortOrderType.DESCENDING; - } - - /** - * CHanges the sort order to ascending - */ - public void ascending() { - sortOrderType = SortOrderType.ASCENDING; - } - - @Override - public boolean equals(Object obj) { - if(obj.getClass() == getClass()) { - return ((SortOrder) obj).key == key - && ((SortOrder) obj).sortOrderType == sortOrderType; - } - else { - return false; - } - } -} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/StartOrderState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/StartOrderState.java deleted file mode 100644 index ea59d72c09..0000000000 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/StartOrderState.java +++ /dev/null @@ -1,139 +0,0 @@ -/* - * Copyright (c) 2013-2019 Cinchapi Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.cinchapi.concourse.lang.sort; - -/** - * The {@link OrderState} that expects the next token to be a sort order or a - * new key - * to sort by. - */ -public class StartOrderState extends BuildableOrderState { - - /** - * Construct a new instance. - * - * @param Order - */ - protected StartOrderState(Order Order) { - super(Order); - } - - /** - * Add an ascending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState ascending() { - order.getSortOrders().get(order.getSortOrders().size() - 1).ascending(); - return new SortOrderState(order); - } - - /** - * Add an ascending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState increasing() { - order.getSortOrders().get(order.getSortOrders().size() - 1).ascending(); - return new SortOrderState(order); - } - - /** - * Add an ascending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState smallestFirst() { - order.getSortOrders().get(order.getSortOrders().size() - 1).ascending(); - return new SortOrderState(order); - } - - /** - * Add an ascending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState largestLast() { - order.getSortOrders().get(order.getSortOrders().size() - 1).ascending(); - return new SortOrderState(order); - } - - /** - * Add a descending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState descending() { - order.getSortOrders().get(order.getSortOrders().size() - 1) - .descending(); - return new SortOrderState(order); - } - - /** - * Add a descending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState decreasing() { - order.getSortOrders().get(order.getSortOrders().size() - 1) - .descending(); - return new SortOrderState(order); - } - - /** - * Add a descending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState reversed() { - order.getSortOrders().get(order.getSortOrders().size() - 1) - .descending(); - return new SortOrderState(order); - } - - /** - * Add a descending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState largestFirst() { - order.getSortOrders().get(order.getSortOrders().size() - 1) - .descending(); - return new SortOrderState(order); - } - - /** - * Add a descending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState smallestLast() { - order.getSortOrders().get(order.getSortOrders().size() - 1) - .descending(); - return new SortOrderState(order); - } - - /** - * Adds a new {@link SortOrder} to sort by to the {@link Order} that is - * building. - * - * @return the builder - */ - public ThenOrderState then(String key) { - order.add(new SortOrder(key)); - return new ThenOrderState(order); - } -} diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/ThenOrderState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/ThenOrderState.java deleted file mode 100644 index d9e0edc7cd..0000000000 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/ThenOrderState.java +++ /dev/null @@ -1,139 +0,0 @@ -/* - * Copyright (c) 2013-2019 Cinchapi Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.cinchapi.concourse.lang.sort; - -/** - * The {@link OrderState} that expects the current token to be a sort order or a - * sort key. - */ -public class ThenOrderState extends BuildableOrderState { - - /** - * Construct a new instance. - * - * @param Order - */ - protected ThenOrderState(Order Order) { - super(Order); - } - - /** - * Add an ascending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState ascending() { - order.getSortOrders().get(order.getSortOrders().size() - 1).ascending(); - return new SortOrderState(order); - } - - /** - * Add an ascending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState increasing() { - order.getSortOrders().get(order.getSortOrders().size() - 1).ascending(); - return new SortOrderState(order); - } - - /** - * Add an ascending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState smallestFirst() { - order.getSortOrders().get(order.getSortOrders().size() - 1).ascending(); - return new SortOrderState(order); - } - - /** - * Add an ascending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState largestLast() { - order.getSortOrders().get(order.getSortOrders().size() - 1).ascending(); - return new SortOrderState(order); - } - - /** - * Add a descending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState descending() { - order.getSortOrders().get(order.getSortOrders().size() - 1) - .descending(); - return new SortOrderState(order); - } - - /** - * Add a descending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState decreasing() { - order.getSortOrders().get(order.getSortOrders().size() - 1) - .descending(); - return new SortOrderState(order); - } - - /** - * Add a descending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState reversed() { - order.getSortOrders().get(order.getSortOrders().size() - 1) - .descending(); - return new SortOrderState(order); - } - - /** - * Add a descending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState largestFirst() { - order.getSortOrders().get(order.getSortOrders().size() - 1) - .descending(); - return new SortOrderState(order); - } - - /** - * Add a descending sort order to the {@link Order} that is building - * - * @return the builder - */ - public SortOrderState smallestLast() { - order.getSortOrders().get(order.getSortOrders().size() - 1) - .descending(); - return new SortOrderState(order); - } - - /** - * Adds a new {@link SortOrder} to sort by to the {@link Order} that is - * building. Adds an implicit Ascending sort order to the prior key - * - * @return the builder - */ - public ThenOrderState then(String key) { - order.add(new SortOrder(key)); - return new ThenOrderState(order); - } - -} \ No newline at end of file diff --git a/concourse-driver-java/src/test/java/com/cinchapi/concourse/lang/sort/OrderTest.java b/concourse-driver-java/src/test/java/com/cinchapi/concourse/lang/sort/OrderTest.java index 82bedbe235..fabfb2c3dc 100644 --- a/concourse-driver-java/src/test/java/com/cinchapi/concourse/lang/sort/OrderTest.java +++ b/concourse-driver-java/src/test/java/com/cinchapi/concourse/lang/sort/OrderTest.java @@ -15,12 +15,12 @@ */ package com.cinchapi.concourse.lang.sort; -import java.util.List; +import java.util.Map; import org.junit.Assert; import org.junit.Test; -import com.google.common.collect.Lists; +import com.google.common.collect.ImmutableMap; /** * Unit tests for the {@link com.cinchapi.concourse.lang.sort.Order} building @@ -30,59 +30,61 @@ public class OrderTest { @Test public void testDefaultSortOrder() { - List expected = Lists - .newArrayList(new SortOrder("foo", SortOrderType.ASCENDING)); + Map expected = ImmutableMap.of("foo", 1); Order order = Order.by("foo").build(); - Assert.assertEquals(expected, order.getSortOrders()); + Assert.assertEquals(expected, order.spec); } @Test public void testAscendingSortOrder() { - List expected = Lists - .newArrayList(new SortOrder("foo", SortOrderType.ASCENDING)); + Map expected = ImmutableMap.of("foo", 1); Order order = Order.by("foo").ascending().build(); - Assert.assertEquals(expected, order.getSortOrders()); + Assert.assertEquals(expected, order.spec); } @Test public void testDescendingSortOrder() { - List expected = Lists - .newArrayList(new SortOrder("foo", SortOrderType.DESCENDING)); + Map expected = ImmutableMap.of("foo", -1); Order order = Order.by("foo").descending().build(); - Assert.assertEquals(expected, order.getSortOrders()); + Assert.assertEquals(expected, order.spec); } @Test public void testMultipleSortKeysSortOrder() { - List expected = Lists.newArrayList( - new SortOrder("foo", SortOrderType.ASCENDING), - new SortOrder("bar", SortOrderType.ASCENDING)); - Order order = Order.by("foo").then("bar").ascending().build(); - Assert.assertEquals(expected, order.getSortOrders()); + Map expected = ImmutableMap.of("foo", 1, "bar", 1); + Order order = Order.by("foo").then().by("bar").ascending().build(); + Assert.assertEquals(expected, order.spec); } @Test public void testMultipleSortKeysWithImplicitSortOrders() { - List expected = Lists.newArrayList( - new SortOrder("foo", SortOrderType.ASCENDING), - new SortOrder("bar", SortOrderType.ASCENDING), - new SortOrder("zoo", SortOrderType.ASCENDING)); - Order order = Order.by("foo").then("bar").then("zoo").build(); - Assert.assertEquals(expected, order.getSortOrders()); + Map expected = ImmutableMap.of("foo", 1, "bar", 1, + "zoo", 1); + Order order = Order.by("foo").then().by("bar").then().by("zoo").build(); + Assert.assertEquals(expected, order.spec); } @Test(expected = IllegalStateException.class) public void testCannotAddSymbolToBuiltOrder() { Order order = Order.by("foo").build(); - order.add(new SortOrder("Bar", SortOrderType.ASCENDING)); + order.add("bar", Direction.ASCENDING); } @Test public void testAlias() { - List expected = Lists - .newArrayList(new SortOrder("foo", SortOrderType.ASCENDING)); + Map expected = ImmutableMap.of("foo", 1); Order order = Sort.by("foo").build(); - Assert.assertEquals(expected, order.getSortOrders()); + Assert.assertEquals(expected, order.spec); + } + + @Test + public void testComplexOrder() { + Order order = Sort.by("a").then().by("b").ascending().then().by("c") + .then().by("d").descending().then().by("e").largestFirst() + .build(); + Map expected = ImmutableMap.of("a", 1, "b", 1, "c", 1, + "d", -1, "e", -1); + Assert.assertEquals(expected, order.spec); } } From 9bfbce15617ffa5236370dfd05bb5ee61ee9450e Mon Sep 17 00:00:00 2001 From: Jeff Nelson Date: Sat, 6 Apr 2019 18:04:15 -0400 Subject: [PATCH 12/13] doc updates --- .../lang/sort/BuildableOrderState.java | 1 - .../cinchapi/concourse/lang/sort/Order.java | 34 +++++++++---------- .../lang/sort/OrderDirectionState.java | 10 ++++-- .../concourse/lang/sort/OrderState.java | 10 ++---- .../cinchapi/concourse/lang/sort/Sort.java | 6 ++-- 5 files changed, 32 insertions(+), 29 deletions(-) diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/BuildableOrderState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/BuildableOrderState.java index b17eb6c630..5bafa33243 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/BuildableOrderState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/BuildableOrderState.java @@ -18,7 +18,6 @@ /** * The base class for a Sort Order state that can be transformed into a complete * and well-formed {@link Order}. - * */ public abstract class BuildableOrderState extends OrderState { diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Order.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Order.java index 60287d83eb..cdf1068fac 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Order.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Order.java @@ -41,6 +41,16 @@ */ public final class Order { + /** + * Start building a new {@link Order}. + * + * @return the Order builder + */ + public static OrderByState by(String key) { + Order order = new Order(); + return new OrderByState(order, key, Direction.$default()); + } + /** * A mapping from each key to direction ordinal (e.g. 1 for ASC and -1 for * DESC) in the constructed {@link Order}. @@ -54,16 +64,6 @@ public final class Order { @Nullable protected String lastKey; - /** - * Start building a new {@link Order}. - * - * @return the Order builder - */ - public static OrderByState by(String key) { - Order order = new Order(); - return new OrderByState(order, key, Direction.$default()); - } - /** * A flag that indicates whether this {@link Order} has been built. */ @@ -91,6 +91,13 @@ public int hashCode() { return spec.hashCode(); } + /** + * Mark this {@link Order} as {@code built}. + */ + void close() { + built = !built ? true : built; + } + /** * Add to the order {@link #spec}. * @@ -103,11 +110,4 @@ final void add(String key, Direction direction) { this.lastKey = key; } - /** - * Mark this {@link Order} as {@code built}. - */ - protected void close() { - built = !built ? true : built; - } - } diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderDirectionState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderDirectionState.java index 7c10ab68c2..231c180d24 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderDirectionState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderDirectionState.java @@ -16,7 +16,8 @@ package com.cinchapi.concourse.lang.sort; /** - * + * A {@link State} that represents a building {@link Order} that just had + * direction information specified for the most recently added key. * * @author Jeff Nelson */ @@ -24,13 +25,18 @@ public class OrderDirectionState extends BuildableOrderState { /** * Construct a new instance. + * * @param order */ OrderDirectionState(Order order, String key, Direction direction) { super(order); order.add(key, direction); } - + + /** + * Specify a transition to adding a new key to the order. + * @return the builder + */ public OrderThenState then() { return new OrderThenState(order); } diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderState.java index 59ef7ef90c..1602fc0a68 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderState.java @@ -18,14 +18,10 @@ /** * This is the base class and marker for any valid state in the {@link Order} * builder. Each {@link OrderState} is passed the current {@link Order} and - * holds - * a reference. For any method called from the state, a {@link SortOrder} is - * added - * to the {@code Order} or the {@code Order} is returned. + * holds a reference. *

- * For the purposes of a builder, a {@link OrderState} typically describes what - * was - * most recently consumed. + * For the purposes of a builder, an {@link OrderState} typically describes what + * was most recently consumed. *

*/ public abstract class OrderState { diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Sort.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Sort.java index 546a64f5a5..fcc3ddf84c 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Sort.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/Sort.java @@ -18,8 +18,8 @@ /** * Serves as an alias for {@link Order} */ -public class Sort { - +public final class Sort { + /** * Start building a new {@link Order}. * @@ -29,4 +29,6 @@ public static OrderByState by(String key) { return Order.by(key); } + private Sort() {/* no-init */} + } From 270b1690659807f89ac576c970c5ef9d8561946f Mon Sep 17 00:00:00 2001 From: Jeff Nelson Date: Sat, 6 Apr 2019 18:05:24 -0400 Subject: [PATCH 13/13] fix formatting --- .../com/cinchapi/concourse/lang/sort/OrderDirectionState.java | 1 + 1 file changed, 1 insertion(+) diff --git a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderDirectionState.java b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderDirectionState.java index 231c180d24..b95aff6673 100644 --- a/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderDirectionState.java +++ b/concourse-driver-java/src/main/java/com/cinchapi/concourse/lang/sort/OrderDirectionState.java @@ -35,6 +35,7 @@ public class OrderDirectionState extends BuildableOrderState { /** * Specify a transition to adding a new key to the order. + * * @return the builder */ public OrderThenState then() {