Coverage Report - org.perfidix.element.BenchmarkElement
 
Classes in this File Line Coverage Branch Coverage Complexity
BenchmarkElement
76%
26/34
50%
9/18
2.5
 
 1  
 /**
 2  
  * Copyright (c) 2012, University of Konstanz, Distributed Systems Group
 3  
  * All rights reserved.
 4  
  * 
 5  
  * Redistribution and use in source and binary forms, with or without
 6  
  * modification, are permitted provided that the following conditions are met:
 7  
  * * Redistributions of source code must retain the above copyright
 8  
  * notice, this list of conditions and the following disclaimer.
 9  
  * * Redistributions in binary form must reproduce the above copyright
 10  
  * notice, this list of conditions and the following disclaimer in the
 11  
  * documentation and/or other materials provided with the distribution.
 12  
  * * Neither the name of the University of Konstanz nor the
 13  
  * names of its contributors may be used to endorse or promote products
 14  
  * derived from this software without specific prior written permission.
 15  
  * 
 16  
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 17  
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 18  
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 19  
  * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
 20  
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 21  
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 22  
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 23  
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 24  
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 25  
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 26  
  */
 27  
 package org.perfidix.element;
 28  
 
 29  
 import java.util.Hashtable;
 30  
 import java.util.Map;
 31  
 
 32  
 /**
 33  
  * This class acts as a container related to one benchmarkable method. This
 34  
  * class has an unique identifier for one execution.
 35  
  * 
 36  
  * @see BenchmarkMethod
 37  
  * @author Sebastian Graf, University of Konstanz
 38  
  */
 39  
 public final class BenchmarkElement {
 40  
 
 41  
     /** The BenchmarkMethod related to this element. */
 42  
     private transient final BenchmarkMethod meth;
 43  
 
 44  
     /** The unique elementId for this elements. */
 45  
     private transient final int elementId;
 46  
 
 47  
     /**
 48  
      * Static Mapping for BenchmarkMethod->Integer. Every BenchmarkMethod gains
 49  
      * one unique elementId from this mapping.
 50  
      */
 51  5
     private static final Map<BenchmarkMethod, Integer> ID_MAPPING = new Hashtable<BenchmarkMethod, Integer>();
 52  
 
 53  
     /**
 54  
      * Constructor, simple taking the corresponding {@link BenchmarkMethod}.
 55  
      * 
 56  
      * @param paramMeth
 57  
      *            the related {@link BenchmarkMethod}
 58  
      */
 59  4090
     public BenchmarkElement(final BenchmarkMethod paramMeth) {
 60  4090
         meth = paramMeth;
 61  4090
         if (!ID_MAPPING.containsKey(paramMeth)) {
 62  115
             ID_MAPPING.put(getMeth(), 0);
 63  
         }
 64  4090
         elementId = ID_MAPPING.get(getMeth()) + 1;
 65  4090
         ID_MAPPING.put(getMeth(), getId());
 66  
 
 67  4090
     }
 68  
 
 69  
     /**
 70  
      * Getter for the elementId.
 71  
      * 
 72  
      * @return the elementId of this element
 73  
      */
 74  
     public int getId() {
 75  4100
         return elementId;
 76  
     }
 77  
 
 78  
     /**
 79  
      * Getting the {@link BenchmarkMethod} related to this element.
 80  
      * 
 81  
      * @return the meth
 82  
      */
 83  
     public BenchmarkMethod getMeth() {
 84  26990
         return meth;
 85  
     }
 86  
 
 87  
     /** {@inheritDoc} */
 88  
     @Override
 89  
     public int hashCode() {
 90  10
         final int prime = 31;
 91  10
         int result = 1;
 92  10
         result = prime * result + elementId;
 93  10
         if (meth == null) {
 94  0
             result = prime * result;
 95  
         } else {
 96  10
             result = prime * result + meth.hashCode();
 97  
         }
 98  10
         return result;
 99  
     }
 100  
 
 101  
     /** {@inheritDoc} */
 102  
     @Override
 103  
     public boolean equals(final Object obj) {
 104  5
         boolean returnVal = true;
 105  5
         if (this == obj) {
 106  0
             returnVal = true;
 107  
         }
 108  5
         if (obj == null) {
 109  0
             returnVal = false;
 110  
         }
 111  5
         if (getClass() != obj.getClass()) {
 112  0
             returnVal = false;
 113  
         }
 114  5
         final BenchmarkElement other = (BenchmarkElement)obj;
 115  5
         if (elementId != other.elementId) {
 116  5
             returnVal = false;
 117  
         }
 118  5
         if (meth == null) {
 119  0
             if (other.meth != null) {
 120  0
                 returnVal = false;
 121  
             }
 122  
         } else {
 123  5
             if (!meth.equals(other.meth)) {
 124  0
                 returnVal = false;
 125  
             }
 126  
         }
 127  5
         return returnVal;
 128  
     }
 129  
 
 130  
     /**
 131  
      * {@inheritDoc}
 132  
      */
 133  
     @Override
 134  
     public String toString() {
 135  0
         return new StringBuilder(meth.toString()).append(":").append(elementId).toString();
 136  
     }
 137  
 
 138  
 }