Coverage Report

Coverage Report - org.perfidix.example.stack.FastIntStack

Classes in this File

Line Coverage

Branch Coverage

Complexity

FastIntStack

69%

9/13

N/A

 /**
  * Copyright (c) 2012, University of Konstanz, Distributed Systems Group
  * All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  * * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  * * Redistributions in binary form must reproduce the above copyright
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution.
  * * Neither the name of the University of Konstanz nor the
  * names of its contributors may be used to endorse or promote products
  * derived from this software without specific prior written permission.
  * 
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 package org.perfidix.example.stack;
 
 import java.util.LinkedList;
 
 /**
  * <h1>FastLongStack</h1>
  * <p>
  * Unsynchronized stack optimized for long primitive type. Is significantly faster than a normal Stack.
  * </p>
  * 
  * @author Marc Kramis, University of Konstanz / Seabix
  */
 public final class FastIntStack {
 
     /** Internal linked list to store stack elements. */
     private transient LinkedList<Integer> stack;
 
     /**
      * Constructor.
      */
     public FastIntStack() {
         stack = new LinkedList<Integer>();
     }
 
     /**
      * Place new element on top of stack.
      * 
      * @param element
      *            Element to push.
      */
     public void push(final int element) {
         stack.addLast(element);
     }
 
     /**
      * Get the element on top of the stack. The internal array performs boundary
      * checks.
      * 
      * @return Topmost stack element.
      */
     public int peek() {
         return stack.getLast().intValue();
     }
 
     /**
      * Get element at given position in stack. The internal array performs
      * boundary checks.
      * 
      * @param position
      *            Position in stack from where to get the element.
      * @return Stack element at given position.
      */
     public int get(final int position) {
         return stack.get(position);
     }
 
     /**
      * Remove topmost element from stack.
      * 
      * @return Removed topmost element of stack.
      */
     public int pop() {
         int last = stack.getLast();
         stack.removeLast();
         return last;
     }
 
     /**
      * Reset the stack.
      */
     public void clear() {
         stack.clear();
     }
 
     /**
      * Get the current stackSize of the stack.
      * 
      * @return stackSize of stack.
      */
     public int size() {
         return stack.size();
     }
 
 }

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.example.stack;
28
29		import java.util.LinkedList;
30
31		/**
32		* <h1>FastLongStack</h1>
33		* <p>
34		* Unsynchronized stack optimized for long primitive type. Is significantly faster than a normal Stack.
35		* </p>
36		*
37		* @author Marc Kramis, University of Konstanz / Seabix
38		*/
39		public final class FastIntStack {
40
41		/** Internal linked list to store stack elements. */
42		private transient LinkedList<Integer> stack;
43
44		/**
45		* Constructor.
46		*/
47	1000	public FastIntStack() {
48	1000	stack = new LinkedList<Integer>();
49	1000	}
50
51		/**
52		* Place new element on top of stack.
53		*
54		* @param element
55		* Element to push.
56		*/
57		public void push(final int element) {
58	100000	stack.addLast(element);
59	100000	}
60
61		/**
62		* Get the element on top of the stack. The internal array performs boundary
63		* checks.
64		*
65		* @return Topmost stack element.
66		*/
67		public int peek() {
68	0	return stack.getLast().intValue();
69		}
70
71		/**
72		* Get element at given position in stack. The internal array performs
73		* boundary checks.
74		*
75		* @param position
76		* Position in stack from where to get the element.
77		* @return Stack element at given position.
78		*/
79		public int get(final int position) {
80	0	return stack.get(position);
81		}
82
83		/**
84		* Remove topmost element from stack.
85		*
86		* @return Removed topmost element of stack.
87		*/
88		public int pop() {
89	50000	int last = stack.getLast();
90	50000	stack.removeLast();
91	50000	return last;
92		}
93
94		/**
95		* Reset the stack.
96		*/
97		public void clear() {
98	0	stack.clear();
99	0	}
100
101		/**
102		* Get the current stackSize of the stack.
103		*
104		* @return stackSize of stack.
105		*/
106		public int size() {
107	50500	return stack.size();
108		}
109
110		}