Coverage Report

Coverage Report - com.allanbank.mongodb.client.VersionRange

Classes in this File

Line Coverage

Branch Coverage

Complexity

VersionRange

94%

36/38

91%

22/24

2.5

 /*
  * #%L
  * VersionRange.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.client;
 
 import java.io.Serializable;
 
 import com.allanbank.mongodb.Version;
 
 /**
  * VersionRange provides a simple class to hold a range of versions.
  * 
  * @api.no This class is <b>NOT</b> part of the drivers API. This class may be
  *         mutated in incompatible ways between any two releases of the driver.
  * @copyright 2014, Allanbank Consulting, Inc., All Rights Reserved
  */
 public class VersionRange implements Serializable {
     /** Serialization version for the class. */
     private static final long serialVersionUID = 7841643157458023019L;
 
     /**
      * Returns a {@link VersionRange} that is only limited by a maximum version.
      * The minimum version is set to {@link Version#VERSION_0}.
      * 
      * @param maxVersion
      *            The maximum version in the range. If <code>null</code> then
      *            <code>null</code> is returned.
      * @return The version range with only a maximum value.
      */
     public static VersionRange maximum(final Version maxVersion) {
         if (maxVersion != null) {
             return new VersionRange(Version.VERSION_0, maxVersion);
         }
         return null;
     }
 
     /**
      * Returns a {@link VersionRange} that is only limited by a minimum version.
      * The maximum version is set to {@link Version#UNKNOWN}.
      * 
      * @param minVersion
      *            The minimum version in the range. If <code>null</code> then
      *            <code>null</code> is returned.
      * @return The version range with only a minimum value.
      */
     public static VersionRange minimum(final Version minVersion) {
         if (minVersion != null) {
             return new VersionRange(minVersion, Version.UNKNOWN);
         }
         return null;
     }
 
     /**
      * Returns a {@link VersionRange} based on the minimum and maximum versions
      * provided.
      * <p>
      * If {@code minVersion} and {@code maxVersion} are both <code>null</code>
      * then <code>null</code> is returned.
      * </p>
      * <p>
      * If only {@code minVersion} is <code>null</code> then the lower bound is
      * set to {@link Version#VERSION_0}.
      * </p>
      * <p>
      * If only {@code maxVersion} is <code>null</code> then the upper bound is
      * set to {@link Version#UNKNOWN}.
      * </p>
      * 
      * @param minVersion
      *            The minimum version in the range. If <code>null</code> then
      *            <code>null</code> is returned.
      * @param maxVersion
      *            The maximum version in the range. If <code>null</code> then
      *            <code>null</code> is returned.
      * @return The version range with only a minimum value.
      */
     public static VersionRange range(final Version minVersion,
             final Version maxVersion) {
         if (minVersion != null) {
             if (maxVersion != null) {
                 return new VersionRange(minVersion, maxVersion);
             }
             return new VersionRange(minVersion, Version.UNKNOWN);
         }
         else if (maxVersion != null) {
             return new VersionRange(Version.VERSION_0, maxVersion);
         }
         return null;
     }
 
     /** The lower, inclusive, bounds of the range. */
     private final Version myLowerBounds;
 
     /** The upper, exclusive, bounds of the range. */
     private final Version myUpperBounds;
 
     /**
      * Creates a new VersionRange.
      * 
      * @param lowerBounds
      *            The lower, inclusive, bounds of the range.
      * @param upperBounds
      *            The upper, exclusive, bounds of the range.
      */
     private VersionRange(final Version lowerBounds, final Version upperBounds) {
         myLowerBounds = lowerBounds;
         myUpperBounds = upperBounds;
     }
 
     /**
      * Returns true if the version is within the bounds of this
      * {@link VersionRange}.
      * 
      * @param version
      *            The version to check if it is within range.
      * @return True if the version is within the bounds of this
      *         {@link VersionRange}.
      */
     public boolean contains(final Version version) {
         return (myLowerBounds.compareTo(version) <= 0)
                 && (myUpperBounds.compareTo(version) > 0);
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to compare this {@link VersionRange} to the other.
      * </p>
      */
     @Override
     public boolean equals(final Object object) {
         boolean result = false;
         if (this == object) {
             result = true;
         }
         else if ((object != null) && (getClass() == object.getClass())) {
             final VersionRange other = (VersionRange) object;
 
             result = myLowerBounds.equals(other.myLowerBounds)
                     && myUpperBounds.equals(other.myUpperBounds);
         }
         return result;
     }
 
     /**
      * Returns the lower, inclusive, bounds of the range.
      * 
      * @return The lower, inclusive, bounds of the range.
      */
     public Version getLowerBounds() {
         return myLowerBounds;
     }
 
     /**
      * Returns the upper, exclusive, bounds of the range.
      * 
      * @return The upper, exclusive, bounds of the range.
      */
     public Version getUpperBounds() {
         return myUpperBounds;
     }
 
     /**
      * {@inheritDoc}
      * <p>
      * Overridden to hash the version range.
      * </p>
      */
     @Override
     public int hashCode() {
         int result = 1;
         result = (31 * result) + myLowerBounds.hashCode();
         result = (31 * result) + myUpperBounds.hashCode();
         return result;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public String toString() {
         final StringBuilder builder = new StringBuilder();
 
         builder.append("[");
         builder.append(myLowerBounds);
         builder.append(", ");
         builder.append(myUpperBounds);
         builder.append(")");
 
         return builder.toString();
     }
 }

1		/*
2		* #%L
3		* VersionRange.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.client;
21
22		import java.io.Serializable;
23
24		import com.allanbank.mongodb.Version;
25
26		/**
27		* VersionRange provides a simple class to hold a range of versions.
28		*
29		* @api.no This class is <b>NOT</b> part of the drivers API. This class may be
30		* mutated in incompatible ways between any two releases of the driver.
31		* @copyright 2014, Allanbank Consulting, Inc., All Rights Reserved
32		*/
33		public class VersionRange implements Serializable {
34		/** Serialization version for the class. */
35		private static final long serialVersionUID = 7841643157458023019L;
36
37		/**
38		* Returns a {@link VersionRange} that is only limited by a maximum version.
39		* The minimum version is set to {@link Version#VERSION_0}.
40		*
41		* @param maxVersion
42		* The maximum version in the range. If <code>null</code> then
43		* <code>null</code> is returned.
44		* @return The version range with only a maximum value.
45		*/
46		public static VersionRange maximum(final Version maxVersion) {
47	18	if (maxVersion != null) {
48	18	return new VersionRange(Version.VERSION_0, maxVersion);
49		}
50	0	return null;
51		}
52
53		/**
54		* Returns a {@link VersionRange} that is only limited by a minimum version.
55		* The maximum version is set to {@link Version#UNKNOWN}.
56		*
57		* @param minVersion
58		* The minimum version in the range. If <code>null</code> then
59		* <code>null</code> is returned.
60		* @return The version range with only a minimum value.
61		*/
62		public static VersionRange minimum(final Version minVersion) {
63	271	if (minVersion != null) {
64	134	return new VersionRange(minVersion, Version.UNKNOWN);
65		}
66	137	return null;
67		}
68
69		/**
70		* Returns a {@link VersionRange} based on the minimum and maximum versions
71		* provided.
72		* <p>
73		* If {@code minVersion} and {@code maxVersion} are both <code>null</code>
74		* then <code>null</code> is returned.
75		* </p>
76		* <p>
77		* If only {@code minVersion} is <code>null</code> then the lower bound is
78		* set to {@link Version#VERSION_0}.
79		* </p>
80		* <p>
81		* If only {@code maxVersion} is <code>null</code> then the upper bound is
82		* set to {@link Version#UNKNOWN}.
83		* </p>
84		*
85		* @param minVersion
86		* The minimum version in the range. If <code>null</code> then
87		* <code>null</code> is returned.
88		* @param maxVersion
89		* The maximum version in the range. If <code>null</code> then
90		* <code>null</code> is returned.
91		* @return The version range with only a minimum value.
92		*/
93		public static VersionRange range(final Version minVersion,
94		final Version maxVersion) {
95	2941	if (minVersion != null) {
96	605	if (maxVersion != null) {
97	593	return new VersionRange(minVersion, maxVersion);
98		}
99	12	return new VersionRange(minVersion, Version.UNKNOWN);
100		}
101	2336	else if (maxVersion != null) {
102	0	return new VersionRange(Version.VERSION_0, maxVersion);
103		}
104	2336	return null;
105		}
106
107		/** The lower, inclusive, bounds of the range. */
108		private final Version myLowerBounds;
109
110		/** The upper, exclusive, bounds of the range. */
111		private final Version myUpperBounds;
112
113		/**
114		* Creates a new VersionRange.
115		*
116		* @param lowerBounds
117		* The lower, inclusive, bounds of the range.
118		* @param upperBounds
119		* The upper, exclusive, bounds of the range.
120		*/
121	757	private VersionRange(final Version lowerBounds, final Version upperBounds) {
122	757	myLowerBounds = lowerBounds;
123	757	myUpperBounds = upperBounds;
124	757	}
125
126		/**
127		* Returns true if the version is within the bounds of this
128		* {@link VersionRange}.
129		*
130		* @param version
131		* The version to check if it is within range.
132		* @return True if the version is within the bounds of this
133		* {@link VersionRange}.
134		*/
135		public boolean contains(final Version version) {
136	7	return (myLowerBounds.compareTo(version) <= 0)
137		&& (myUpperBounds.compareTo(version) > 0);
138		}
139
140		/**
141		* {@inheritDoc}
142		* <p>
143		* Overridden to compare this {@link VersionRange} to the other.
144		* </p>
145		*/
146		@Override
147		public boolean equals(final Object object) {
148	3487	boolean result = false;
149	3487	if (this == object) {
150	80	result = true;
151		}
152	3407	else if ((object != null) && (getClass() == object.getClass())) {
153	3247	final VersionRange other = (VersionRange) object;
154
155	3247	result = myLowerBounds.equals(other.myLowerBounds)
156		&& myUpperBounds.equals(other.myUpperBounds);
157		}
158	3487	return result;
159		}
160
161		/**
162		* Returns the lower, inclusive, bounds of the range.
163		*
164		* @return The lower, inclusive, bounds of the range.
165		*/
166		public Version getLowerBounds() {
167	111	return myLowerBounds;
168		}
169
170		/**
171		* Returns the upper, exclusive, bounds of the range.
172		*
173		* @return The upper, exclusive, bounds of the range.
174		*/
175		public Version getUpperBounds() {
176	13	return myUpperBounds;
177		}
178
179		/**
180		* {@inheritDoc}
181		* <p>
182		* Overridden to hash the version range.
183		* </p>
184		*/
185		@Override
186		public int hashCode() {
187	6480	int result = 1;
188	6480	result = (31 * result) + myLowerBounds.hashCode();
189	6480	result = (31 * result) + myUpperBounds.hashCode();
190	6480	return result;
191		}
192
193		/**
194		* {@inheritDoc}
195		*/
196		@Override
197		public String toString() {
198	2260	final StringBuilder builder = new StringBuilder();
199
200	2260	builder.append("[");
201	2260	builder.append(myLowerBounds);
202	2260	builder.append(", ");
203	2260	builder.append(myUpperBounds);
204	2260	builder.append(")");
205
206	2260	return builder.toString();
207		}
208		}