MtasDataDoubleBasic.java

  1. package mtas.codec.util.collector;

  3. import java.io.IOException;
  4. import java.util.Collections;
  5. import java.util.SortedSet;

  7. import org.apache.commons.lang.ArrayUtils;
  8. import mtas.codec.util.CodecUtil;

  10. /**
  11.  * The Class MtasDataDoubleBasic.
  12.  */
  13. public class MtasDataDoubleBasic extends MtasDataBasic<Double, Double> {

  15.   /** The Constant serialVersionUID. */
  16.   private static final long serialVersionUID = 1L;

  18.   /**
  19.    * Instantiates a new mtas data double basic.
  20.    *
  21.    * @param collectorType the collector type
  22.    * @param statsItems the stats items
  23.    * @param sortType the sort type
  24.    * @param sortDirection the sort direction
  25.    * @param start the start
  26.    * @param number the number
  27.    * @param subCollectorTypes the sub collector types
  28.    * @param subDataTypes the sub data types
  29.    * @param subStatsTypes the sub stats types
  30.    * @param subStatsItems the sub stats items
  31.    * @param subSortTypes the sub sort types
  32.    * @param subSortDirections the sub sort directions
  33.    * @param subStart the sub start
  34.    * @param subNumber the sub number
  35.    * @param segmentRegistration the segment registration
  36.    * @param boundary the boundary
  37.    * @throws IOException Signals that an I/O exception has occurred.
  38.    */
  39.   public MtasDataDoubleBasic(String collectorType, SortedSet<String> statsItems,
  40.       String sortType, String sortDirection, Integer start, Integer number,
  41.       String[] subCollectorTypes, String[] subDataTypes, String[] subStatsTypes,
  42.       SortedSet<String>[] subStatsItems, String[] subSortTypes,
  43.       String[] subSortDirections, Integer[] subStart, Integer[] subNumber,
  44.       String segmentRegistration, String boundary) throws IOException {
  45.     super(collectorType, CodecUtil.DATA_TYPE_DOUBLE, statsItems, sortType,
  46.         sortDirection, start, number, subCollectorTypes, subDataTypes,
  47.         subStatsTypes, subStatsItems, subSortTypes, subSortDirections, subStart,
  48.         subNumber, new MtasDataDoubleOperations(), segmentRegistration,
  49.         boundary);
  50.   }

  52.   /*
  53.    * (non-Javadoc)
  54.    * 
  55.    * @see mtas.codec.util.DataCollector.MtasDataCollector#getItem(int)
  56.    */
  57.   @Override
  58.   protected MtasDataItemDoubleBasic getItem(int i) {
  59.     if (i >= 0 && i < size) {
  60.       return new MtasDataItemDoubleBasic(basicValueSumList[i],
  61.           basicValueNList[i], hasSub() ? subCollectorListNextLevel[i] : null,
  62.           getStatsItems(), sortType, sortDirection, errorNumber[i],
  63.           errorList[i], sourceNumberList[i]);
  64.     } else {
  65.       return null;
  66.     }
  67.   }

  69.   /*
  70.    * (non-Javadoc)
  71.    * 
  72.    * @see mtas.codec.util.DataCollector.MtasDataCollector#add(long, long)
  73.    */
  74.   @Override
  75.   public MtasDataCollector<?, ?> add(long valueSum, long valueN)
  76.       throws IOException {
  77.     MtasDataCollector<?, ?> dataCollector = add(false);
  78.     setValue(newCurrentPosition, Double.valueOf(valueSum), valueN,
  79.         newCurrentExisting);
  80.     return dataCollector;
  81.   }

  83.   /*
  84.    * (non-Javadoc)
  85.    * 
  86.    * @see mtas.codec.util.DataCollector.MtasDataCollector#add(long[], int)
  87.    */
  88.   @Override
  89.   public MtasDataCollector<?, ?> add(long[] values, int number)
  90.       throws IOException {
  91.     MtasDataCollector<?, ?> dataCollector = add(false);
  92.     Double[] newValues = new Double[number];
  93.     for (int i = 0; i < values.length; i++)
  94.       newValues[i] = Long.valueOf(values[i]).doubleValue();
  95.     setValue(newCurrentPosition, newValues, number, newCurrentExisting);
  96.     return dataCollector;
  97.   }

  99.   /*
  100.    * (non-Javadoc)
  101.    * 
  102.    * @see mtas.codec.util.DataCollector.MtasDataCollector#add(double, long)
  103.    */
  104.   @Override
  105.   public MtasDataCollector<?, ?> add(double valueSum, long valueN)
  106.       throws IOException {
  107.     MtasDataCollector<?, ?> dataCollector = add(false);
  108.     setValue(newCurrentPosition, valueSum, valueN, newCurrentExisting);
  109.     return dataCollector;
  110.   }

  112.   /*
  113.    * (non-Javadoc)
  114.    * 
  115.    * @see mtas.codec.util.DataCollector.MtasDataCollector#add(double[], int)
  116.    */
  117.   @Override
  118.   public MtasDataCollector<?, ?> add(double[] values, int number)
  119.       throws IOException {
  120.     MtasDataCollector<?, ?> dataCollector = add(false);
  121.     setValue(newCurrentPosition, ArrayUtils.toObject(values), number,
  122.         newCurrentExisting);
  123.     return dataCollector;
  124.   }

  126.   /*
  127.    * (non-Javadoc)
  128.    * 
  129.    * @see
  130.    * mtas.codec.util.DataCollector.MtasDataCollector#add(java.lang.String[],
  131.    * long, long)
  132.    */
  133.   @Override
  134.   public MtasDataCollector<?, ?> add(String key, long valueSum, long valueN)
  135.       throws IOException {
  136.     if (key != null) {
  137.       MtasDataCollector<?, ?> subCollector = add(key, false);
  138.       setValue(newCurrentPosition, Double.valueOf(valueSum), valueN,
  139.           newCurrentExisting);
  140.       return subCollector;
  141.     } else {
  142.       return null;
  143.     }
  144.   }

  146.   /*
  147.    * (non-Javadoc)
  148.    * 
  149.    * @see
  150.    * mtas.codec.util.DataCollector.MtasDataCollector#add(java.lang.String[],
  151.    * long[], int)
  152.    */
  153.   @Override
  154.   public MtasDataCollector<?, ?> add(String key, long[] values, int number)
  155.       throws IOException {
  156.     if (key != null) {
  157.       Double[] newValues = new Double[number];
  158.       for (int i = 0; i < values.length; i++)
  159.         newValues[i] = Long.valueOf(values[i]).doubleValue();
  160.       MtasDataCollector<?, ?> subCollector = add(key, false);
  161.       setValue(newCurrentPosition, newValues, number, newCurrentExisting);
  162.       return subCollector;
  163.     } else {
  164.       return null;
  165.     }
  166.   }

  168.   /*
  169.    * (non-Javadoc)
  170.    * 
  171.    * @see
  172.    * mtas.codec.util.DataCollector.MtasDataCollector#add(java.lang.String[],
  173.    * double, long)
  174.    */
  175.   @Override
  176.   public MtasDataCollector<?, ?> add(String key, double valueSum, long valueN)
  177.       throws IOException {
  178.     if (key != null) {
  179.       MtasDataCollector<?, ?> subCollector = add(key, false);
  180.       setValue(newCurrentPosition, valueSum, valueN, newCurrentExisting);
  181.       return subCollector;
  182.     } else {
  183.       return null;
  184.     }
  185.   }

  187.   /*
  188.    * (non-Javadoc)
  189.    * 
  190.    * @see
  191.    * mtas.codec.util.DataCollector.MtasDataCollector#add(java.lang.String[],
  192.    * double[], int)
  193.    */
  194.   @Override
  195.   public MtasDataCollector<?, ?> add(String key, double[] values, int number)
  196.       throws IOException {
  197.     if (key != null) {
  198.       MtasDataCollector<?, ?> subCollector = add(key, false);
  199.       setValue(newCurrentPosition, ArrayUtils.toObject(values), number,
  200.           newCurrentExisting);
  201.       return subCollector;
  202.     } else {
  203.       return null;
  204.     }
  205.   }

  207.   /*
  208.    * (non-Javadoc)
  209.    * 
  210.    * @see
  211.    * mtas.codec.util.DataCollector.MtasDataCollector#compareForComputingSegment(
  212.    * java.lang.Number, java.lang.Number)
  213.    */
  214.   @Override
  215.   protected boolean compareWithBoundary(Double value, Double boundary)
  216.       throws IOException {
  217.     if (segmentRegistration.equals(SEGMENT_SORT_ASC)
  218.         || segmentRegistration.equals(SEGMENT_BOUNDARY_ASC)) {
  219.       return value <= boundary;
  220.     } else if (segmentRegistration.equals(SEGMENT_SORT_DESC)
  221.         || segmentRegistration.equals(SEGMENT_BOUNDARY_DESC)) {
  222.       return value >= boundary;
  223.     } else {
  224.       throw new IOException(
  225.           "can't compare for segmentRegistration " + segmentRegistration);
  226.     }
  227.   }

  229.   /*
  230.    * (non-Javadoc)
  231.    * 
  232.    * @see
  233.    * mtas.codec.util.DataCollector.MtasDataCollector#minimumForComputingSegment(
  234.    * java.lang.Number, java.lang.Number)
  235.    */
  236.   @Override
  237.   protected Double lastForComputingSegment(Double value, Double boundary)
  238.       throws IOException {
  239.     if (segmentRegistration.equals(SEGMENT_SORT_ASC)) {
  240.       return Math.max(value, boundary);
  241.     } else if (segmentRegistration.equals(SEGMENT_SORT_DESC)) {
  242.       return Math.min(value, boundary);
  243.     } else {
  244.       throw new IOException(
  245.           "can't compute last for segmentRegistration " + segmentRegistration);
  246.     }
  247.   }

  249.   /*
  250.    * (non-Javadoc)
  251.    * 
  252.    * @see
  253.    * mtas.codec.util.DataCollector.MtasDataCollector#minimumForComputingSegment(
  254.    * )
  255.    */
  256.   @Override
  257.   protected Double lastForComputingSegment() throws IOException {
  258.     if (segmentRegistration.equals(SEGMENT_SORT_ASC)
  259.         || segmentRegistration.equals(SEGMENT_BOUNDARY_ASC)) {
  260.       return Collections.max(segmentValueTopList);
  261.     } else if (segmentRegistration.equals(SEGMENT_SORT_DESC)
  262.         || segmentRegistration.equals(SEGMENT_BOUNDARY_DESC)) {
  263.       return Collections.min(segmentValueTopList);
  264.     } else {
  265.       throw new IOException(
  266.           "can't compute last for segmentRegistration " + segmentRegistration);
  267.     }
  268.   }

  270.   /*
  271.    * (non-Javadoc)
  272.    * 
  273.    * @see
  274.    * mtas.codec.util.DataCollector.MtasDataCollector#boundaryForComputingSegment
  275.    * ()
  276.    */
  277.   @Override
  278.   protected Double boundaryForSegmentComputing(String segmentName)
  279.       throws IOException {
  280.     if (segmentRegistration.equals(SEGMENT_SORT_ASC)
  281.         || segmentRegistration.equals(SEGMENT_SORT_DESC)) {
  282.       Double boundary = boundaryForSegment(segmentName);
  283.       if (boundary == null) {
  284.         return null;
  285.       } else {
  286.         if (segmentRegistration.equals(SEGMENT_SORT_DESC)) {
  287.           long correctionBoundary = 0;
  288.           for (String otherSegmentName : segmentValueTopListLast.keySet()) {
  289.             if (!otherSegmentName.equals(segmentName)) {
  290.               Double otherBoundary = segmentValuesBoundary
  291.                   .get(otherSegmentName);
  292.               if (otherBoundary != null) {
  293.                 correctionBoundary += Math.max(0, otherBoundary - boundary);
  294.               }
  295.             }
  296.           }
  297.           return boundary + correctionBoundary;
  298.         } else {
  299.           return boundary;
  300.         }
  301.       }
  302.     } else {
  303.       throw new IOException("can't compute boundary for segmentRegistration "
  304.           + segmentRegistration);
  305.     }
  306.   }

  308.   /*
  309.    * (non-Javadoc)
  310.    * 
  311.    * @see mtas.codec.util.DataCollector.MtasDataCollector#boundaryForSegment()
  312.    */
  313.   @Override
  314.   protected Double boundaryForSegment(String segmentName) throws IOException {
  315.     if (segmentRegistration.equals(SEGMENT_SORT_ASC)
  316.         || segmentRegistration.equals(SEGMENT_SORT_DESC)) {
  317.       Double thisLast = segmentValueTopListLast.get(segmentName);
  318.       if (thisLast == null) {
  319.         return null;
  320.       } else if (segmentRegistration.equals(SEGMENT_SORT_ASC)) {
  321.         return thisLast * segmentNumber;
  322.       } else {
  323.         return thisLast / segmentNumber;
  324.       }
  325.     } else {
  326.       throw new IOException("can't compute boundary for segmentRegistration "
  327.           + segmentRegistration);
  328.     }
  329.   }

  331.   /*
  332.    * (non-Javadoc)
  333.    * 
  334.    * @see
  335.    * mtas.codec.util.collector.MtasDataCollector#stringToBoundary(java.lang.
  336.    * String, java.lang.Integer)
  337.    */
  338.   @Override
  339.   protected Double stringToBoundary(String boundary, Integer segmentNumber)
  340.       throws IOException {
  341.     if (segmentRegistration.equals(SEGMENT_BOUNDARY_ASC)
  342.         || segmentRegistration.equals(SEGMENT_BOUNDARY_DESC)) {
  343.       if (segmentNumber == null) {
  344.         return Double.valueOf(boundary);
  345.       } else {
  346.         return Double.valueOf(boundary) / segmentNumber;
  347.       }
  348.     } else {
  349.       throw new IOException(
  350.           "not available for segmentRegistration " + segmentRegistration);
  351.     }
  352.   }

  354.   /*
  355.    * (non-Javadoc)
  356.    * 
  357.    * @see
  358.    * mtas.codec.util.collector.MtasDataCollector#validateSegmentBoundary(java.
  359.    * lang.Object)
  360.    */
  361.   @Override
  362.   public boolean validateSegmentBoundary(Object o) throws IOException {
  363.     if (o instanceof Double) {
  364.       return validateWithSegmentBoundary((Double) o);
  365.     } else {
  366.       throw new IOException("incorrect type");
  367.     }
  368.   }

  370. }
Created with JaCoCo 0.7.9.201702052155