utils/src/main/java/org/apache/felix/utils/version/VersionRange.java - felix - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you 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.
  */
 package org.apache.felix.utils.version;

 import java.io.Serializable;

 import org.osgi.framework.Version;

 public class VersionRange implements Serializable
 {

     /**
      *
      */
     private static final long serialVersionUID = 1L;

     public static final Version INFINITE_VERSION = new Version( Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, "" );
     public static final VersionRange ANY_VERSION = new VersionRange( false, Version.emptyVersion, INFINITE_VERSION, true );

     public static final int EXACT = 0;
     public static final int MICRO = 1;
     public static final int MINOR = 2;
     public static final int MAJOR = 3;
     public static final int ANY   = 40;

     private final boolean openFloor;
     private final Version floor;
     private final Version ceiling;
     private final boolean openCeiling;


     /**
      * Interval constructor
      *
      * @param openFloor Whether the lower bound of the range is inclusive (false) or exclusive (true).
      * @param floor The lower bound version of the range.
      * @param ceiling The upper bound version of the range.
      * @param openCeiling Whether the upper bound of the range is inclusive (false) or exclusive (true).
      */
     public VersionRange( boolean openFloor, Version floor, Version ceiling, boolean openCeiling )
     {
         this.openFloor = openFloor;
         this.floor = floor;
         this.ceiling = ceiling;
         this.openCeiling = openCeiling;
         checkRange();
     }


     /**
      * atLeast constructor
      *
      * @param atLeast Minimum version
      */
     public VersionRange( Version atLeast )
     {
         this( atLeast, false );
     }

     /**
      * atLeast constructor
      *
      * @param atLeast Minimum version
      * @param exact Exact range
      */
     public VersionRange( Version atLeast, boolean exact )
     {

         this.openFloor = false;
         this.floor = atLeast;
         this.ceiling = exact ? atLeast : INFINITE_VERSION;
         this.openCeiling = exact ? false : true;
         checkRange();
     }


     public VersionRange( String val ) throws IllegalArgumentException, NumberFormatException
     {
         this( val, false );
     }

     public VersionRange( String val, boolean exact ) throws IllegalArgumentException, NumberFormatException
     {
         this( val, exact, true );
     }

     public VersionRange( String val, boolean exact, boolean clean ) throws IllegalArgumentException, NumberFormatException
     {
         val = removeQuotesAndWhitespaces(val);
         int fst = val.charAt( 0 );
         if ( fst == '[' )
         {
             openFloor = false;
         }
         else if ( fst == '(' )
         {
             openFloor = true;
         }
         else
         {
             openFloor = false;
             floor = VersionTable.getVersion( val, clean );
             ceiling = exact ? floor : INFINITE_VERSION;
             openCeiling = exact ? false : true;
             return;
         }

         int lst = val.charAt( val.length() - 1 );
         if ( lst == ']' )
         {
             openCeiling = false;
         }
         else if ( lst == ')' )
         {
             openCeiling = true;
         }
         else
         {
             throw new IllegalArgumentException( "illegal version range syntax " + val
                 + ": range must end in ')' or ']'" );
         }

         int comma = val.indexOf( ',' );
         if ( comma < 0 )
         {
             throw new IllegalArgumentException( "illegal version range syntax " + "no comma" );
         }
         if ( val.indexOf( ',', comma + 1 ) > 0 )
         {
             throw new IllegalArgumentException( "illegal version range syntax " + "too many commas" );
         }
         String strFloor = val.substring( 1, comma );
         String strCeil = val.substring( comma + 1, val.length() - 1 );
         floor = VersionTable.getVersion( strFloor, clean );
         ceiling = "*".equals( strCeil ) ? INFINITE_VERSION : VersionTable.getVersion( strCeil, clean );
         checkRange();
     }

     private String removeQuotesAndWhitespaces(String val) {
         for (int i = 0, l = val.length(); i < l; i++) {
             char ch = val.charAt(i);
             if (isRemoveable(ch)) {
                 StringBuilder sb = new StringBuilder(l);
                 sb.append(val, 0, i);
                 for (i++; i < l; i++) {
                     ch = val.charAt(i);
                     if (!isRemoveable(ch)) {
                         sb.append(ch);
                     }
                 }
                 return sb.toString();
             }
         }
         return val;
     }

     private static boolean[] removeable;
     static {
         removeable = new boolean[256];
         for (int i = 0; i < 256; i++) {
             removeable[i] = Character.isWhitespace(i);
         }
         removeable['"'] = true;
     }

     private boolean isRemoveable(char ch) {
         return ch < 256 ? removeable[ch] : Character.isWhitespace(ch);
     }

     public static VersionRange parseVersionRange( String val ) throws IllegalArgumentException, NumberFormatException
     {
         if ( val == null || val.trim().length() == 0 )
         {
             return ANY_VERSION;
         }

         return new VersionRange( val );
     }


     public Version getCeiling()
     {
         return ceiling;
     }


     public Version getFloor()
     {
         return floor;
     }


     public boolean isOpenCeiling()
     {
         return openCeiling;
     }


     public boolean isOpenFloor()
     {
         return openFloor;
     }


     public boolean isPointVersion()
     {
         return !openFloor && !openCeiling && floor.equals( ceiling );
     }


     /**
      * test a version to see if it falls in the range
      *
      * @param version The version to check
      * @return Whether the version is within the range
      */
     public boolean contains( Version version )
     {
         if ( version.equals( INFINITE_VERSION ) )
         {
             return ceiling.equals( INFINITE_VERSION );
         }
         else
         {
             return ( version.compareTo( floor ) > 0 && version.compareTo( ceiling ) < 0 )
                 || ( !openFloor && version.equals( floor ) ) || ( !openCeiling && version.equals( ceiling ) );
         }
     }

     /*
     * (non-Javadoc)
     *
     * @see org.apache.aries.application.impl.VersionRange#intersect(VersionRange
     * range)
     */

     public VersionRange intersect(VersionRange r)
     {
         // Use the highest minimum version.
         final Version newFloor;
         final boolean newOpenFloor;
         int minCompare = floor.compareTo(r.getFloor());
         if (minCompare > 0)
         {
             newFloor = floor;
             newOpenFloor = openFloor;
         }
         else if (minCompare < 0)
         {
             newFloor = r.getFloor();
             newOpenFloor = r.isOpenFloor();
         }
         else
         {
             newFloor = floor;
             newOpenFloor = (openFloor || r.isOpenFloor());
         }

         // Use the lowest maximum version.
         final Version newCeiling;
         final boolean newOpenCeiling;
         // null maximum version means unbounded, so the highest possible value.
         int maxCompare = ceiling.compareTo(r.getCeiling());
         if (maxCompare < 0)
         {
             newCeiling = ceiling;
             newOpenCeiling = openCeiling;
         }
         else if (maxCompare > 0)
         {
             newCeiling = r.getCeiling();
             newOpenCeiling = r.isOpenCeiling();
         }
         else
         {
             newCeiling = ceiling;
             newOpenCeiling = (openCeiling || r.isOpenCeiling());
         }

         VersionRange result;
         if (isRangeValid(newOpenFloor, newFloor, newCeiling, newOpenCeiling))
         {
             result = new VersionRange(newOpenFloor, newFloor, newCeiling, newOpenCeiling);
         }
         else
         {
             result = null;
         }
         return result;
     }

     /**
      * Check if the supplied parameters describe a valid version range.
      *
      * @param floor
      *          the minimum version.
      * @param openFloor
      *          whether the minimum version is exclusive.
      * @param ceiling
      *          the maximum version.
      * @param openCeiling
      *          whether the maximum version is exclusive.
      * @return true is the range is valid; otherwise false.
      */
     private static boolean isRangeValid(boolean openFloor, Version floor, Version ceiling, boolean openCeiling) {
         boolean result;
         int compare = floor.compareTo(ceiling);
         if (compare > 0)
         {
             // Minimum larger than maximum is invalid.
             result = false;
         }
         else if (compare == 0 && (openFloor || openCeiling))
         {
             // If floor and ceiling are the same, and either are exclusive, no valid range
             // exists.
             result = false;
         }
         else
         {
             // Range is valid.
             result = true;
         }
         return result;
     }

     private void checkRange()
     {
         if (!isRangeValid(openFloor, floor, ceiling, openCeiling))
         {
             throw new IllegalArgumentException("invalid version range: " + makeString(openFloor, floor, ceiling, openCeiling));
         }
     }


     public int hashCode()
     {
         final int prime = 31;
         int result = 1;
         result = prime * result + ( ( ceiling == null ) ? 0 : ceiling.hashCode() );
         result = prime * result + ( ( floor == null ) ? 0 : floor.hashCode() );
         result = prime * result + ( openCeiling ? 1231 : 1237 );
         result = prime * result + ( openFloor ? 1231 : 1237 );
         return result;
     }


     public boolean equals( Object obj )
     {
         if ( this == obj )
             return true;
         if ( obj == null )
             return false;
         if ( getClass() != obj.getClass() )
             return false;
         final VersionRange other = ( VersionRange ) obj;
         if ( ceiling == null )
         {
             if ( other.ceiling != null )
                 return false;
         }
         else if ( !ceiling.equals( other.ceiling ) )
             return false;
         if ( floor == null )
         {
             if ( other.floor != null )
                 return false;
         }
         else if ( !floor.equals( other.floor ) )
             return false;
         if ( openCeiling != other.openCeiling )
             return false;
         if ( openFloor != other.openFloor )
             return false;
         return true;
     }


     public String toString()
     {
         if ( ANY_VERSION.equals( this ) )
         {
             return makeString( openFloor, Version.emptyVersion, INFINITE_VERSION, openCeiling );
         }
         return makeString( openFloor, floor, ceiling, openCeiling );
     }


     private String makeString( boolean openFloor, Version floor, Version ceiling, boolean openCeiling )
     {
         StringBuffer vr = new StringBuffer( 32 );
         if ( INFINITE_VERSION.equals( ceiling ) )
         {
             vr.append( Version.emptyVersion.equals( floor ) ? "0" : floor.toString() );
         }
         else
         {
             vr.append( openFloor ? "(" : "[" );
             String floorStr = Version.emptyVersion.equals( floor ) ? "0" : floor.toString();
             String ceilingStr = ceiling.toString();
             vr.append( floorStr ).append( "," ).append( ceilingStr );
             vr.append( openCeiling ? ")" : "]" );
         }
         return vr.toString();
     }


     public static VersionRange newInstance( Version pointVersion,
                                             int lowerBoundRule,
                                             int upperBoundRule )
     {
         Version floor = null;
         switch ( lowerBoundRule )
         {
             case ANY:
                 floor = VersionTable.getVersion( 0, 0, 0 );
                 break;
             case MAJOR:
                 floor = VersionTable.getVersion( pointVersion.getMajor(), 0, 0 );
                 break;
             case MINOR:
                 floor = VersionTable.getVersion( pointVersion.getMajor(), pointVersion.getMinor(), 0 );
                 break;
             case MICRO:
                 floor = VersionTable.getVersion( pointVersion.getMajor(), pointVersion.getMinor(), pointVersion.getMicro() );
                 break;
             case EXACT:
                 floor = pointVersion;
                 break;
         }

         Version ceiling = null;
         boolean openCeiling = true;
         switch ( upperBoundRule )
         {
             case ANY:
                 ceiling = INFINITE_VERSION;
                 break;
             case MAJOR:
                 ceiling = VersionTable.getVersion( pointVersion.getMajor() + 1, 0, 0 );
                 break;
             case MINOR:
                 ceiling = VersionTable.getVersion( pointVersion.getMajor(), pointVersion.getMinor() + 1, 0 );
                 break;
             case MICRO:
                 ceiling = VersionTable.getVersion( pointVersion.getMajor(), pointVersion.getMinor(), pointVersion.getMicro() + 1 );
                 break;
             case EXACT:
                 ceiling = pointVersion;
                 openCeiling = false;
                 break;
         }

         return new VersionRange( false, floor, ceiling, openCeiling );
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you 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.
	*/
	package org.apache.felix.utils.version;

	import java.io.Serializable;

	import org.osgi.framework.Version;

	public class VersionRange implements Serializable
	{

	/**
	*
	*/
	private static final long serialVersionUID = 1L;

	public static final Version INFINITE_VERSION = new Version( Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, "" );
	public static final VersionRange ANY_VERSION = new VersionRange( false, Version.emptyVersion, INFINITE_VERSION, true );

	public static final int EXACT = 0;
	public static final int MICRO = 1;
	public static final int MINOR = 2;
	public static final int MAJOR = 3;
	public static final int ANY = 40;

	private final boolean openFloor;
	private final Version floor;
	private final Version ceiling;
	private final boolean openCeiling;


	/**
	* Interval constructor
	*
	* @param openFloor Whether the lower bound of the range is inclusive (false) or exclusive (true).
	* @param floor The lower bound version of the range.
	* @param ceiling The upper bound version of the range.
	* @param openCeiling Whether the upper bound of the range is inclusive (false) or exclusive (true).
	*/
	public VersionRange( boolean openFloor, Version floor, Version ceiling, boolean openCeiling )
	{
	this.openFloor = openFloor;
	this.floor = floor;
	this.ceiling = ceiling;
	this.openCeiling = openCeiling;
	checkRange();
	}


	/**
	* atLeast constructor
	*
	* @param atLeast Minimum version
	*/
	public VersionRange( Version atLeast )
	{
	this( atLeast, false );
	}

	/**
	* atLeast constructor
	*
	* @param atLeast Minimum version
	* @param exact Exact range
	*/
	public VersionRange( Version atLeast, boolean exact )
	{

	this.openFloor = false;
	this.floor = atLeast;
	this.ceiling = exact ? atLeast : INFINITE_VERSION;
	this.openCeiling = exact ? false : true;
	checkRange();
	}


	public VersionRange( String val ) throws IllegalArgumentException, NumberFormatException
	{
	this( val, false );
	}

	public VersionRange( String val, boolean exact ) throws IllegalArgumentException, NumberFormatException
	{
	this( val, exact, true );
	}

	public VersionRange( String val, boolean exact, boolean clean ) throws IllegalArgumentException, NumberFormatException
	{
	val = removeQuotesAndWhitespaces(val);
	int fst = val.charAt( 0 );
	if ( fst == '[' )
	{
	openFloor = false;
	}
	else if ( fst == '(' )
	{
	openFloor = true;
	}
	else
	{
	openFloor = false;
	floor = VersionTable.getVersion( val, clean );
	ceiling = exact ? floor : INFINITE_VERSION;
	openCeiling = exact ? false : true;
	return;
	}

	int lst = val.charAt( val.length() - 1 );
	if ( lst == ']' )
	{
	openCeiling = false;
	}
	else if ( lst == ')' )
	{
	openCeiling = true;
	}
	else
	{
	throw new IllegalArgumentException( "illegal version range syntax " + val
	+ ": range must end in ')' or ']'" );
	}

	int comma = val.indexOf( ',' );
	if ( comma < 0 )
	{
	throw new IllegalArgumentException( "illegal version range syntax " + "no comma" );
	}
	if ( val.indexOf( ',', comma + 1 ) > 0 )
	{
	throw new IllegalArgumentException( "illegal version range syntax " + "too many commas" );
	}
	String strFloor = val.substring( 1, comma );
	String strCeil = val.substring( comma + 1, val.length() - 1 );
	floor = VersionTable.getVersion( strFloor, clean );
	ceiling = "*".equals( strCeil ) ? INFINITE_VERSION : VersionTable.getVersion( strCeil, clean );
	checkRange();
	}

	private String removeQuotesAndWhitespaces(String val) {
	for (int i = 0, l = val.length(); i < l; i++) {
	char ch = val.charAt(i);
	if (isRemoveable(ch)) {
	StringBuilder sb = new StringBuilder(l);
	sb.append(val, 0, i);
	for (i++; i < l; i++) {
	ch = val.charAt(i);
	if (!isRemoveable(ch)) {
	sb.append(ch);
	}
	}
	return sb.toString();
	}
	}
	return val;
	}

	private static boolean[] removeable;
	static {
	removeable = new boolean[256];
	for (int i = 0; i < 256; i++) {
	removeable[i] = Character.isWhitespace(i);
	}
	removeable['"'] = true;
	}

	private boolean isRemoveable(char ch) {
	return ch < 256 ? removeable[ch] : Character.isWhitespace(ch);
	}

	public static VersionRange parseVersionRange( String val ) throws IllegalArgumentException, NumberFormatException
	{
	if ( val == null \|\| val.trim().length() == 0 )
	{
	return ANY_VERSION;
	}

	return new VersionRange( val );
	}


	public Version getCeiling()
	{
	return ceiling;
	}


	public Version getFloor()
	{
	return floor;
	}


	public boolean isOpenCeiling()
	{
	return openCeiling;
	}


	public boolean isOpenFloor()
	{
	return openFloor;
	}


	public boolean isPointVersion()
	{
	return !openFloor && !openCeiling && floor.equals( ceiling );
	}


	/**
	* test a version to see if it falls in the range
	*
	* @param version The version to check
	* @return Whether the version is within the range
	*/
	public boolean contains( Version version )
	{
	if ( version.equals( INFINITE_VERSION ) )
	{
	return ceiling.equals( INFINITE_VERSION );
	}
	else
	{
	return ( version.compareTo( floor ) > 0 && version.compareTo( ceiling ) < 0 )
	\|\| ( !openFloor && version.equals( floor ) ) \|\| ( !openCeiling && version.equals( ceiling ) );
	}
	}

	/*
	* (non-Javadoc)
	*
	* @see org.apache.aries.application.impl.VersionRange#intersect(VersionRange
	* range)
	*/

	public VersionRange intersect(VersionRange r)
	{
	// Use the highest minimum version.
	final Version newFloor;
	final boolean newOpenFloor;
	int minCompare = floor.compareTo(r.getFloor());
	if (minCompare > 0)
	{
	newFloor = floor;
	newOpenFloor = openFloor;
	}
	else if (minCompare < 0)
	{
	newFloor = r.getFloor();
	newOpenFloor = r.isOpenFloor();
	}
	else
	{
	newFloor = floor;
	newOpenFloor = (openFloor \|\| r.isOpenFloor());
	}

	// Use the lowest maximum version.
	final Version newCeiling;
	final boolean newOpenCeiling;
	// null maximum version means unbounded, so the highest possible value.
	int maxCompare = ceiling.compareTo(r.getCeiling());
	if (maxCompare < 0)
	{
	newCeiling = ceiling;
	newOpenCeiling = openCeiling;
	}
	else if (maxCompare > 0)
	{
	newCeiling = r.getCeiling();
	newOpenCeiling = r.isOpenCeiling();
	}
	else
	{
	newCeiling = ceiling;
	newOpenCeiling = (openCeiling \|\| r.isOpenCeiling());
	}

	VersionRange result;
	if (isRangeValid(newOpenFloor, newFloor, newCeiling, newOpenCeiling))
	{
	result = new VersionRange(newOpenFloor, newFloor, newCeiling, newOpenCeiling);
	}
	else
	{
	result = null;
	}
	return result;
	}

	/**
	* Check if the supplied parameters describe a valid version range.
	*
	* @param floor
	* the minimum version.
	* @param openFloor
	* whether the minimum version is exclusive.
	* @param ceiling
	* the maximum version.
	* @param openCeiling
	* whether the maximum version is exclusive.
	* @return true is the range is valid; otherwise false.
	*/
	private static boolean isRangeValid(boolean openFloor, Version floor, Version ceiling, boolean openCeiling) {
	boolean result;
	int compare = floor.compareTo(ceiling);
	if (compare > 0)
	{
	// Minimum larger than maximum is invalid.
	result = false;
	}
	else if (compare == 0 && (openFloor \|\| openCeiling))
	{
	// If floor and ceiling are the same, and either are exclusive, no valid range
	// exists.
	result = false;
	}
	else
	{
	// Range is valid.
	result = true;
	}
	return result;
	}

	private void checkRange()
	{
	if (!isRangeValid(openFloor, floor, ceiling, openCeiling))
	{
	throw new IllegalArgumentException("invalid version range: " + makeString(openFloor, floor, ceiling, openCeiling));
	}
	}


	public int hashCode()
	{
	final int prime = 31;
	int result = 1;
	result = prime * result + ( ( ceiling == null ) ? 0 : ceiling.hashCode() );
	result = prime * result + ( ( floor == null ) ? 0 : floor.hashCode() );
	result = prime * result + ( openCeiling ? 1231 : 1237 );
	result = prime * result + ( openFloor ? 1231 : 1237 );
	return result;
	}


	public boolean equals( Object obj )
	{
	if ( this == obj )
	return true;
	if ( obj == null )
	return false;
	if ( getClass() != obj.getClass() )
	return false;
	final VersionRange other = ( VersionRange ) obj;
	if ( ceiling == null )
	{
	if ( other.ceiling != null )
	return false;
	}
	else if ( !ceiling.equals( other.ceiling ) )
	return false;
	if ( floor == null )
	{
	if ( other.floor != null )
	return false;
	}
	else if ( !floor.equals( other.floor ) )
	return false;
	if ( openCeiling != other.openCeiling )
	return false;
	if ( openFloor != other.openFloor )
	return false;
	return true;
	}


	public String toString()
	{
	if ( ANY_VERSION.equals( this ) )
	{
	return makeString( openFloor, Version.emptyVersion, INFINITE_VERSION, openCeiling );
	}
	return makeString( openFloor, floor, ceiling, openCeiling );
	}


	private String makeString( boolean openFloor, Version floor, Version ceiling, boolean openCeiling )
	{
	StringBuffer vr = new StringBuffer( 32 );
	if ( INFINITE_VERSION.equals( ceiling ) )
	{
	vr.append( Version.emptyVersion.equals( floor ) ? "0" : floor.toString() );
	}
	else
	{
	vr.append( openFloor ? "(" : "[" );
	String floorStr = Version.emptyVersion.equals( floor ) ? "0" : floor.toString();
	String ceilingStr = ceiling.toString();
	vr.append( floorStr ).append( "," ).append( ceilingStr );
	vr.append( openCeiling ? ")" : "]" );
	}
	return vr.toString();
	}


	public static VersionRange newInstance( Version pointVersion,
	int lowerBoundRule,
	int upperBoundRule )
	{
	Version floor = null;
	switch ( lowerBoundRule )
	{
	case ANY:
	floor = VersionTable.getVersion( 0, 0, 0 );
	break;
	case MAJOR:
	floor = VersionTable.getVersion( pointVersion.getMajor(), 0, 0 );
	break;
	case MINOR:
	floor = VersionTable.getVersion( pointVersion.getMajor(), pointVersion.getMinor(), 0 );
	break;
	case MICRO:
	floor = VersionTable.getVersion( pointVersion.getMajor(), pointVersion.getMinor(), pointVersion.getMicro() );
	break;
	case EXACT:
	floor = pointVersion;
	break;
	}

	Version ceiling = null;
	boolean openCeiling = true;
	switch ( upperBoundRule )
	{
	case ANY:
	ceiling = INFINITE_VERSION;
	break;
	case MAJOR:
	ceiling = VersionTable.getVersion( pointVersion.getMajor() + 1, 0, 0 );
	break;
	case MINOR:
	ceiling = VersionTable.getVersion( pointVersion.getMajor(), pointVersion.getMinor() + 1, 0 );
	break;
	case MICRO:
	ceiling = VersionTable.getVersion( pointVersion.getMajor(), pointVersion.getMinor(), pointVersion.getMicro() + 1 );
	break;
	case EXACT:
	ceiling = pointVersion;
	openCeiling = false;
	break;
	}

	return new VersionRange( false, floor, ceiling, openCeiling );
	}
	}