MtasDataCollector.java

  1. package mtas.codec.util.collector;

  3. import java.io.IOException;
  4. import java.io.Serializable;
  5. import java.util.ArrayList;
  6. import java.util.Arrays;
  7. import java.util.Collection;
  8. import java.util.HashMap;
  9. import java.util.HashSet;
  10. import java.util.LinkedHashMap;
  11. import java.util.Map;
  12. import java.util.Set;
  13. import java.util.SortedMap;
  14. import java.util.SortedSet;
  15. import java.util.TreeMap;
  16. import java.util.Map.Entry;

  18. import mtas.codec.util.DataCollector;

  20. /**
  21.  * The Class MtasDataCollector.
  22.  *
  23.  * @param <T1> the generic type
  24.  * @param <T2> the generic type
  25.  */
  26. public abstract class MtasDataCollector<T1 extends Number & Comparable<T1>, T2 extends Number & Comparable<T2>>
  27.     implements Serializable {

  29.   /** The Constant serialVersionUID. */
  30.   private static final long serialVersionUID = 1L;

  32.   /** The Constant SEGMENT_SORT_ASC. */
  33.   public static final String SEGMENT_SORT_ASC = "segment_asc";

  35.   /** The Constant SEGMENT_SORT_DESC. */
  36.   public static final String SEGMENT_SORT_DESC = "segment_desc";

  38.   /** The Constant SEGMENT_BOUNDARY_ASC. */
  39.   public static final String SEGMENT_BOUNDARY_ASC = "segment_boundary_asc";

  41.   /** The Constant SEGMENT_BOUNDARY_DESC. */
  42.   public static final String SEGMENT_BOUNDARY_DESC = "segment_boundary_desc";

  44.   /** The Constant SEGMENT_KEY. */
  45.   public static final String SEGMENT_KEY = "key";

  47.   /** The Constant SEGMENT_NEW. */
  48.   public static final String SEGMENT_NEW = "new";

  50.   /** The Constant SEGMENT_KEY_OR_NEW. */
  51.   public static final String SEGMENT_KEY_OR_NEW = "key_or_new";

  53.   /** The Constant SEGMENT_POSSIBLE_KEY. */
  54.   public static final String SEGMENT_POSSIBLE_KEY = "possible_key";

  56.   /** The size. */
  57.   protected int size;

  59.   /** The position. */
  60.   protected int position;

  62.   /** The collector type. */
  63.   // properties collector
  64.   protected String collectorType;

  66.   /** The stats type. */
  67.   protected String statsType;

  69.   /** The data type. */
  70.   protected String dataType;

  72.   /** The stats items. */
  73.   private SortedSet<String> statsItems;

  75.   /** The sort type. */
  76.   protected String sortType;

  78.   /** The sort direction. */
  79.   protected String sortDirection;

  81.   /** The start. */
  82.   protected Integer start;

  84.   /** The number. */
  85.   protected Integer number;

  87.   /** The error number. */
  88.   // error
  89.   protected int[] errorNumber;

  91.   /** The error list. */
  92.   protected HashMap<String, Integer>[] errorList;

  94.   /** The key list. */
  95.   protected String[] keyList;

  97.   /** The source number list. */
  98.   protected int[] sourceNumberList;

  100.   /** The with total. */
  101.   private boolean withTotal;

  103.   /** The segment registration. */
  104.   public transient String segmentRegistration;

  106.   /** The segment key value list. */
  107.   protected transient LinkedHashMap<String, Map<String, T1>> segmentKeyValueList;

  109.   /** The segment recompute key list. */
  110.   public transient Map<String, Set<String>> segmentRecomputeKeyList;

  112.   /** The segment keys. */
  113.   public transient Set<String> segmentKeys;

  115.   /** The segment values boundary. */
  116.   protected transient Map<String, T1> segmentValuesBoundary;

  118.   /** The segment value boundary. */
  119.   protected transient T1 segmentValueBoundary;

  121.   /** The segment value top list last. */
  122.   protected transient Map<String, T1> segmentValueTopListLast;

  124.   /** The segment value top list. */
  125.   protected transient ArrayList<T1> segmentValueTopList;

  127.   /** The segment name. */
  128.   protected transient String segmentName;

  130.   /** The segment number. */
  131.   protected transient int segmentNumber;

  133.   /** The has sub. */
  134.   private boolean hasSub;

  136.   /** The sub collector types. */
  137.   private String[] subCollectorTypes;

  139.   /** The sub data types. */
  140.   private String[] subDataTypes;

  142.   /** The sub stats types. */
  143.   private String[] subStatsTypes;

  145.   /** The sub stats items. */
  146.   private SortedSet<String>[] subStatsItems;

  148.   /** The sub sort types. */
  149.   private String[] subSortTypes;

  151.   /** The sub sort directions. */
  152.   private String[] subSortDirections;

  154.   /** The sub start. */
  155.   private Integer[] subStart;

  157.   /** The sub number. */
  158.   private Integer[] subNumber;

  160.   /** The sub collector list next level. */
  161.   protected MtasDataCollector<?, ?>[] subCollectorListNextLevel = null;

  163.   /** The sub collector next level. */
  164.   protected MtasDataCollector<?, ?> subCollectorNextLevel = null;

  166.   /** The new size. */
  167.   protected transient int newSize;

  169.   /** The new position. */
  170.   protected transient int newPosition;

  172.   /** The new current position. */
  173.   protected transient int newCurrentPosition;

  175.   /** The new current existing. */
  176.   protected transient boolean newCurrentExisting;

  178.   /** The new key list. */
  179.   protected transient String[] newKeyList = null;

  181.   /** The new source number list. */
  182.   protected transient int[] newSourceNumberList = null;

  184.   /** The new error number. */
  185.   protected transient int[] newErrorNumber;

  187.   /** The new error list. */
  188.   protected transient HashMap<String, Integer>[] newErrorList;

  190.   /** The new known key found in segment. */
  191.   public transient Set<String> newKnownKeyFoundInSegment;

  193.   /** The new sub collector types. */
  194.   private transient String[] newSubCollectorTypes;

  196.   /** The new sub data types. */
  197.   private transient String[] newSubDataTypes;

  199.   /** The new sub stats types. */
  200.   private transient String[] newSubStatsTypes;

  202.   /** The new sub stats items. */
  203.   private transient SortedSet<String>[] newSubStatsItems;

  205.   /** The new sub sort types. */
  206.   private transient String[] newSubSortTypes;

  208.   /** The new sub sort directions. */
  209.   private transient String[] newSubSortDirections;

  211.   /** The new sub start. */
  212.   private transient Integer[] newSubStart;

  214.   /** The new sub number. */
  215.   private transient Integer[] newSubNumber;

  217.   /** The new sub collector list next level. */
  218.   // subcollectors next level for adding
  219.   protected transient MtasDataCollector<?, ?>[] newSubCollectorListNextLevel = null;

  221.   /** The new sub collector next level. */
  222.   protected transient MtasDataCollector<?, ?> newSubCollectorNextLevel = null;

  224.   /** The closed. */
  225.   protected transient boolean closed = false;

  227.   /** The result. */
  228.   private transient MtasDataCollectorResult<T1, T2> result = null;

  230.   /**
  231.    * Instantiates a new mtas data collector.
  232.    *
  233.    * @param collectorType the collector type
  234.    * @param dataType the data type
  235.    * @param statsType the stats type
  236.    * @param statsItems the stats items
  237.    * @param sortType the sort type
  238.    * @param sortDirection the sort direction
  239.    * @param start the start
  240.    * @param number the number
  241.    * @param segmentRegistration the segment registration
  242.    * @param boundary the boundary
  243.    * @throws IOException Signals that an I/O exception has occurred.
  244.    */
  245.   @SuppressWarnings("unchecked")
  246.   protected MtasDataCollector(String collectorType, String dataType,
  247.       String statsType, SortedSet<String> statsItems, String sortType,
  248.       String sortDirection, Integer start, Integer number,
  249.       String segmentRegistration, String boundary) throws IOException {
  250.     // set properties
  251.     this.closed = false;
  252.     this.collectorType = collectorType; // data or list
  253.     this.dataType = dataType; // long or double
  254.     this.statsType = statsType; // basic, advanced or full
  255.     this.statsItems = statsItems; // sum, n, all, ...
  256.     this.sortType = sortType;
  257.     this.sortDirection = sortDirection;
  258.     this.start = start;
  259.     this.number = number;
  260.     this.segmentRegistration = segmentRegistration;
  261.     this.withTotal = false;
  262.     if (segmentRegistration != null) {
  263.       segmentKeys = new HashSet<>();
  264.       segmentKeyValueList = new LinkedHashMap<>();
  265.       segmentValuesBoundary = new LinkedHashMap<>();
  266.       segmentValueTopListLast = new LinkedHashMap<>();
  267.       if (segmentRegistration.equals(SEGMENT_BOUNDARY_ASC)
  268.           || segmentRegistration.equals(SEGMENT_BOUNDARY_DESC)) {
  269.         if (boundary != null) {
  270.           segmentValueBoundary = stringToBoundary(boundary);
  271.         } else {
  272.           throw new IOException("did expect boundary with segmentRegistration "
  273.               + segmentRegistration);
  274.         }
  275.       } else if (boundary != null) {
  276.         throw new IOException("didn't expect boundary with segmentRegistration "
  277.             + segmentRegistration);
  278.       }
  279.     }
  280.     // initialize administration
  281.     keyList = new String[0];
  282.     sourceNumberList = new int[0];
  283.     errorNumber = new int[0];
  284.     errorList = (HashMap<String, Integer>[]) new HashMap<?, ?>[0];
  285.     size = 0;
  286.     position = 0;
  287.     // subCollectors properties
  288.     hasSub = false;
  289.     subCollectorTypes = null;
  290.     subDataTypes = null;
  291.     subStatsTypes = null;
  292.     subStatsItems = null;
  293.     subSortTypes = null;
  294.     subSortDirections = null;
  295.     subStart = null;
  296.     subNumber = null;
  297.     subCollectorListNextLevel = null;
  298.     subCollectorNextLevel = null;
  299.   }

  301.   /**
  302.    * Instantiates a new mtas data collector.
  303.    *
  304.    * @param collectorType the collector type
  305.    * @param dataType the data type
  306.    * @param statsType the stats type
  307.    * @param statsItems the stats items
  308.    * @param sortType the sort type
  309.    * @param sortDirection the sort direction
  310.    * @param start the start
  311.    * @param number the number
  312.    * @param subCollectorTypes the sub collector types
  313.    * @param subDataTypes the sub data types
  314.    * @param subStatsTypes the sub stats types
  315.    * @param subStatsItems the sub stats items
  316.    * @param subSortTypes the sub sort types
  317.    * @param subSortDirections the sub sort directions
  318.    * @param subStart the sub start
  319.    * @param subNumber the sub number
  320.    * @param segmentRegistration the segment registration
  321.    * @param boundary the boundary
  322.    * @throws IOException Signals that an I/O exception has occurred.
  323.    */
  324.   protected MtasDataCollector(String collectorType, String dataType,
  325.       String statsType, SortedSet<String> statsItems, String sortType,
  326.       String sortDirection, Integer start, Integer number,
  327.       String[] subCollectorTypes, String[] subDataTypes, String[] subStatsTypes,
  328.       SortedSet<String>[] subStatsItems, String[] subSortTypes,
  329.       String[] subSortDirections, Integer[] subStart, Integer[] subNumber,
  330.       String segmentRegistration, String boundary) throws IOException {
  331.     // initialize
  332.     this(collectorType, dataType, statsType, statsItems, sortType,
  333.         sortDirection, start, number, segmentRegistration, boundary);
  334.     // initialize subCollectors
  335.     if (subCollectorTypes != null) {
  336.       hasSub = true;
  337.       this.subCollectorTypes = subCollectorTypes;
  338.       this.subDataTypes = subDataTypes;
  339.       this.subStatsTypes = subStatsTypes;
  340.       this.subStatsItems = subStatsItems;
  341.       this.subSortTypes = subSortTypes;
  342.       this.subSortDirections = subSortDirections;
  343.       this.subStart = subStart;
  344.       this.subNumber = subNumber;
  345.       if (subCollectorTypes.length > 1) {
  346.         newSubCollectorTypes = Arrays.copyOfRange(subCollectorTypes, 1,
  347.             subCollectorTypes.length);
  348.         newSubDataTypes = Arrays.copyOfRange(subDataTypes, 1,
  349.             subStatsTypes.length);
  350.         newSubStatsTypes = Arrays.copyOfRange(subStatsTypes, 1,
  351.             subStatsTypes.length);
  352.         newSubStatsItems = Arrays.copyOfRange(subStatsItems, 1,
  353.             subStatsItems.length);
  354.         newSubSortTypes = Arrays.copyOfRange(subSortTypes, 1,
  355.             subSortTypes.length);
  356.         newSubSortDirections = Arrays.copyOfRange(subSortDirections, 1,
  357.             subSortDirections.length);
  358.         newSubStart = Arrays.copyOfRange(subStart, 1, subStart.length);
  359.         newSubNumber = Arrays.copyOfRange(subNumber, 1, subNumber.length);
  360.       }
  361.       newSubCollectorListNextLevel = new MtasDataCollector[0];
  362.     }
  363.   }

  365.   /**
  366.    * Merge.
  367.    *
  368.    * @param newDataCollector the new data collector
  369.    * @param map the map
  370.    * @param increaseSourceNumber the increase source number
  371.    * @throws IOException Signals that an I/O exception has occurred.
  372.    */
  373.   abstract public void merge(MtasDataCollector<?, ?> newDataCollector,
  374.       Map<MtasDataCollector<?, ?>, MtasDataCollector<?, ?>> map,
  375.       boolean increaseSourceNumber) throws IOException;

  377.   /**
  378.    * Inits the new list.
  379.    *
  380.    * @param maxNumberOfTerms the max number of terms
  381.    * @param segmentName the segment name
  382.    * @param segmentNumber the segment number
  383.    * @param boundary the boundary
  384.    * @throws IOException Signals that an I/O exception has occurred.
  385.    */
  386.   public void initNewList(int maxNumberOfTerms, String segmentName,
  387.       int segmentNumber, String boundary) throws IOException {
  388.     if (closed) {
  389.       result = null;
  390.       closed = false;
  391.     }
  392.     initNewListBasic(maxNumberOfTerms);
  393.     if (segmentRegistration != null) {
  394.       this.segmentName = segmentName;
  395.       this.segmentNumber = segmentNumber;
  396.       if (!segmentKeyValueList.containsKey(segmentName)) {
  397.         segmentKeyValueList.put(segmentName, new HashMap<String, T1>());
  398.         if (segmentRegistration.equals(SEGMENT_BOUNDARY_ASC)
  399.             || segmentRegistration.equals(SEGMENT_BOUNDARY_DESC)) {
  400.           if (boundary != null) {
  401.             segmentValuesBoundary.put(segmentName,
  402.                 stringToBoundary(boundary, segmentNumber));
  403.           } else {
  404.             throw new IOException("expected boundary");
  405.           }
  406.         } else {
  407.           segmentValuesBoundary.put(segmentName, null);
  408.         }
  409.         segmentValueTopListLast.put(segmentName, null);
  410.       }
  411.       this.segmentValueTopList = new ArrayList<>();
  412.     }
  413.   }

  415.   /**
  416.    * Inits the new list.
  417.    *
  418.    * @param maxNumberOfTerms the max number of terms
  419.    * @throws IOException Signals that an I/O exception has occurred.
  420.    */
  421.   public void initNewList(int maxNumberOfTerms) throws IOException {
  422.     if (closed) {
  423.       result = null;
  424.       closed = false;
  425.     }
  426.     if (segmentRegistration != null) {
  427.       throw new IOException("missing segment name");
  428.     } else {
  429.       initNewListBasic(maxNumberOfTerms);
  430.     }
  431.   }

  433.   /**
  434.    * Inits the new list basic.
  435.    *
  436.    * @param maxNumberOfTerms the max number of terms
  437.    * @throws IOException Signals that an I/O exception has occurred.
  438.    */
  439.   @SuppressWarnings("unchecked")
  440.   private void initNewListBasic(int maxNumberOfTerms) throws IOException {
  441.     if (!closed) {
  442.       position = 0;
  443.       newPosition = 0;
  444.       newCurrentPosition = 0;
  445.       newSize = maxNumberOfTerms + size;
  446.       newKeyList = new String[newSize];
  447.       newSourceNumberList = new int[newSize];
  448.       newErrorNumber = new int[newSize];
  449.       newErrorList = (HashMap<String, Integer>[]) new HashMap<?, ?>[newSize];
  450.       newKnownKeyFoundInSegment = new HashSet<>();
  451.       if (hasSub) {
  452.         newSubCollectorListNextLevel = new MtasDataCollector[newSize];
  453.       }
  454.     } else {
  455.       throw new IOException("already closed");
  456.     }
  457.   }

  459.   /**
  460.    * Increase new list size.
  461.    *
  462.    * @throws IOException Signals that an I/O exception has occurred.
  463.    */
  464.   @SuppressWarnings("unchecked")
  465.   protected void increaseNewListSize() throws IOException {
  466.     if (!closed) {
  467.       String[] tmpNewKeyList = newKeyList;
  468.       int[] tmpNewSourceNumberList = newSourceNumberList;
  469.       int[] tmpNewErrorNumber = newErrorNumber;
  470.       HashMap<String, Integer>[] tmpNewErrorList = newErrorList;
  471.       int tmpNewSize = newSize;
  472.       newSize = 2 * newSize;
  473.       newKeyList = new String[newSize];
  474.       newSourceNumberList = new int[newSize];
  475.       newErrorNumber = new int[newSize];
  476.       newErrorList = (HashMap<String, Integer>[]) new HashMap<?, ?>[newSize];
  477.       System.arraycopy(tmpNewKeyList, 0, newKeyList, 0, tmpNewSize);
  478.       System.arraycopy(tmpNewSourceNumberList, 0, newSourceNumberList, 0,
  479.           tmpNewSize);
  480.       System.arraycopy(tmpNewErrorNumber, 0, newErrorNumber, 0, tmpNewSize);
  481.       System.arraycopy(tmpNewErrorList, 0, newErrorList, 0, tmpNewSize);
  482.       if (hasSub) {
  483.         MtasDataCollector<?, ?>[] tmpNewSubCollectorListNextLevel = newSubCollectorListNextLevel;
  484.         newSubCollectorListNextLevel = new MtasDataCollector[newSize];
  485.         System.arraycopy(tmpNewSubCollectorListNextLevel, 0,
  486.             newSubCollectorListNextLevel, 0, tmpNewSize);
  487.       }
  488.     } else {
  489.       throw new IOException("already closed");
  490.     }
  491.   }

  493.   /**
  494.    * Adds the.
  495.    *
  496.    * @param increaseSourceNumber the increase source number
  497.    * @return the mtas data collector
  498.    * @throws IOException Signals that an I/O exception has occurred.
  499.    */
  500.   protected final MtasDataCollector add(boolean increaseSourceNumber)
  501.       throws IOException {
  502.     if (!closed) {
  503.       if (!collectorType.equals(DataCollector.COLLECTOR_TYPE_DATA)) {
  504.         throw new IOException(
  505.             "collector should be " + DataCollector.COLLECTOR_TYPE_DATA);
  506.       } else {
  507.         if (newPosition > 0) {
  508.           newCurrentExisting = true;
  509.         } else if (position < getSize()) {
  510.           // copy
  511.           newKeyList[0] = keyList[0];
  512.           newSourceNumberList[0] = sourceNumberList[0];
  513.           if (increaseSourceNumber) {
  514.             newSourceNumberList[0]++;
  515.           }
  516.           newErrorNumber[0] = errorNumber[0];
  517.           newErrorList[0] = errorList[0];
  518.           if (hasSub) {
  519.             newSubCollectorNextLevel = subCollectorNextLevel;
  520.           }
  521.           copyToNew(0, 0);
  522.           newPosition = 1;
  523.           position = 1;
  524.           newCurrentExisting = true;
  525.         } else {
  526.           // add key
  527.           newKeyList[0] = DataCollector.COLLECTOR_TYPE_DATA;
  528.           newSourceNumberList[0] = 1;
  529.           newErrorNumber[0] = 0;
  530.           newErrorList[0] = new HashMap<>();
  531.           newPosition = 1;
  532.           newCurrentPosition = newPosition - 1;
  533.           newCurrentExisting = false;
  534.           // ready, only handle sub
  535.           if (hasSub) {
  536.             newSubCollectorNextLevel = DataCollector.getCollector(
  537.                 subCollectorTypes[0], subDataTypes[0], subStatsTypes[0],
  538.                 subStatsItems[0], subSortTypes[0], subSortDirections[0],
  539.                 subStart[0], subNumber[0], newSubCollectorTypes,
  540.                 newSubDataTypes, newSubStatsTypes, newSubStatsItems,
  541.                 newSubSortTypes, newSubSortDirections, newSubStart,
  542.                 newSubNumber, segmentRegistration, null);
  543.           } else {
  544.             newSubCollectorNextLevel = null;
  545.           }
  546.         }
  547.         return newSubCollectorNextLevel;
  548.       }
  549.     } else {
  550.       throw new IOException("already closed");
  551.     }
  552.   }

  554.   /**
  555.    * Adds the.
  556.    *
  557.    * @param key the key
  558.    * @param increaseSourceNumber the increase source number
  559.    * @return the mtas data collector
  560.    * @throws IOException Signals that an I/O exception has occurred.
  561.    */
  562.   protected final MtasDataCollector add(String key,
  563.       boolean increaseSourceNumber) throws IOException {
  564.     if (!closed) {
  565.       if (collectorType.equals(DataCollector.COLLECTOR_TYPE_DATA)) {
  566.         throw new IOException(
  567.             "collector should be " + DataCollector.COLLECTOR_TYPE_LIST);
  568.       } else if (key == null) {
  569.         throw new IOException("key shouldn't be null");
  570.       } else {
  571.         // check previous added
  572.         if ((newPosition > 0)
  573.             && newKeyList[(newPosition - 1)].compareTo(key) >= 0) {
  574.           int i = newPosition;
  575.           do {
  576.             i--;
  577.             if (newKeyList[i].equals(key)) {
  578.               newCurrentPosition = i;
  579.               newCurrentExisting = true;
  580.               if (subDataTypes != null) {
  581.                 return newSubCollectorListNextLevel[newCurrentPosition];
  582.               } else {
  583.                 return null;
  584.               }
  585.             }
  586.           } while ((i > 0) && (newKeyList[i].compareTo(key) > 0));
  587.         }
  588.         // move position in old list
  589.         if (position < getSize()) {
  590.           // just add smaller or equal items
  591.           while (keyList[position].compareTo(key) <= 0) {
  592.             if (newPosition == newSize) {
  593.               increaseNewListSize();
  594.             }
  595.             // copy
  596.             newKeyList[newPosition] = keyList[position];
  597.             newSourceNumberList[newPosition] = sourceNumberList[position];
  598.             newErrorNumber[newPosition] = errorNumber[position];
  599.             newErrorList[newPosition] = errorList[position];
  600.             if (hasSub) {
  601.               newSubCollectorListNextLevel[newPosition] = subCollectorListNextLevel[position];
  602.             }
  603.             copyToNew(position, newPosition);
  604.             newPosition++;
  605.             position++;
  606.             // check if added key from list is right key
  607.             if (newKeyList[(newPosition - 1)].equals(key)) {
  608.               if (increaseSourceNumber) {
  609.                 newSourceNumberList[(newPosition - 1)]++;
  610.               }
  611.               newCurrentPosition = newPosition - 1;
  612.               newCurrentExisting = true;
  613.               // register known key found again in segment
  614.               newKnownKeyFoundInSegment.add(key);
  615.               // ready
  616.               if (hasSub) {
  617.                 return newSubCollectorListNextLevel[newCurrentPosition];
  618.               } else {
  619.                 return null;
  620.               }
  621.               // stop if position exceeds size
  622.             } else if (position == getSize()) {
  623.               break;
  624.             }
  625.           }
  626.         }
  627.         // check size
  628.         if (newPosition == newSize) {
  629.           increaseNewListSize();
  630.         }
  631.         // add key
  632.         newKeyList[newPosition] = key;
  633.         newSourceNumberList[newPosition] = 1;
  634.         newErrorNumber[newPosition] = 0;
  635.         newErrorList[newPosition] = new HashMap<>();
  636.         newPosition++;
  637.         newCurrentPosition = newPosition - 1;
  638.         newCurrentExisting = false;
  639.         // ready, only handle sub
  640.         if (hasSub) {
  641.           newSubCollectorListNextLevel[newCurrentPosition] = DataCollector
  642.               .getCollector(subCollectorTypes[0], subDataTypes[0],
  643.                   subStatsTypes[0], subStatsItems[0], subSortTypes[0],
  644.                   subSortDirections[0], subStart[0], subNumber[0],
  645.                   newSubCollectorTypes, newSubDataTypes, newSubStatsTypes,
  646.                   newSubStatsItems, newSubSortTypes, newSubSortDirections,
  647.                   newSubStart, newSubNumber, segmentRegistration, null);
  648.           return newSubCollectorListNextLevel[newCurrentPosition];
  649.         } else {
  650.           return null;
  651.         }
  652.       }
  653.     } else {
  654.       throw new IOException("already closed");
  655.     }
  656.   }

  658.   /**
  659.    * Copy to new.
  660.    *
  661.    * @param position the position
  662.    * @param newPosition the new position
  663.    */
  664.   protected abstract void copyToNew(int position, int newPosition);

  666.   /**
  667.    * Copy from new.
  668.    */
  669.   protected abstract void copyFromNew();

  671.   /**
  672.    * Compare with boundary.
  673.    *
  674.    * @param value the value
  675.    * @param boundary the boundary
  676.    * @return true, if successful
  677.    * @throws IOException Signals that an I/O exception has occurred.
  678.    */
  679.   protected abstract boolean compareWithBoundary(T1 value, T1 boundary)
  680.       throws IOException;

  682.   /**
  683.    * Last for computing segment.
  684.    *
  685.    * @param value the value
  686.    * @param boundary the boundary
  687.    * @return the t1
  688.    * @throws IOException Signals that an I/O exception has occurred.
  689.    */
  690.   protected abstract T1 lastForComputingSegment(T1 value, T1 boundary)
  691.       throws IOException;

  693.   /**
  694.    * Last for computing segment.
  695.    *
  696.    * @return the t1
  697.    * @throws IOException Signals that an I/O exception has occurred.
  698.    */
  699.   protected abstract T1 lastForComputingSegment() throws IOException;

  701.   /**
  702.    * Boundary for segment.
  703.    *
  704.    * @param segmentName the segment name
  705.    * @return the t1
  706.    * @throws IOException Signals that an I/O exception has occurred.
  707.    */
  708.   protected abstract T1 boundaryForSegment(String segmentName)
  709.       throws IOException;

  711.   /**
  712.    * Boundary for segment computing.
  713.    *
  714.    * @param segmentName the segment name
  715.    * @return the t1
  716.    * @throws IOException Signals that an I/O exception has occurred.
  717.    */
  718.   protected abstract T1 boundaryForSegmentComputing(String segmentName)
  719.       throws IOException;

  721.   /**
  722.    * String to boundary.
  723.    *
  724.    * @param boundary the boundary
  725.    * @param segmentNumber the segment number
  726.    * @return the t1
  727.    * @throws IOException Signals that an I/O exception has occurred.
  728.    */
  729.   protected abstract T1 stringToBoundary(String boundary, Integer segmentNumber)
  730.       throws IOException;

  732.   /**
  733.    * String to boundary.
  734.    *
  735.    * @param boundary the boundary
  736.    * @return the t1
  737.    * @throws IOException Signals that an I/O exception has occurred.
  738.    */
  739.   protected T1 stringToBoundary(String boundary) throws IOException {
  740.     return stringToBoundary(boundary, null);
  741.   }

  743.   /**
  744.    * Close segment key value registration.
  745.    *
  746.    * @throws IOException Signals that an I/O exception has occurred.
  747.    */
  748.   public void closeSegmentKeyValueRegistration() throws IOException {
  749.     if (!closed) {
  750.       if (segmentRegistration != null) {
  751.         Map<String, T1> keyValueList = segmentKeyValueList.get(segmentName);
  752.         T1 tmpSegmentValueBoundary = segmentValuesBoundary.get(segmentName);
  753.         for (Entry<String, T1> entry : keyValueList.entrySet()) {
  754.           if (tmpSegmentValueBoundary == null || compareWithBoundary(
  755.               entry.getValue(), tmpSegmentValueBoundary)) {
  756.             segmentKeys.add(entry.getKey());
  757.           }
  758.         }
  759.       }
  760.     } else {
  761.       throw new IOException("already closed");
  762.     }
  763.   }

  765.   /**
  766.    * Recompute segment keys.
  767.    *
  768.    * @throws IOException Signals that an I/O exception has occurred.
  769.    */
  770.   public void recomputeSegmentKeys() throws IOException {
  771.     if (!closed && segmentRegistration != null) {
  772.       if (segmentRegistration.equals(SEGMENT_SORT_ASC)
  773.           || segmentRegistration.equals(SEGMENT_SORT_DESC)
  774.           || segmentRegistration.equals(SEGMENT_BOUNDARY_ASC)
  775.           || segmentRegistration.equals(SEGMENT_BOUNDARY_DESC)) {

  777.         if (segmentRegistration.equals(SEGMENT_SORT_ASC)
  778.             || segmentRegistration.equals(SEGMENT_SORT_DESC)) {
  779.           segmentKeys.clear();
  780.           // recompute boundaries
  781.           for (Entry<String, Map<String, T1>> entry : segmentKeyValueList
  782.               .entrySet()) {
  783.             T1 tmpSegmentValueBoundary = boundaryForSegment(entry.getKey());
  784.             segmentValuesBoundary.put(entry.getKey(), tmpSegmentValueBoundary);
  785.           }
  786.           // compute adjusted boundaries and compute keys
  787.           for (Entry<String, Map<String, T1>> entry : segmentKeyValueList
  788.               .entrySet()) {
  789.             this.segmentName = entry.getKey();
  790.             Map<String, T1> keyValueList = entry.getValue();
  791.             T1 tmpSegmentValueBoundaryForComputing = boundaryForSegmentComputing(
  792.                 entry.getKey());
  793.             for (Entry<String, T1> subEntry : keyValueList.entrySet()) {
  794.               if (tmpSegmentValueBoundaryForComputing == null
  795.                   || compareWithBoundary(subEntry.getValue(),
  796.                       tmpSegmentValueBoundaryForComputing)) {
  797.                 if (!segmentKeys.contains(subEntry.getKey())) {
  798.                   segmentKeys.add(subEntry.getKey());
  799.                 }
  800.               }
  801.             }
  802.           }
  803.         }

  805.         Map<String, T1> keyValueList;
  806.         Set<String> recomputeKeyList;
  807.         segmentRecomputeKeyList = new LinkedHashMap<>();
  808.         for (String key : segmentKeys) {
  809.           for (Entry<String, Map<String, T1>> entry : segmentKeyValueList
  810.               .entrySet()) {
  811.             keyValueList = entry.getValue();
  812.             if (!keyValueList.containsKey(key)) {
  813.               if (!segmentRecomputeKeyList.containsKey(entry.getKey())) {
  814.                 recomputeKeyList = new HashSet<>();
  815.                 segmentRecomputeKeyList.put(entry.getKey(), recomputeKeyList);
  816.               } else {
  817.                 recomputeKeyList = segmentRecomputeKeyList.get(entry.getKey());
  818.               }
  819.               recomputeKeyList.add(key);
  820.             }
  821.           }
  822.         }
  823.         this.segmentName = null;
  824.       } else {
  825.         throw new IOException(
  826.             "not for segmentRegistration " + segmentRegistration);
  827.       }
  828.     } else {
  829.       throw new IOException("already closed or no segmentRegistration ("
  830.           + segmentRegistration + ")");
  831.     }
  832.   }

  834.   /**
  835.    * Reduce to keys.
  836.    *
  837.    * @param keys the keys
  838.    */
  839.   public abstract void reduceToKeys(Set<String> keys);

  841.   /**
  842.    * Reduce to segment keys.
  843.    */
  844.   public void reduceToSegmentKeys() {
  845.     if (segmentRegistration != null) {
  846.       reduceToKeys(segmentKeys);
  847.     }
  848.   }

  850.   /**
  851.    * Check existence necessary keys.
  852.    *
  853.    * @return true, if successful
  854.    * @throws IOException Signals that an I/O exception has occurred.
  855.    */
  856.   public boolean checkExistenceNecessaryKeys() throws IOException {
  857.     if (!closed) {
  858.       if (segmentRegistration != null) {
  859.         return segmentRecomputeKeyList.size() == 0;
  860.       } else {
  861.         return true;
  862.       }
  863.     } else {
  864.       throw new IOException("already closed");
  865.     }
  866.   }

  868.   /**
  869.    * Validate segment boundary.
  870.    *
  871.    * @param o the o
  872.    * @return true, if successful
  873.    * @throws IOException Signals that an I/O exception has occurred.
  874.    */
  875.   abstract public boolean validateSegmentBoundary(Object o) throws IOException;

  877.   /**
  878.    * Validate with segment boundary.
  879.    *
  880.    * @param value the value
  881.    * @return true, if successful
  882.    * @throws IOException Signals that an I/O exception has occurred.
  883.    */
  884.   protected boolean validateWithSegmentBoundary(T1 value) throws IOException {
  885.     if (!closed && segmentRegistration != null) {
  886.       T1 tmpSegmentValueBoundary = segmentValuesBoundary.get(segmentName);
  887.       if (tmpSegmentValueBoundary == null
  888.           || compareWithBoundary(value, tmpSegmentValueBoundary)) {
  889.         return true;
  890.       }
  891.     }
  892.     return false;
  893.   }

  895.   /**
  896.    * Validate segment value.
  897.    *
  898.    * @param value the value
  899.    * @param maximumNumber the maximum number
  900.    * @param segmentNumber the segment number
  901.    * @return the string
  902.    * @throws IOException Signals that an I/O exception has occurred.
  903.    */
  904.   public String validateSegmentValue(T1 value, int maximumNumber,
  905.       int segmentNumber) throws IOException {
  906.     if (!closed) {
  907.       if (segmentRegistration != null) {
  908.         if (maximumNumber > 0) {
  909.           T1 tmpSegmentValueBoundary = segmentValuesBoundary.get(segmentName);
  910.           if (segmentValueTopList.size() < maximumNumber
  911.               || compareWithBoundary(value, tmpSegmentValueBoundary)) {
  912.             return SEGMENT_KEY_OR_NEW;
  913.           } else if (segmentKeys.size() > newKnownKeyFoundInSegment.size()) {
  914.             return SEGMENT_POSSIBLE_KEY;
  915.           } else {
  916.             return null;
  917.           }
  918.         } else {
  919.           return null;
  920.         }
  921.       } else {
  922.         return null;
  923.       }
  924.     } else {
  925.       throw new IOException("already closed");
  926.     }
  927.   }

  929.   /**
  930.    * Validate segment value.
  931.    *
  932.    * @param key the key
  933.    * @param value the value
  934.    * @param maximumNumber the maximum number
  935.    * @param segmentNumber the segment number
  936.    * @param test the test
  937.    * @return the string
  938.    * @throws IOException Signals that an I/O exception has occurred.
  939.    */
  940.   public String validateSegmentValue(String key, T1 value, int maximumNumber,
  941.       int segmentNumber, boolean test) throws IOException {
  942.     if (!closed) {
  943.       if (segmentRegistration != null) {
  944.         if (maximumNumber > 0) {
  945.           T1 tmpSegmentValueMaxListMin = segmentValueTopListLast
  946.               .get(segmentName);
  947.           T1 tmpSegmentValueBoundary = segmentValuesBoundary.get(segmentName);
  948.           if (segmentValueTopList.size() < maximumNumber) {
  949.             if (!test) {
  950.               segmentKeyValueList.get(segmentName).put(key, value);
  951.               segmentValueTopList.add(value);
  952.               segmentValueTopListLast.put(segmentName,
  953.                   (tmpSegmentValueMaxListMin == null) ? value
  954.                       : lastForComputingSegment(tmpSegmentValueMaxListMin,
  955.                           value));
  956.               if (segmentValueTopList.size() == maximumNumber) {
  957.                 tmpSegmentValueMaxListMin = segmentValueTopListLast
  958.                     .get(segmentName);
  959.                 segmentValueTopListLast.put(segmentName,
  960.                     tmpSegmentValueMaxListMin);
  961.                 segmentValuesBoundary.put(segmentName,
  962.                     boundaryForSegmentComputing(segmentName));
  963.               }
  964.             }
  965.             return segmentKeys.contains(key) ? SEGMENT_KEY : SEGMENT_NEW;
  966.           } else if (compareWithBoundary(value, tmpSegmentValueBoundary)) {
  967.             // System.out.println(key+" "+value+" "+tmpSegmentValueBoundary);
  968.             if (!test) {
  969.               segmentKeyValueList.get(segmentName).put(key, value);
  970.               if (compareWithBoundary(value, tmpSegmentValueMaxListMin)) {
  971.                 segmentValueTopList.add(value);
  972.                 segmentValueTopList.remove(tmpSegmentValueMaxListMin);
  973.                 tmpSegmentValueMaxListMin = lastForComputingSegment();
  974.                 segmentValueTopListLast.put(segmentName,
  975.                     tmpSegmentValueMaxListMin);
  976.                 segmentValuesBoundary.put(segmentName,
  977.                     boundaryForSegmentComputing(segmentName));
  978.               }
  979.             }
  980.             return segmentKeys.contains(key) ? SEGMENT_KEY : SEGMENT_NEW;
  981.           } else if (segmentKeys.contains(key)) {
  982.             if (!test) {
  983.               segmentKeyValueList.get(segmentName).put(key, value);
  984.             }
  985.             return SEGMENT_KEY;
  986.           } else {
  987.             return null;
  988.           }
  989.         } else {
  990.           return null;
  991.         }
  992.       } else {
  993.         return null;
  994.       }
  995.     } else {
  996.       throw new IOException("already closed");
  997.     }
  998.   }

  1000.   /**
  1001.    * Sets the error.
  1002.    *
  1003.    * @param newPosition the new position
  1004.    * @param errorNumberItem the error number item
  1005.    * @param errorListItem the error list item
  1006.    * @param currentExisting the current existing
  1007.    * @throws IOException Signals that an I/O exception has occurred.
  1008.    */
  1009.   protected final void setError(int newPosition, int errorNumberItem,
  1010.       HashMap<String, Integer> errorListItem, boolean currentExisting)
  1011.       throws IOException {
  1012.     if (!closed) {
  1013.       if (currentExisting) {
  1014.         newErrorNumber[newPosition] += errorNumberItem;
  1015.         HashMap<String, Integer> item = newErrorList[newPosition];
  1016.         for (Entry<String, Integer> entry : errorListItem.entrySet()) {
  1017.           if (item.containsKey(entry.getKey())) {
  1018.             item.put(entry.getKey(),
  1019.                 item.get(entry.getKey()) + entry.getValue());
  1020.           } else {
  1021.             item.put(entry.getKey(), entry.getValue());
  1022.           }
  1023.         }
  1024.       } else {
  1025.         newErrorNumber[newPosition] = errorNumberItem;
  1026.         newErrorList[newPosition] = errorListItem;
  1027.       }
  1028.     } else {
  1029.       throw new IOException("already closed");
  1030.     }
  1031.   }

  1033.   /**
  1034.    * Sorted and unique.
  1035.    *
  1036.    * @param keyList the key list
  1037.    * @param size the size
  1038.    * @return true, if successful
  1039.    * @throws IOException Signals that an I/O exception has occurred.
  1040.    */
  1041.   private boolean sortedAndUnique(String[] keyList, int size)
  1042.       throws IOException {
  1043.     if (!closed) {
  1044.       for (int i = 1; i < size; i++) {
  1045.         if (keyList[(i - 1)].compareTo(keyList[i]) >= 0) {
  1046.           return false;
  1047.         }
  1048.       }
  1049.       return true;
  1050.     } else {
  1051.       throw new IOException("already closed");
  1052.     }
  1053.   }

  1055.   /**
  1056.    * Compute sort and unique mapping.
  1057.    *
  1058.    * @param keyList the key list
  1059.    * @param size the size
  1060.    * @return the int[][]
  1061.    * @throws IOException Signals that an I/O exception has occurred.
  1062.    */
  1063.   private int[][] computeSortAndUniqueMapping(String[] keyList, int size)
  1064.       throws IOException {
  1065.     if (!closed) {
  1066.       if (size > 0) {
  1067.         SortedMap<String, int[]> sortedMap = new TreeMap<>();
  1068.         for (int i = 0; i < size; i++) {
  1069.           if (sortedMap.containsKey(keyList[i])) {
  1070.             int[] previousList = sortedMap.get(keyList[i]);
  1071.             int[] newList = new int[previousList.length + 1];
  1072.             System.arraycopy(previousList, 0, newList, 0, previousList.length);
  1073.             newList[previousList.length] = i;
  1074.             sortedMap.put(keyList[i], newList);
  1075.           } else {
  1076.             sortedMap.put(keyList[i], new int[] { i });
  1077.           }
  1078.         }
  1079.         Collection<int[]> values = sortedMap.values();
  1080.         int[][] result = new int[sortedMap.size()][];
  1081.         return values.toArray(result);
  1082.       } else {
  1083.         return null;
  1084.       }
  1085.     } else {
  1086.       throw new IOException("already closed");
  1087.     }
  1088.   }

  1090.   /**
  1091.    * Remap data.
  1092.    *
  1093.    * @param mapping the mapping
  1094.    * @throws IOException Signals that an I/O exception has occurred.
  1095.    */
  1096.   protected void remapData(int[][] mapping) throws IOException {
  1097.     if (!closed) {
  1098.       // remap and merge keys
  1099.       String[] newKeyList = new String[mapping.length];
  1100.       // process mapping for functions?
  1101.       HashMap<MtasDataCollector<?, ?>, MtasDataCollector<?, ?>> map = new HashMap<>();
  1102.       int[] newSourceNumberList = new int[mapping.length];
  1103.       int[] newErrorNumber = new int[mapping.length];
  1104.       @SuppressWarnings("unchecked")
  1105.       HashMap<String, Integer>[] newErrorList = (HashMap<String, Integer>[]) new HashMap<?, ?>[mapping.length];
  1106.       for (int i = 0; i < mapping.length; i++) {
  1107.         newKeyList[i] = keyList[mapping[i][0]];
  1108.         newSourceNumberList[i] = sourceNumberList[mapping[i][0]];
  1109.         for (int j = 0; j < mapping[i].length; j++) {
  1110.           if (j == 0) {
  1111.             newErrorNumber[i] = errorNumber[mapping[i][j]];
  1112.             newErrorList[i] = errorList[mapping[i][j]];
  1113.           } else {
  1114.             newErrorNumber[i] += errorNumber[mapping[i][j]];
  1115.             for (Entry<String, Integer> entry : errorList[mapping[i][j]]
  1116.                 .entrySet()) {
  1117.               if (newErrorList[i].containsKey(entry.getKey())) {
  1118.                 newErrorList[i].put(entry.getKey(),
  1119.                     newErrorList[i].get(entry.getKey()) + entry.getValue());
  1120.               } else {
  1121.                 newErrorList[i].put(entry.getKey(), entry.getValue());
  1122.               }
  1123.             }
  1124.           }
  1125.         }
  1126.       }
  1127.       if (hasSub) {
  1128.         newSubCollectorListNextLevel = new MtasDataCollector<?, ?>[mapping.length];
  1129.         for (int i = 0; i < mapping.length; i++) {
  1130.           for (int j = 0; j < mapping[i].length; j++) {
  1131.             if (j == 0 || newSubCollectorListNextLevel[i] == null) {
  1132.               newSubCollectorListNextLevel[i] = subCollectorListNextLevel[mapping[i][j]];
  1133.             } else {
  1134.               newSubCollectorListNextLevel[i]
  1135.                   .merge(subCollectorListNextLevel[mapping[i][j]], map, false);
  1136.             }
  1137.           }
  1138.         }
  1139.         subCollectorListNextLevel = newSubCollectorListNextLevel;
  1140.       }
  1141.       keyList = newKeyList;
  1142.       sourceNumberList = newSourceNumberList;
  1143.       errorNumber = newErrorNumber;
  1144.       errorList = newErrorList;
  1145.       size = keyList.length;
  1146.       position = 0;
  1147.     } else {
  1148.       throw new IOException("already closed");
  1149.     }
  1150.   }

  1152.   /**
  1153.    * Close new list.
  1154.    *
  1155.    * @throws IOException Signals that an I/O exception has occurred.
  1156.    */
  1157.   public void closeNewList() throws IOException {
  1158.     if (!closed) {
  1159.       if (segmentRegistration != null) {
  1160.         this.segmentName = null;
  1161.       }
  1162.       if (newSize > 0) {
  1163.         // add remaining old
  1164.         while (position < getSize()) {
  1165.           if (newPosition == newSize) {
  1166.             increaseNewListSize();
  1167.           }
  1168.           newKeyList[newPosition] = keyList[position];
  1169.           newSourceNumberList[newPosition] = sourceNumberList[position];
  1170.           newErrorNumber[newPosition] = errorNumber[position];
  1171.           newErrorList[newPosition] = errorList[position];
  1172.           if (hasSub) {
  1173.             newSubCollectorListNextLevel[newPosition] = subCollectorListNextLevel[position];
  1174.           }
  1175.           copyToNew(position, newPosition);
  1176.           position++;
  1177.           newPosition++;
  1178.         }
  1179.         // copy
  1180.         keyList = newKeyList;
  1181.         sourceNumberList = newSourceNumberList;
  1182.         errorNumber = newErrorNumber;
  1183.         errorList = newErrorList;
  1184.         subCollectorListNextLevel = newSubCollectorListNextLevel;
  1185.         copyFromNew();
  1186.         size = newPosition;
  1187.         // sort and merge
  1188.         if (!sortedAndUnique(keyList, getSize())) {
  1189.           remapData(computeSortAndUniqueMapping(keyList, getSize()));
  1190.         }
  1191.       }
  1192.       position = 0;
  1193.       newSize = 0;
  1194.       newPosition = 0;
  1195.       newCurrentPosition = 0;
  1196.     }
  1197.   }

  1199.   /**
  1200.    * Gets the item.
  1201.    *
  1202.    * @param i the i
  1203.    * @return the item
  1204.    */
  1205.   abstract protected MtasDataItem<T1, T2> getItem(int i);

  1207.   /**
  1208.    * Checks for sub.
  1209.    *
  1210.    * @return true, if successful
  1211.    */
  1212.   protected boolean hasSub() {
  1213.     return hasSub;
  1214.   }

  1216.   /**
  1217.    * Error.
  1218.    *
  1219.    * @param error the error
  1220.    * @throws IOException Signals that an I/O exception has occurred.
  1221.    */
  1222.   public abstract void error(String error) throws IOException;

  1224.   /**
  1225.    * Error.
  1226.    *
  1227.    * @param key the key
  1228.    * @param error the error
  1229.    * @throws IOException Signals that an I/O exception has occurred.
  1230.    */
  1231.   public abstract void error(String key, String error) throws IOException;

  1233.   /**
  1234.    * Adds the.
  1235.    *
  1236.    * @param valueSum the value sum
  1237.    * @param valueN the value N
  1238.    * @return the mtas data collector
  1239.    * @throws IOException Signals that an I/O exception has occurred.
  1240.    */
  1241.   public abstract MtasDataCollector add(long valueSum, long valueN)
  1242.       throws IOException;

  1244.   /**
  1245.    * Adds the.
  1246.    *
  1247.    * @param values the values
  1248.    * @param number the number
  1249.    * @return the mtas data collector
  1250.    * @throws IOException Signals that an I/O exception has occurred.
  1251.    */
  1252.   public abstract MtasDataCollector add(long[] values, int number)
  1253.       throws IOException;

  1255.   /**
  1256.    * Adds the.
  1257.    *
  1258.    * @param valueSum the value sum
  1259.    * @param valueN the value N
  1260.    * @return the mtas data collector
  1261.    * @throws IOException Signals that an I/O exception has occurred.
  1262.    */
  1263.   public abstract MtasDataCollector add(double valueSum, long valueN)
  1264.       throws IOException;

  1266.   /**
  1267.    * Adds the.
  1268.    *
  1269.    * @param values the values
  1270.    * @param number the number
  1271.    * @return the mtas data collector
  1272.    * @throws IOException Signals that an I/O exception has occurred.
  1273.    */
  1274.   public abstract MtasDataCollector add(double[] values, int number)
  1275.       throws IOException;

  1277.   /**
  1278.    * Adds the.
  1279.    *
  1280.    * @param key the key
  1281.    * @param valueSum the value sum
  1282.    * @param valueN the value N
  1283.    * @return the mtas data collector
  1284.    * @throws IOException Signals that an I/O exception has occurred.
  1285.    */
  1286.   public abstract MtasDataCollector add(String key, long valueSum, long valueN)
  1287.       throws IOException;

  1289.   /**
  1290.    * Adds the.
  1291.    *
  1292.    * @param key the key
  1293.    * @param values the values
  1294.    * @param number the number
  1295.    * @return the mtas data collector
  1296.    * @throws IOException Signals that an I/O exception has occurred.
  1297.    */
  1298.   public abstract MtasDataCollector add(String key, long[] values, int number)
  1299.       throws IOException;

  1301.   /**
  1302.    * Adds the.
  1303.    *
  1304.    * @param key the key
  1305.    * @param valueSum the value sum
  1306.    * @param valueN the value N
  1307.    * @return the mtas data collector
  1308.    * @throws IOException Signals that an I/O exception has occurred.
  1309.    */
  1310.   public abstract MtasDataCollector add(String key, double valueSum,
  1311.       long valueN) throws IOException;

  1313.   /**
  1314.    * Adds the.
  1315.    *
  1316.    * @param key the key
  1317.    * @param values the values
  1318.    * @param number the number
  1319.    * @return the mtas data collector
  1320.    * @throws IOException Signals that an I/O exception has occurred.
  1321.    */
  1322.   public abstract MtasDataCollector add(String key, double[] values, int number)
  1323.       throws IOException;

  1325.   /*
  1326.    * (non-Javadoc)
  1327.    * 
  1328.    * @see java.lang.Object#toString()
  1329.    */
  1330.   @Override
  1331.   public String toString() {
  1332.     StringBuilder text = new StringBuilder();
  1333.     text.append(this.getClass().getSimpleName() + "-" + this.hashCode() + "\n");
  1334.     text.append("\t=== " + collectorType + " - " + statsType + " " + statsItems
  1335.         + " " + hasSub + " ===\n");
  1336.     text.append("\tclosed: " + closed + "\n");
  1337.     text.append("\tkeylist: " + Arrays.asList(keyList) + "\n");
  1338.     text.append("\tsegmentKeys: "
  1339.         + (segmentKeys != null ? segmentKeys.contains("1") : "null") + "\n");
  1340.     return text.toString().trim();
  1341.   }

  1343.   /**
  1344.    * Gets the result.
  1345.    *
  1346.    * @return the result
  1347.    * @throws IOException Signals that an I/O exception has occurred.
  1348.    */
  1349.   public MtasDataCollectorResult<T1, T2> getResult() throws IOException {
  1350.     if (!closed) {
  1351.       close();
  1352.     }
  1353.     return result;
  1354.   }

  1356.   /**
  1357.    * Gets the key list.
  1358.    *
  1359.    * @return the key list
  1360.    * @throws IOException Signals that an I/O exception has occurred.
  1361.    */
  1362.   public Set<String> getKeyList() throws IOException {
  1363.     if (!closed) {
  1364.       close();
  1365.     }
  1366.     return new HashSet<>(Arrays.asList(keyList));
  1367.   }

  1369.   /**
  1370.    * Gets the stats items.
  1371.    *
  1372.    * @return the stats items
  1373.    */
  1374.   public SortedSet<String> getStatsItems() {
  1375.     return statsItems;
  1376.   }

  1378.   /**
  1379.    * Close.
  1380.    *
  1381.    * @throws IOException Signals that an I/O exception has occurred.
  1382.    */
  1383.   @SuppressWarnings({ "rawtypes", "unchecked" })
  1384.   public void close() throws IOException {
  1385.     if (!closed) {
  1386.       closeNewList();
  1387.       if (collectorType.equals(DataCollector.COLLECTOR_TYPE_LIST)) {
  1388.         // compute initial basic list
  1389.         TreeMap<String, MtasDataItem<T1, T2>> basicList = new TreeMap<>();
  1390.         for (int i = 0; i < getSize(); i++) {
  1391.           MtasDataItem<T1, T2> newItem = getItem(i);
  1392.           if (basicList.containsKey(keyList[i])) {
  1393.             newItem.add(basicList.get(keyList[i]));
  1394.           }
  1395.           basicList.put(keyList[i], newItem);
  1396.         }
  1397.         // create result based on basic list
  1398.         result = new MtasDataCollectorResult<>(collectorType, sortType,
  1399.             sortDirection, basicList, start, number);
  1400.         // reduce
  1401.         if (segmentRegistration != null) {
  1402.           if (segmentRegistration.equals(SEGMENT_SORT_ASC)
  1403.               || segmentRegistration.equals(SEGMENT_SORT_DESC)) {
  1404.             reduceToKeys(result.getComparatorList().keySet());
  1405.           } else if (segmentRegistration.equals(SEGMENT_BOUNDARY_ASC)
  1406.               || segmentRegistration.equals(SEGMENT_BOUNDARY_DESC)) {
  1407.             Map<String, MtasDataItemNumberComparator> comparatorList = result
  1408.                 .getComparatorList();
  1409.             HashSet<String> filteredKeySet = new HashSet<>();
  1410.             if (segmentRegistration.equals(SEGMENT_BOUNDARY_ASC)) {
  1411.               for (Entry<String, MtasDataItemNumberComparator> entry : comparatorList
  1412.                   .entrySet()) {
  1413.                 if (entry.getValue().compareTo(segmentValueBoundary) < 0) {
  1414.                   filteredKeySet.add(entry.getKey());
  1415.                 }
  1416.               }
  1417.             } else {
  1418.               for (Entry<String, MtasDataItemNumberComparator> entry : comparatorList
  1419.                   .entrySet()) {
  1420.                 if (entry.getValue().compareTo(segmentValueBoundary) > 0) {
  1421.                   filteredKeySet.add(entry.getKey());
  1422.                 }
  1423.               }
  1424.             }
  1425.             reduceToKeys(filteredKeySet);
  1426.             basicList.keySet().retainAll(filteredKeySet);
  1427.             result = new MtasDataCollectorResult<>(collectorType, sortType,
  1428.                 sortDirection, basicList, start, number);
  1429.           }
  1430.         }
  1431.       } else if (collectorType.equals(DataCollector.COLLECTOR_TYPE_DATA)) {
  1432.         if (getSize() > 0) {
  1433.           result = new MtasDataCollectorResult<>(collectorType, getItem(0));
  1434.         } else {
  1435.           result = new MtasDataCollectorResult<>(collectorType, sortType,
  1436.               sortDirection);
  1437.         }
  1438.       } else {
  1439.         throw new IOException("type " + collectorType + " not supported");
  1440.       }
  1441.       closed = true;
  1442.     }
  1443.   }

  1445.   /**
  1446.    * Gets the collector type.
  1447.    *
  1448.    * @return the collector type
  1449.    */
  1450.   public String getCollectorType() {
  1451.     return collectorType;
  1452.   }

  1454.   /**
  1455.    * Gets the stats type.
  1456.    *
  1457.    * @return the stats type
  1458.    */
  1459.   public String getStatsType() {
  1460.     return statsType;
  1461.   }

  1463.   /**
  1464.    * Gets the data type.
  1465.    *
  1466.    * @return the data type
  1467.    */
  1468.   public String getDataType() {
  1469.     return dataType;
  1470.   }

  1472.   /**
  1473.    * Gets the size.
  1474.    *
  1475.    * @return the size
  1476.    */
  1477.   public int getSize() {
  1478.     return size;
  1479.   }

  1481.   /**
  1482.    * With total.
  1483.    *
  1484.    * @return true, if successful
  1485.    */
  1486.   public boolean withTotal() {
  1487.     return withTotal;
  1488.   }

  1490.   /**
  1491.    * Sets the with total.
  1492.    *
  1493.    * @throws IOException Signals that an I/O exception has occurred.
  1494.    */
  1495.   public void setWithTotal() throws IOException {
  1496.     if (collectorType.equals(DataCollector.COLLECTOR_TYPE_LIST)) {
  1497.       if (segmentName != null) {
  1498.         throw new IOException("can't get total with segmentRegistration");
  1499.       } else {
  1500.         withTotal = true;
  1501.       }
  1502.     } else {
  1503.       throw new IOException(
  1504.           "can't get total for dataCollector of type " + collectorType);
  1505.     }
  1506.   }

  1508. }
Created with JaCoCo 0.7.9.201702052155