#288

Build # #288

Build Type

push

Committed by

Commit Message

<a href="https://github.com/apache/datasketches-java/commit/<a class=hub.com/apache/datasketches-java/commit/a8c32170a2a8681407753566fee14f62b962a802">a8c32170a<a href="https://github.com/apache/datasketches-java/commit/a8c32170a2a8681407753566fee14f62b962a802">">Merge </a><a class="double-link" href="https://github.com/apache/datasketches-java/commit/<a class="double-link" href="https://github.com/apache/datasketches-java/commit/3a6f188ecdb349bfa904f9d21ead884e3500a3c8">3a6f188ec</a>">3a6f188ec</a><a href="https://github.com/apache/datasketches-java/commit/a8c32170a2a8681407753566fee14f62b962a802"> into a4893d35a">a4893d35a</a>

Run Details

1009 of 1009 new or added lines in 109 files covered. (100.0%)

19191 of 19555 relevant lines covered (98.14%)

0.98 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.17

/src/main/java/org/apache/datasketches/quantiles/ItemsUnion.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 org.apache.datasketches.quantiles;

import static org.apache.datasketches.Util.LS;

import java.util.Comparator;
import java.util.Objects;

import org.apache.datasketches.ArrayOfItemsSerDe;
import org.apache.datasketches.memory.Memory;

/**
 * The API for Union operations for generic ItemsSketches
 *
 * @param <T> type of item
 *
 * @author Lee Rhodes
 * @author Alexander Saydakov
 */
public final class ItemsUnion<T> {

  protected final int maxK_;
  protected final Comparator<? super T> comparator_;
  protected ItemsSketch<T> gadget_;
  protected Class<T> clazz_;

  private ItemsUnion(final int maxK, final Comparator<? super T> comparator, final ItemsSketch<T> gadget) {
    Objects.requireNonNull(gadget, "Gadjet sketch must not be null.");
    Objects.requireNonNull(comparator, "Comparator must not be null.");
    maxK_ = maxK;
    comparator_ = comparator;
    gadget_ = gadget;
    clazz_ = gadget.clazz;
    gadget_.classicQisSV = null;
  }

  /**
   * Create an instance of ItemsUnion with the default k
   * @param <T> The sketch data type
   * @param clazz The sketch class type
   * @param comparator to compare items
   * @return an instance of ItemsUnion
   */
  public static <T> ItemsUnion<T> getInstance(final Class<T> clazz, final Comparator<? super T> comparator) {
    final ItemsSketch<T> emptySk = ItemsSketch.getInstance(clazz, comparator);
    return new ItemsUnion<T>(PreambleUtil.DEFAULT_K, comparator, emptySk);
  }

  /**
   * Create an instance of ItemsUnion
   * @param clazz The sketch class type
   * @param <T> The sketch data type
   * @param maxK determines the accuracy and size of the union and is a maximum.
   * The effective <i>k</i> can be smaller due to unions with smaller <i>k</i> sketches.
   * It is recommended that <i>maxK</i> be a power of 2 to enable unioning of sketches with a
   * different <i>k</i>.
   * @param comparator to compare items
   * @return an instance of ItemsUnion
   */
  public static <T> ItemsUnion<T> getInstance(final Class<T> clazz, final int maxK,
      final Comparator<? super T> comparator) {
    final ItemsSketch<T> emptySk = ItemsSketch.getInstance(clazz, maxK, comparator);
    return new ItemsUnion<>(maxK, comparator, emptySk);
  }

  /**
   * Heapify the given srcMem into a Union object.
   * @param clazz The sketch class type
   * A reference to srcMem will not be maintained internally.
   * @param srcMem the given srcMem.
   * @param comparator to compare items
   * @param serDe an instance of ArrayOfItemsSerDe
   * @param <T> The sketch data type
   * @return an instance of ItemsUnion
   */
  public static <T> ItemsUnion<T> getInstance(final Class<T> clazz, final Memory srcMem,
      final Comparator<? super T> comparator, final ArrayOfItemsSerDe<T> serDe) {
    final ItemsSketch<T> gadget = ItemsSketch.getInstance(clazz, srcMem, comparator, serDe);
    return new ItemsUnion<>(gadget.getK(), gadget.getComparator(), gadget);
  }

  /**
   * Create an instance of ItemsUnion based on ItemsSketch
   * @param <T> The sketch data type
   * @param sketch the basis of the union
   * @return an instance of ItemsUnion
   */
  public static <T> ItemsUnion<T> getInstance(final ItemsSketch<T> sketch) {
    return new ItemsUnion<>(sketch.getK(), sketch.getComparator(), ItemsSketch.copy(sketch));
  }

  /**
   * Iterative union operation, which means this method can be repeatedly called.
   * Merges the given sketch into this union object.
   * The given sketch is not modified.
   * It is required that the ratio of the two K's be a power of 2.
   * This is easily satisfied if each of the K's are already a power of 2.
   * If the given sketch is null or empty it is ignored.
   *
   * <p>It is required that the results of the union operation, which can be obtained at any time,
   * is obtained from {@link #getResult() }.</p>
   *
   * @param sketchIn the sketch to be merged into this one.
   */
  public void union(final ItemsSketch<T> sketchIn) {
    gadget_ = updateLogic(maxK_, comparator_, gadget_, sketchIn);
  }

  /**
   * Iterative union operation, which means this method can be repeatedly called.
   * Merges the given Memory image of a ItemsSketch into this union object.
   * The given Memory object is not modified and a link to it is not retained.
   * It is required that the ratio of the two K's be a power of 2.
   * This is easily satisfied if each of the K's are already a power of 2.
   * If the given sketch is null or empty it is ignored.
   *
   * <p>It is required that the results of the union operation, which can be obtained at any time,
   * is obtained from {@link #getResult() }.</p>
   * @param srcMem Memory image of sketch to be merged
   * @param serDe an instance of ArrayOfItemsSerDe
   */
  public void union(final Memory srcMem, final ArrayOfItemsSerDe<T> serDe) { //TODO rename merge
    final ItemsSketch<T> that = ItemsSketch.getInstance(this.clazz_, srcMem, comparator_, serDe);
    gadget_ = updateLogic(maxK_, comparator_, gadget_, that);
  }

  /**
   * Update this union with the given double (or float) data Item.
   *
   * @param dataItem The given datum.
   */
  public void update(final T dataItem) {
    if (dataItem == null) { return; }
    if (gadget_ == null) {
      gadget_ = ItemsSketch.getInstance(this.clazz_, maxK_, comparator_);
    }
    gadget_.update(dataItem);
  }

  /**
   * Gets the result of this Union operation as a copy of the internal state.
   * This enables further union update operations on this state.
   * @return the result of this Union operation
   */
  public ItemsSketch<T> getResult() {
    if (gadget_ == null) {
      return ItemsSketch.getInstance(this.clazz_, maxK_, comparator_);
    }
    return ItemsSketch.copy(gadget_); //can't have any externally owned handles.
  }

  /**
   * Gets the result of this Union operation (without a copy) and resets this Union to the
   * virgin state.
   *
   * @return the result of this Union operation and reset.
   */
  public ItemsSketch<T> getResultAndReset() {
    if (gadget_ == null) { return null; } //Intentionally return null here for speed.
    final ItemsSketch<T> hqs = gadget_;
    gadget_ = null;
    return hqs;
  }

  /**
   * Resets this Union to a virgin state.
   * Keeps maxK, comparator and clazz
   */
  public void reset() {
    gadget_ = null;
  }

  /**
   * Returns true if this union is empty
   * @return true if this union is empty
   */
  public boolean isEmpty() {
    return (gadget_ == null) || gadget_.isEmpty();
  }

  /**
   * Returns true if this union is direct
   * @return true if this union is direct
   */
  public boolean isDirect() {
    return (gadget_ != null) && gadget_.isDirect();
  }

  /**
   * Returns the configured <i>maxK</i> of this Union.
   * @return the configured <i>maxK</i> of this Union.
   */
  public int getMaxK() {
    return maxK_;
  }

  /**
   * Returns the effective <i>k</i> of this Union.
   * @return the effective <i>k</i> of this Union.
   */
  public int getEffectiveK() {
    return (gadget_ != null) ? gadget_.getK() : maxK_;
  }

  /**
   * Returns summary information about the backing sketch.
   */
  @Override
  public String toString() {
    return toString(true, false);
  }

  /**
   * Returns summary information about the backing sketch. Used for debugging.
   * @param sketchSummary if true includes sketch summary
   * @param dataDetail if true includes data detail
   * @return summary information about the sketch.
   */
  public String toString(final boolean sketchSummary, final boolean dataDetail) {
    final StringBuilder sb = new StringBuilder();
    final String thisSimpleName = this.getClass().getSimpleName();
    final int maxK = this.getMaxK();
    final String kStr = String.format("%,d", maxK);
    sb.append(ClassicUtil.LS).append("### Quantiles ").append(thisSimpleName).append(LS);
    sb.append("   maxK                         : ").append(kStr);
    if (gadget_ == null) {
      sb.append(ItemsSketch.getInstance(this.clazz_, maxK_, comparator_).toString());
      return sb.toString();
    }
    sb.append(gadget_.toString(sketchSummary, dataDetail));
    return sb.toString();
  }

  /**
   * Serialize this union to a byte array. Result is an ItemsSketch, serialized in an
   * unordered, non-compact form. The resulting byte[] can be passed to getInstance for either a
   * sketch or union.
   *
   * @param serDe an instance of ArrayOfItemsSerDe
   * @return byte array of this union
   */
  public byte[] toByteArray(final ArrayOfItemsSerDe<T> serDe) {
    if (gadget_ == null) {
      final ItemsSketch<T> sketch = ItemsSketch.getInstance(this.clazz_, maxK_, comparator_);
      return sketch.toByteArray(serDe);
    }
    return gadget_.toByteArray(serDe);
  }

  //@formatter:off
  @SuppressWarnings("unchecked")
  static <T> ItemsSketch<T> updateLogic(final int myMaxK, final Comparator<? super T> comparator,
      final ItemsSketch<T> myQS, final ItemsSketch<T> other) {
    int sw1 = ((myQS   == null) ? 0 :   myQS.isEmpty() ? 4 : 8);
    sw1 |=    ((other  == null) ? 0 :  other.isEmpty() ? 1 : 2);
    int outCase = 0; //0=null, 1=NOOP, 2=copy, 3=merge
    switch (sw1) {
      case 0:  outCase = 0; break; //myQS = null,  other = null ; return null
      case 1:  outCase = 4; break; //myQS = null,  other = empty; create empty-heap(myMaxK)
      case 2:  outCase = 2; break; //myQS = null,  other = valid; stream or downsample to myMaxK
      case 4:  outCase = 1; break; //myQS = empty, other = null ; no-op
      case 5:  outCase = 1; break; //myQS = empty, other = empty; no-op
      case 6:  outCase = 3; break; //myQS = empty, other = valid; merge
      case 8:  outCase = 1; break; //myQS = valid, other = null ; no-op
      case 9:  outCase = 1; break; //myQS = valid, other = empty: no-op
      case 10: outCase = 3; break; //myQS = valid, other = valid; merge
      //default: //This cannot happen and cannot be tested
    }
    ItemsSketch<T> ret = null;
    switch (outCase) {
      case 0: ret = null; break;
      case 1: ret = myQS; break;
      case 2: { //myQS = null,  other = valid; stream or downsample to myMaxK
        assert other != null;
        if (!other.isEstimationMode()) { //other is exact, stream items in
          ret = ItemsSketch.getInstance(other.getSketchType(), myMaxK, comparator);
          final int otherCnt = other.getBaseBufferCount();
          final Object[] combBuf = other.getCombinedBuffer();
          for (int i = 0; i < otherCnt; i++) {
            ret.update((T) combBuf[i]);
          }
        }
        else { //myQS = null, other is est mode
          ret = (myMaxK < other.getK())
              ? other.downSample(myMaxK)
              : ItemsSketch.copy(other); //required because caller has handle
        }
        break;
      }
      case 3: { //myQS = empty/valid, other = valid; merge
        assert other != null;
        assert myQS != null;
        if (!other.isEstimationMode()) { //other is exact, stream items in
          ret = myQS;
          final int otherCnt = other.getBaseBufferCount();
          final Object[] combBuf = other.getCombinedBuffer();
          for (int i = 0; i < otherCnt; i++) {
            ret.update((T) combBuf[i]);
          }
        }
        else { //myQS = empty/valid, other = valid and in est mode
          if (myQS.getK() <= other.getK()) { //I am smaller or equal, thus the target
            ItemsMergeImpl.mergeInto(other, myQS);
            ret = myQS;
          }
          else { //Bigger: myQS.getK() > other.getK(), must reverse roles
            //must copy other as it will become mine and can't have any externally owned handles.
            ret = ItemsSketch.copy(other);
            ItemsMergeImpl.mergeInto(myQS, ret);
          }
        }
        break;
      }
      case 4: {
        assert other != null;
        ret = ItemsSketch.getInstance(other.getSketchType(), Math.min(myMaxK, other.getK()), comparator);
        break;
      }
      //default: //This cannot happen and cannot be tested
    }
    return ret;
  }
  //@formatter:on

}

1	/*
2	* Licensed to the Apache Software Foundation (ASF) under one
3	* or more contributor license agreements. See the NOTICE file
4	* distributed with this work for additional information
5	* regarding copyright ownership. The ASF licenses this file
6	* to you under the Apache License, Version 2.0 (the
7	* "License"); you may not use this file except in compliance
8	* with the License. You may obtain a copy of the License at
9	*
10	* http://www.apache.org/licenses/LICENSE-2.0
11	*
12	* Unless required by applicable law or agreed to in writing,
13	* software distributed under the License is distributed on an
14	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15	* KIND, either express or implied. See the License for the
16	* specific language governing permissions and limitations
17	* under the License.
18	*/
19
20	package org.apache.datasketches.quantiles;
21
22	import static org.apache.datasketches.Util.LS;
23
24	import java.util.Comparator;
25	import java.util.Objects;
26
27	import org.apache.datasketches.ArrayOfItemsSerDe;
28	import org.apache.datasketches.memory.Memory;
29
30	/**
31	* The API for Union operations for generic ItemsSketches
32	*
33	* @param <T> type of item
34	*
35	* @author Lee Rhodes
36	* @author Alexander Saydakov
37	*/
38	public final class ItemsUnion<T> {	1✔
39
40	protected final int maxK_;
41	protected final Comparator<? super T> comparator_;
42	protected ItemsSketch<T> gadget_;
43	protected Class<T> clazz_;
44
45	private ItemsUnion(final int maxK, final Comparator<? super T> comparator, final ItemsSketch<T> gadget) {	1✔
46	Objects.requireNonNull(gadget, "Gadjet sketch must not be null.");	1✔
47	Objects.requireNonNull(comparator, "Comparator must not be null.");	1✔
48	maxK_ = maxK;	1✔
49	comparator_ = comparator;	1✔
50	gadget_ = gadget;	1✔
51	clazz_ = gadget.clazz;	1✔
52	gadget_.classicQisSV = null;	1✔
53	}	1✔
54
55	/**
56	* Create an instance of ItemsUnion with the default k
57	* @param <T> The sketch data type
58	* @param clazz The sketch class type
59	* @param comparator to compare items
60	* @return an instance of ItemsUnion
61	*/
62	public static <T> ItemsUnion<T> getInstance(final Class<T> clazz, final Comparator<? super T> comparator) {
63	final ItemsSketch<T> emptySk = ItemsSketch.getInstance(clazz, comparator);	1✔
64	return new ItemsUnion<T>(PreambleUtil.DEFAULT_K, comparator, emptySk);	1✔
65	}
66
67	/**
68	* Create an instance of ItemsUnion
69	* @param clazz The sketch class type
70	* @param <T> The sketch data type
71	* @param maxK determines the accuracy and size of the union and is a maximum.
72	* The effective <i>k</i> can be smaller due to unions with smaller <i>k</i> sketches.
73	* It is recommended that <i>maxK</i> be a power of 2 to enable unioning of sketches with a
74	* different <i>k</i>.
75	* @param comparator to compare items
76	* @return an instance of ItemsUnion
77	*/
78	public static <T> ItemsUnion<T> getInstance(final Class<T> clazz, final int maxK,
79	final Comparator<? super T> comparator) {
80	final ItemsSketch<T> emptySk = ItemsSketch.getInstance(clazz, maxK, comparator);	1✔
81	return new ItemsUnion<>(maxK, comparator, emptySk);	1✔
82	}
83
84	/**
85	* Heapify the given srcMem into a Union object.
86	* @param clazz The sketch class type
87	* A reference to srcMem will not be maintained internally.
88	* @param srcMem the given srcMem.
89	* @param comparator to compare items
90	* @param serDe an instance of ArrayOfItemsSerDe
91	* @param <T> The sketch data type
92	* @return an instance of ItemsUnion
93	*/
94	public static <T> ItemsUnion<T> getInstance(final Class<T> clazz, final Memory srcMem,
95	final Comparator<? super T> comparator, final ArrayOfItemsSerDe<T> serDe) {
96	final ItemsSketch<T> gadget = ItemsSketch.getInstance(clazz, srcMem, comparator, serDe);	1✔
97	return new ItemsUnion<>(gadget.getK(), gadget.getComparator(), gadget);	1✔
98	}
99
100	/**
101	* Create an instance of ItemsUnion based on ItemsSketch
102	* @param <T> The sketch data type
103	* @param sketch the basis of the union
104	* @return an instance of ItemsUnion
105	*/
106	public static <T> ItemsUnion<T> getInstance(final ItemsSketch<T> sketch) {
107	return new ItemsUnion<>(sketch.getK(), sketch.getComparator(), ItemsSketch.copy(sketch));	1✔
108	}
109
110	/**
111	* Iterative union operation, which means this method can be repeatedly called.
112	* Merges the given sketch into this union object.
113	* The given sketch is not modified.
114	* It is required that the ratio of the two K's be a power of 2.
115	* This is easily satisfied if each of the K's are already a power of 2.
116	* If the given sketch is null or empty it is ignored.
117	*
118	* <p>It is required that the results of the union operation, which can be obtained at any time,
119	* is obtained from {@link #getResult() }.</p>
120	*
121	* @param sketchIn the sketch to be merged into this one.
122	*/
123	public void union(final ItemsSketch<T> sketchIn) {
124	gadget_ = updateLogic(maxK_, comparator_, gadget_, sketchIn);	1✔
125	}	1✔
126
127	/**
128	* Iterative union operation, which means this method can be repeatedly called.
129	* Merges the given Memory image of a ItemsSketch into this union object.
130	* The given Memory object is not modified and a link to it is not retained.
131	* It is required that the ratio of the two K's be a power of 2.
132	* This is easily satisfied if each of the K's are already a power of 2.
133	* If the given sketch is null or empty it is ignored.
134	*
135	* <p>It is required that the results of the union operation, which can be obtained at any time,
136	* is obtained from {@link #getResult() }.</p>
137	* @param srcMem Memory image of sketch to be merged
138	* @param serDe an instance of ArrayOfItemsSerDe
139	*/
140	public void union(final Memory srcMem, final ArrayOfItemsSerDe<T> serDe) { //TODO rename merge
141	final ItemsSketch<T> that = ItemsSketch.getInstance(this.clazz_, srcMem, comparator_, serDe);	1✔
142	gadget_ = updateLogic(maxK_, comparator_, gadget_, that);	1✔
143	}	1✔
144
145	/**
146	* Update this union with the given double (or float) data Item.
147	*
148	* @param dataItem The given datum.
149	*/
150	public void update(final T dataItem) {
151	if (dataItem == null) { return; }	1✔
152	if (gadget_ == null) {	1✔
153	gadget_ = ItemsSketch.getInstance(this.clazz_, maxK_, comparator_);	×
154	}
155	gadget_.update(dataItem);	1✔
156	}	1✔
157
158	/**
159	* Gets the result of this Union operation as a copy of the internal state.
160	* This enables further union update operations on this state.
161	* @return the result of this Union operation
162	*/
163	public ItemsSketch<T> getResult() {
164	if (gadget_ == null) {	1✔
165	return ItemsSketch.getInstance(this.clazz_, maxK_, comparator_);	1✔
166	}
167	return ItemsSketch.copy(gadget_); //can't have any externally owned handles.	1✔
168	}
169
170	/**
171	* Gets the result of this Union operation (without a copy) and resets this Union to the
172	* virgin state.
173	*
174	* @return the result of this Union operation and reset.
175	*/
176	public ItemsSketch<T> getResultAndReset() {
177	if (gadget_ == null) { return null; } //Intentionally return null here for speed.	1✔
178	final ItemsSketch<T> hqs = gadget_;	1✔
179	gadget_ = null;	1✔
180	return hqs;	1✔
181	}
182
183	/**
184	* Resets this Union to a virgin state.
185	* Keeps maxK, comparator and clazz
186	*/
187	public void reset() {
188	gadget_ = null;	1✔
189	}	1✔
190
191	/**
192	* Returns true if this union is empty
193	* @return true if this union is empty
194	*/
195	public boolean isEmpty() {
196	return (gadget_ == null) \|\| gadget_.isEmpty();	1✔
197	}
198
199	/**
200	* Returns true if this union is direct
201	* @return true if this union is direct
202	*/
203	public boolean isDirect() {
204	return (gadget_ != null) && gadget_.isDirect();	1✔
205	}
206
207	/**
208	* Returns the configured <i>maxK</i> of this Union.
209	* @return the configured <i>maxK</i> of this Union.
210	*/
211	public int getMaxK() {
212	return maxK_;	1✔
213	}
214
215	/**
216	* Returns the effective <i>k</i> of this Union.
217	* @return the effective <i>k</i> of this Union.
218	*/
219	public int getEffectiveK() {
220	return (gadget_ != null) ? gadget_.getK() : maxK_;	1✔
221	}
222
223	/**
224	* Returns summary information about the backing sketch.
225	*/
226	@Override
227	public String toString() {
228	return toString(true, false);	1✔
229	}
230
231	/**
232	* Returns summary information about the backing sketch. Used for debugging.
233	* @param sketchSummary if true includes sketch summary
234	* @param dataDetail if true includes data detail
235	* @return summary information about the sketch.
236	*/
237	public String toString(final boolean sketchSummary, final boolean dataDetail) {
238	final StringBuilder sb = new StringBuilder();	1✔
239	final String thisSimpleName = this.getClass().getSimpleName();	1✔
240	final int maxK = this.getMaxK();	1✔
241	final String kStr = String.format("%,d", maxK);	1✔
242	sb.append(ClassicUtil.LS).append("### Quantiles ").append(thisSimpleName).append(LS);	1✔
243	sb.append(" maxK : ").append(kStr);	1✔
244	if (gadget_ == null) {	1✔
245	sb.append(ItemsSketch.getInstance(this.clazz_, maxK_, comparator_).toString());	×
246	return sb.toString();	×
247	}
248	sb.append(gadget_.toString(sketchSummary, dataDetail));	1✔
249	return sb.toString();	1✔
250	}
251
252	/**
253	* Serialize this union to a byte array. Result is an ItemsSketch, serialized in an
254	* unordered, non-compact form. The resulting byte[] can be passed to getInstance for either a
255	* sketch or union.
256	*
257	* @param serDe an instance of ArrayOfItemsSerDe
258	* @return byte array of this union
259	*/
260	public byte[] toByteArray(final ArrayOfItemsSerDe<T> serDe) {
261	if (gadget_ == null) {	1✔
262	final ItemsSketch<T> sketch = ItemsSketch.getInstance(this.clazz_, maxK_, comparator_);	×
263	return sketch.toByteArray(serDe);	×
264	}
265	return gadget_.toByteArray(serDe);	1✔
266	}
267
268	//@formatter:off
269	@SuppressWarnings("unchecked")
270	static <T> ItemsSketch<T> updateLogic(final int myMaxK, final Comparator<? super T> comparator,
271	final ItemsSketch<T> myQS, final ItemsSketch<T> other) {
272	int sw1 = ((myQS == null) ? 0 : myQS.isEmpty() ? 4 : 8);	1✔
273	sw1 \|= ((other == null) ? 0 : other.isEmpty() ? 1 : 2);	1✔
274	int outCase = 0; //0=null, 1=NOOP, 2=copy, 3=merge	1✔
275	switch (sw1) {	1✔
276	case 0: outCase = 0; break; //myQS = null, other = null ; return null	1✔
277	case 1: outCase = 4; break; //myQS = null, other = empty; create empty-heap(myMaxK)	1✔
278	case 2: outCase = 2; break; //myQS = null, other = valid; stream or downsample to myMaxK	1✔
279	case 4: outCase = 1; break; //myQS = empty, other = null ; no-op	1✔
280	case 5: outCase = 1; break; //myQS = empty, other = empty; no-op	1✔
281	case 6: outCase = 3; break; //myQS = empty, other = valid; merge	1✔
282	case 8: outCase = 1; break; //myQS = valid, other = null ; no-op	1✔
283	case 9: outCase = 1; break; //myQS = valid, other = empty: no-op	1✔
284	case 10: outCase = 3; break; //myQS = valid, other = valid; merge	1✔
285	//default: //This cannot happen and cannot be tested
286	}
287	ItemsSketch<T> ret = null;	1✔
288	switch (outCase) {	1✔
289	case 0: ret = null; break;	1✔
290	case 1: ret = myQS; break;	1✔
291	case 2: { //myQS = null, other = valid; stream or downsample to myMaxK
292	assert other != null;	1✔
293	if (!other.isEstimationMode()) { //other is exact, stream items in	1✔
294	ret = ItemsSketch.getInstance(other.getSketchType(), myMaxK, comparator);	1✔
295	final int otherCnt = other.getBaseBufferCount();	1✔
296	final Object[] combBuf = other.getCombinedBuffer();	1✔
297	for (int i = 0; i < otherCnt; i++) {	1✔
298	ret.update((T) combBuf[i]);	1✔
299	}
300	}	1✔
301	else { //myQS = null, other is est mode
302	ret = (myMaxK < other.getK())	1✔
303	? other.downSample(myMaxK)	×
304	: ItemsSketch.copy(other); //required because caller has handle	1✔
305	}
306	break;	1✔
307	}
308	case 3: { //myQS = empty/valid, other = valid; merge
309	assert other != null;	1✔
310	assert myQS != null;	1✔
311	if (!other.isEstimationMode()) { //other is exact, stream items in	1✔
312	ret = myQS;	1✔
313	final int otherCnt = other.getBaseBufferCount();	1✔
314	final Object[] combBuf = other.getCombinedBuffer();	1✔
315	for (int i = 0; i < otherCnt; i++) {	1✔
316	ret.update((T) combBuf[i]);	1✔
317	}
318	}	1✔
319	else { //myQS = empty/valid, other = valid and in est mode
320	if (myQS.getK() <= other.getK()) { //I am smaller or equal, thus the target	1✔
321	ItemsMergeImpl.mergeInto(other, myQS);	1✔
322	ret = myQS;	1✔
323	}
324	else { //Bigger: myQS.getK() > other.getK(), must reverse roles
325	//must copy other as it will become mine and can't have any externally owned handles.
326	ret = ItemsSketch.copy(other);	1✔
327	ItemsMergeImpl.mergeInto(myQS, ret);	1✔
328	}
329	}
330	break;	1✔
331	}
332	case 4: {
333	assert other != null;	1✔
334	ret = ItemsSketch.getInstance(other.getSketchType(), Math.min(myMaxK, other.getK()), comparator);	1✔
335	break;
336	}
337	//default: //This cannot happen and cannot be tested
338	}
339	return ret;	1✔
340	}
341	//@formatter:on
342
343	}

apache / datasketches-java / #288

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous