Coverage Report

Coverage Report - com.allanbank.mongodb.ProfilingStatus

Classes in this File

Line Coverage

Branch Coverage

Complexity

ProfilingStatus

97%

38/39

95%

23/24

2.308

ProfilingStatus$Level

100%

12/12

100%

4/4

2.308

 /*
  * #%L
  * ProfilingStatus.java - mongodb-async-driver - Allanbank Consulting, Inc.
  * %%
  * Copyright (C) 2011 - 2014 Allanbank Consulting, Inc.
  * %%
  * Licensed 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.
  * #L%
  */
 package com.allanbank.mongodb;
 
 import java.io.Serializable;
 
 /**
  * ProfilingStatus provides a container for the {@link Level} and number of
  * milliseconds beyond which to consider an operation to be slow.
  * 
  * @api.yes This class is part of the driver's API. Public and protected members
  *          will be deprecated for at least 1 non-bugfix release (version
  *          numbers are &lt;major&gt;.&lt;minor&gt;.&lt;bugfix&gt;) before being
  *          removed or modified.
  * @copyright 2012-2013, Allanbank Consulting, Inc., All Rights Reserved
  */
 public class ProfilingStatus implements Comparable<ProfilingStatus>,
         Serializable {
 
     /**
      * The default threshold ({@value} )for the number of milliseconds beyond
      * considering an operation slow.
      */
     public static final long DEFAULT_SLOW_MS = 100;
 
     /** The off profiling state. */
     public static final ProfilingStatus OFF = new ProfilingStatus(Level.NONE);
 
     /** The all profiling state. */
     public static final ProfilingStatus ON = new ProfilingStatus(Level.ALL);
 
     /** The serialization version of the class. */
     private static final long serialVersionUID = 181636899391154872L;
 
     /**
      * Creates a profiling state to profile operations taking more than
      * {@code slowMillis} to complete.
      * 
      * @param slowMillis
      *            The number of milliseconds beyond which to consider an
      *            operation to be slow.
      * @return The slow profiling state.
      */
     public static final ProfilingStatus slow(final int slowMillis) {
         return new ProfilingStatus(Level.SLOW_ONLY, slowMillis);
     }
 
     /** The profiling level. */
     private final Level myLevel;
 
     /**
      * The number of milliseconds beyond which to consider an operation to be
      * slow.
      */
     private final long mySlowMillisThreshold;
 
     /**
      * Creates a new ProfilingStatus.
      * 
      * @param level
      *            The profiling level to use.
      */
     private ProfilingStatus(final Level level) {
         this(level, DEFAULT_SLOW_MS);
     }
 
     /**
      * Creates a new ProfilingStatus.
      * 
      * @param level
      *            The profiling level to use.
      * @param slowMillis
      *            The number of milliseconds beyond which to consider an
      *            operation to be slow.
      */
     private ProfilingStatus(final Level level, final long slowMillis) {
         myLevel = level;
         mySlowMillisThreshold = slowMillis;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to return an ordering based on the tuple ordering of (level,
      * slowMs).
      * </p>
      */
     @Override
     public int compareTo(final ProfilingStatus other) {
         int diff = myLevel.getValue() - other.myLevel.getValue();
         if (diff == 0) {
             if (mySlowMillisThreshold < other.mySlowMillisThreshold) {
                 diff = -1;
             }
             else if (mySlowMillisThreshold == other.mySlowMillisThreshold) {
                 diff = 0;
             }
             else {
                 diff = 1;
             }
 
         }
         return diff;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to compare this object to the passed object.
      * </p>
      */
     @Override
     public boolean equals(final Object object) {
         boolean result = false;
         if (this == object) {
             result = true;
         }
         else if ((object != null) && (getClass() == object.getClass())) {
             final ProfilingStatus other = (ProfilingStatus) object;
 
             result = (myLevel == other.myLevel)
                     && (mySlowMillisThreshold == other.mySlowMillisThreshold);
         }
         return result;
     }
 
     /**
      * Returns the profiling level to use.
      * 
      * @return The profiling level to use.
      */
     public Level getLevel() {
         return myLevel;
     }
 
     /**
      * Returns the number of milliseconds beyond which to consider an operation
      * to be slow.
      * 
      * @return The number of milliseconds beyond which to consider an operation
      *         to be slow.
      */
     public long getSlowMillisThreshold() {
         return mySlowMillisThreshold;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to generate a suitable hash of the objects state.
      * </p>
      */
     @Override
     public int hashCode() {
         int result = 1;
         result = (31 * result) + ((myLevel == null) ? 0 : myLevel.hashCode());
         result = (31 * result)
                 + (int) (mySlowMillisThreshold ^ (mySlowMillisThreshold >>> 32));
         return result;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to return a readable form of the object.
      * </p>
      */
     @Override
     public String toString() {
         if (myLevel == Level.SLOW_ONLY) {
             return myLevel.name() + "(" + mySlowMillisThreshold + " ms)";
         }
         return myLevel.name();
     }
 
     /**
      * Hook into serialization to replace <tt>this</tt> object with the local
      * {@link #ON} or {@link #OFF} instance as appropriate.
      * 
      * @return Either the {@link #ON} or {@link #OFF} instance if <tt>this</tt>
      *         instance equals one of those instances otherwise <tt>this</tt>
      *         instance.
      */
     private Object readResolve() {
         if (this.equals(ON)) {
             return ON;
         }
         else if (this.equals(OFF)) {
             return OFF;
         }
         else {
             return this;
         }
     }
 
     /**
      * Level provides the set of available profiling levels provided by the
      * MongoDB server.
      * 
      * @api.yes This class is part of the driver's API. Public and protected
      *          members will be deprecated for at least 1 non-bugfix release
      *          (version numbers are &lt;major&gt;.&lt;minor&gt;.&lt;bugfix&gt;)
      *          before being removed or modified.
      * @copyright 2012-2013, Allanbank Consulting, Inc., All Rights Reserved
      */
     public static enum Level {
 
         /** Profile all operations. */
         ALL(2),
 
         /** Profile no operations. */
         NONE(0),
 
         /** Only profile slow operations. */
         SLOW_ONLY(1);
 
         /**
          * Returns the {@link Level} for the specified value.
          * 
          * @param value
          *            The value of the profile level.
          * @return The profile level for the value.
          */
         public static Level fromValue(final int value) {
             for (final Level level : values()) {
                 if (level.getValue() == value) {
                     return level;
                 }
             }
 
             return null;
         }
 
         /** The profile level value to send to MongoDB. */
         private final int myValue;
 
         /**
          * Creates a new Level.
          * 
          * @param value
          *            The profile level value to send to MongoDB.
          */
         private Level(final int value) {
             myValue = value;
         }
 
         /**
          * Returns the profile level value to send to MongoDB.
          * 
          * @return The profile level value to send to MongoDB.
          */
         public int getValue() {
             return myValue;
         }
     }
 }

1		/*
2		* #%L
3		* ProfilingStatus.java - mongodb-async-driver - Allanbank Consulting, Inc.
4		* %%
5		* Copyright (C) 2011 - 2014 Allanbank Consulting, Inc.
6		* %%
7		* Licensed under the Apache License, Version 2.0 (the "License");
8		* you may not use this file except in compliance with the License.
9		* You may obtain a copy of the License at
10		*
11		* http://www.apache.org/licenses/LICENSE-2.0
12		*
13		* Unless required by applicable law or agreed to in writing, software
14		* distributed under the License is distributed on an "AS IS" BASIS,
15		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16		* See the License for the specific language governing permissions and
17		* limitations under the License.
18		* #L%
19		*/
20		package com.allanbank.mongodb;
21
22		import java.io.Serializable;
23
24		/**
25		* ProfilingStatus provides a container for the {@link Level} and number of
26		* milliseconds beyond which to consider an operation to be slow.
27		*
28		* @api.yes This class is part of the driver's API. Public and protected members
29		* will be deprecated for at least 1 non-bugfix release (version
30		* numbers are <major>.<minor>.<bugfix>) before being
31		* removed or modified.
32		* @copyright 2012-2013, Allanbank Consulting, Inc., All Rights Reserved
33		*/
34	0	public class ProfilingStatus implements Comparable<ProfilingStatus>,
35		Serializable {
36
37		/**
38		* The default threshold ({@value} )for the number of milliseconds beyond
39		* considering an operation slow.
40		*/
41		public static final long DEFAULT_SLOW_MS = 100;
42
43		/** The off profiling state. */
44	1	public static final ProfilingStatus OFF = new ProfilingStatus(Level.NONE);
45
46		/** The all profiling state. */
47	1	public static final ProfilingStatus ON = new ProfilingStatus(Level.ALL);
48
49		/** The serialization version of the class. */
50		private static final long serialVersionUID = 181636899391154872L;
51
52		/**
53		* Creates a profiling state to profile operations taking more than
54		* {@code slowMillis} to complete.
55		*
56		* @param slowMillis
57		* The number of milliseconds beyond which to consider an
58		* operation to be slow.
59		* @return The slow profiling state.
60		*/
61		public static final ProfilingStatus slow(final int slowMillis) {
62	36	return new ProfilingStatus(Level.SLOW_ONLY, slowMillis);
63		}
64
65		/** The profiling level. */
66		private final Level myLevel;
67
68		/**
69		* The number of milliseconds beyond which to consider an operation to be
70		* slow.
71		*/
72		private final long mySlowMillisThreshold;
73
74		/**
75		* Creates a new ProfilingStatus.
76		*
77		* @param level
78		* The profiling level to use.
79		*/
80		private ProfilingStatus(final Level level) {
81	2	this(level, DEFAULT_SLOW_MS);
82	2	}
83
84		/**
85		* Creates a new ProfilingStatus.
86		*
87		* @param level
88		* The profiling level to use.
89		* @param slowMillis
90		* The number of milliseconds beyond which to consider an
91		* operation to be slow.
92		*/
93	38	private ProfilingStatus(final Level level, final long slowMillis) {
94	38	myLevel = level;
95	38	mySlowMillisThreshold = slowMillis;
96	38	}
97
98		/**
99		* {@inheritDoc}
100		* <p>
101		* Overridden to return an ordering based on the tuple ordering of (level,
102		* slowMs).
103		* </p>
104		*/
105		@Override
106		public int compareTo(final ProfilingStatus other) {
107	16	int diff = myLevel.getValue() - other.myLevel.getValue();
108	16	if (diff == 0) {
109	6	if (mySlowMillisThreshold < other.mySlowMillisThreshold) {
110	1	diff = -1;
111		}
112	5	else if (mySlowMillisThreshold == other.mySlowMillisThreshold) {
113	4	diff = 0;
114		}
115		else {
116	1	diff = 1;
117		}
118
119		}
120	16	return diff;
121		}
122
123		/**
124		* {@inheritDoc}
125		* <p>
126		* Overridden to compare this object to the passed object.
127		* </p>
128		*/
129		@Override
130		public boolean equals(final Object object) {
131	83	boolean result = false;
132	83	if (this == object) {
133	13	result = true;
134		}
135	70	else if ((object != null) && (getClass() == object.getClass())) {
136	52	final ProfilingStatus other = (ProfilingStatus) object;
137
138	52	result = (myLevel == other.myLevel)
139		&& (mySlowMillisThreshold == other.mySlowMillisThreshold);
140		}
141	83	return result;
142		}
143
144		/**
145		* Returns the profiling level to use.
146		*
147		* @return The profiling level to use.
148		*/
149		public Level getLevel() {
150	17	return myLevel;
151		}
152
153		/**
154		* Returns the number of milliseconds beyond which to consider an operation
155		* to be slow.
156		*
157		* @return The number of milliseconds beyond which to consider an operation
158		* to be slow.
159		*/
160		public long getSlowMillisThreshold() {
161	13	return mySlowMillisThreshold;
162		}
163
164		/**
165		* {@inheritDoc}
166		* <p>
167		* Overridden to generate a suitable hash of the objects state.
168		* </p>
169		*/
170		@Override
171		public int hashCode() {
172	90	int result = 1;
173	90	result = (31 * result) + ((myLevel == null) ? 0 : myLevel.hashCode());
174	90	result = (31 * result)
175		+ (int) (mySlowMillisThreshold ^ (mySlowMillisThreshold >>> 32));
176	90	return result;
177		}
178
179		/**
180		* {@inheritDoc}
181		* <p>
182		* Overridden to return a readable form of the object.
183		* </p>
184		*/
185		@Override
186		public String toString() {
187	74	if (myLevel == Level.SLOW_ONLY) {
188	58	return myLevel.name() + "(" + mySlowMillisThreshold + " ms)";
189		}
190	16	return myLevel.name();
191		}
192
193		/**
194		* Hook into serialization to replace <tt>this</tt> object with the local
195		* {@link #ON} or {@link #OFF} instance as appropriate.
196		*
197		* @return Either the {@link #ON} or {@link #OFF} instance if <tt>this</tt>
198		* instance equals one of those instances otherwise <tt>this</tt>
199		* instance.
200		*/
201		private Object readResolve() {
202	3	if (this.equals(ON)) {
203	1	return ON;
204		}
205	2	else if (this.equals(OFF)) {
206	1	return OFF;
207		}
208		else {
209	1	return this;
210		}
211		}
212
213		/**
214		* Level provides the set of available profiling levels provided by the
215		* MongoDB server.
216		*
217		* @api.yes This class is part of the driver's API. Public and protected
218		* members will be deprecated for at least 1 non-bugfix release
219		* (version numbers are <major>.<minor>.<bugfix>)
220		* before being removed or modified.
221		* @copyright 2012-2013, Allanbank Consulting, Inc., All Rights Reserved
222		*/
223	16	public static enum Level {
224
225		/** Profile all operations. */
226	1	ALL(2),
227
228		/** Profile no operations. */
229	1	NONE(0),
230
231		/** Only profile slow operations. */
232	1	SLOW_ONLY(1);
233
234		/**
235		* Returns the {@link Level} for the specified value.
236		*
237		* @param value
238		* The value of the profile level.
239		* @return The profile level for the value.
240		*/
241		public static Level fromValue(final int value) {
242	26	for (final Level level : values()) {
243	24	if (level.getValue() == value) {
244	9	return level;
245		}
246		}
247
248	2	return null;
249		}
250
251		/** The profile level value to send to MongoDB. */
252		private final int myValue;
253
254		/**
255		* Creates a new Level.
256		*
257		* @param value
258		* The profile level value to send to MongoDB.
259		*/
260	3	private Level(final int value) {
261	3	myValue = value;
262	3	}
263
264		/**
265		* Returns the profile level value to send to MongoDB.
266		*
267		* @return The profile level value to send to MongoDB.
268		*/
269		public int getValue() {
270	65	return myValue;
271		}
272		}
273		}