src/main/java/org/apache/felix/metatype/AD.java - felix-dev - 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.metatype;


 import java.util.*;

 import org.apache.felix.metatype.internal.Activator;
 import org.osgi.service.log.LogService;
 import org.osgi.service.metatype.AttributeDefinition;


 /**
  * The <code>AD</code> class represents the <code>AD</code> element of the
  * meta type descriptor.
  *
  * @author fmeschbe
  */
 public class AD
 {

     /**
      * The message returned from the {@link #validate(String)} method if the
      * value is not any of the specified {@link #getOptionValues() option values}
      * (value is "%not a valid option").
      */
     public static final String VALIDATE_NOT_A_VALID_OPTION = "%not a valid option";

     /**
      * The message returned from the {@link #validate(String)} method if the
      * value is greater than the specified {@link #getMax() maximum value}
      * (value is "%greater than maximum").
      */
     public static final String VALIDATE_GREATER_THAN_MAXIMUM = "%greater than maximum";

     /**
      * The message returned from the {@link #validate(String)} method if the
      * value is less than the specified {@link #getMin() minimum value}
      * (value is "%less than minimum").
      */
     public static final String VALIDATE_LESS_THAN_MINIMUM = "%less than minimum";

     private String id;
     private String name;
     private String description;
     private int type;
     private int cardinality = 0;
     private String[] optionLabels;
     private String[] optionValues;
     private String[] defaultValue;
     private String min;
     private String max;
     private boolean isRequired = true;


     public String getID()
     {
         return id;
     }


     public String getName()
     {
         return name;
     }


     public String getDescription()
     {
         return description;
     }


     public int getType()
     {
         return type;
     }


     public int getCardinality()
     {
         return cardinality;
     }


     public String[] getOptionLabels()
     {
         return optionLabels;
     }


     public String[] getOptionValues()
     {
         return optionValues;
     }


     public String[] getDefaultValue()
     {
         return defaultValue;
     }


     public String getMin()
     {
         return min;
     }


     public String getMax()
     {
         return max;
     }


     public boolean isRequired()
     {
         return isRequired;
     }


     /**
      * Implements validation of the <code>valueString</code> and returns an
      * indication of the success:
      * <dl>
      * <dt><code>null</code>
      * <dd>If neither a {@link #getMin() minimal value} nor a
      *      {@link #getMax() maximal value} nor any
      *      {@link #getOptionValues() optional values} are defined in this
      *      instance, validation cannot be performed.
      * <dt>Empty String
      * <dd>If validation succeeds. This value is also returned if the
      *      <code>valueString</code> is empty or <code>null</code> or cannot be
      *      converted into a numeric type.
      * <dt><b>%</b>message
      * <dd>If the value falls below the minimum, higher than the maximum or is
      *      not any of the option values, an explanatory message, which may be
      *      localized is returned. If any of the minimum, maximum or option
      *      values is <code>null</code>, the respective value is not checked.
      * </dl>
      *
      * @param valueString The string representation of the value to validate.
      *
      * @return As explained above.
      *
      * @see #VALIDATE_GREATER_THAN_MAXIMUM
      * @see #VALIDATE_LESS_THAN_MINIMUM
      * @see #VALIDATE_NOT_A_VALID_OPTION
      */
     public String validate( String valueString )
     {
         // no validation if no min and max
         if ( getMin() == null && getMax() == null && getOptionValues() == null )
         {
             return null;
         }

         Comparable value = convertToType( valueString );
         if ( value == null )
         {
             return ""; // accept null value
         }

         Comparable other = convertToType( getMin() );
         if ( other != null )
         {
             if ( value.compareTo( other ) < 0 )
             {
                 return VALIDATE_LESS_THAN_MINIMUM;
             }
         }

         other = convertToType( getMax() );
         if ( other != null )
         {
             if ( value.compareTo( other ) > 0 )
             {
                 return VALIDATE_GREATER_THAN_MAXIMUM;
             }
         }

         String[] optionValues = getOptionValues();
         if ( optionValues != null && optionValues.length > 0)
         {
             for ( int i = 0; i < optionValues.length; i++ )
             {
                 other = convertToType( optionValues[i] );
                 if ( value.compareTo( other ) == 0 )
                 {
                     // one of the option values
                     return "";
                 }
             }

             // not any of the option values, fail
             return VALIDATE_NOT_A_VALID_OPTION;
         }

         // finally, we accept the value
         return "";
     }


     //--------- Setters for setting up this instance --------------------------

     /**
      * @param id the id to set
      */
     public void setID( String id )
     {
         this.id = id;
     }


     /**
      * @param name the name to set
      */
     public void setName( String name )
     {
         this.name = name;
     }


     /**
      * @param description the description to set
      */
     public void setDescription( String description )
     {
         this.description = description;
     }


     /**
      * @param typeString the type to set
      */
     public void setType( String typeString )
     {
         this.type = toType( typeString );
     }


     /**
      * @param cardinality the cardinality to set
      */
     public void setCardinality( int cardinality )
     {
         this.cardinality = cardinality;
     }


     /**
      * @param options the options to set
      */
     public void setOptions( Map options )
     {
         optionLabels = new String[options.size()];
         optionValues = new String[options.size()];
         int i = 0;
         for ( Iterator oi = options.entrySet().iterator(); oi.hasNext(); i++ )
         {
             Map.Entry entry = ( Map.Entry ) oi.next();
             optionValues[i] = String.valueOf( entry.getKey() );
             optionLabels[i] = String.valueOf( entry.getValue() );
         }
     }


     /**
      * @param defaultValue the defaultValue to set
      */
     public void setDefaultValue( String defaultValue )
     {
         this.defaultValue = splitList( defaultValue );
     }


     /**
      * @param min the min to set
      */
     public void setMin( String min )
     {
         this.min = min;
     }


     /**
      * @param max the max to set
      */
     public void setMax( String max )
     {
         this.max = max;
     }


     /**
      * @param defaultValue the defaultValue to set
      */
     public void setDefaultValue( String[] defaultValue )
     {
         this.defaultValue = ( String[] ) defaultValue.clone();
     }


     /**
      * @param isRequired the isRequired to set
      */
     public void setRequired( boolean isRequired )
     {
         this.isRequired = isRequired;
     }


     public static int toType( String typeString )
     {
         if ( "String".equals( typeString ) )
         {
             return AttributeDefinition.STRING;
         }
         else if ( "Long".equals( typeString ) )
         {
             return AttributeDefinition.LONG;
         }
         else if ( "Double".equals( typeString ) )
         {
             return AttributeDefinition.DOUBLE;
         }
         else if ( "Float".equals( typeString ) )
         {
             return AttributeDefinition.FLOAT;
         }
         else if ( "Integer".equals( typeString ) )
         {
             return AttributeDefinition.INTEGER;
         }
         else if ( "Byte".equals( typeString ) )
         {
             return AttributeDefinition.BYTE;
         }
         else if ( "Char".equals( typeString ) )
         {
             return AttributeDefinition.CHARACTER;
         }
         else if ( "Boolean".equals( typeString ) )
         {
             return AttributeDefinition.BOOLEAN;
         }
         else if ( "Short".equals( typeString ) )
         {
             return AttributeDefinition.SHORT;
         }

         // finally fall back to string for illegal values
         return AttributeDefinition.STRING;
     }


     public static String[] splitList( String listString )
     {
         // return nothing ...
         if ( listString == null )
         {
             return null;
         }

         List values = new ArrayList();
         boolean escape = false;
         StringBuffer buf = new StringBuffer();
         for ( int i = 0; i < listString.length(); i++ )
         {
             char c = listString.charAt( i );

             if ( escape )
             {
                 // just go ahead
                 escape = false;
             }
             else if ( c == ',' )
             {
                 String value = buf.toString().trim();
                 if ( value.length() > 0 )
                 {
                     values.add( value );
                 }
                 buf.delete( 0, buf.length() );
                 continue;
             }
             else if ( c == '\\' )
             {
                 escape = true;
                 continue;
             }

             buf.append( c );
         }

         // add last string
         if ( buf.length() > 0 )
         {
             String value = buf.toString().trim();
             if ( value.length() > 0 )
             {
                 values.add( value );
             }
         }

         return values.isEmpty() ? null : ( String[] ) values.toArray( new String[values.size()] );
     }


     protected Comparable convertToType( final String value )
     {
         if ( value != null && value.length() > 0 )
         {
             try
             {
                 switch ( getType() )
                 {
                     case AttributeDefinition.BOOLEAN:
                         // Boolean is only Comparable starting with Java 5
                         return new ComparableBoolean(value);
                     case AttributeDefinition.CHARACTER:
                         return new Character( value.charAt( 0 ) );
                     case AttributeDefinition.BYTE:
                         return Byte.valueOf( value );
                     case AttributeDefinition.SHORT:
                         return Short.valueOf( value );
                     case AttributeDefinition.INTEGER:
                         return Integer.valueOf( value );
                     case AttributeDefinition.LONG:
                         return Long.valueOf( value );
                     case AttributeDefinition.FLOAT:
                         return Float.valueOf( value );
                     case AttributeDefinition.DOUBLE:
                         return Double.valueOf( value );
                     case AttributeDefinition.STRING:
                     default:
                         return value;
                 }
             }
             catch ( NumberFormatException nfe )
             {
                 Activator.log( LogService.LOG_INFO, "Cannot convert value '" + value + "'", nfe );
             }
         }

         return null;
     }

     private static class ComparableBoolean implements Comparable {
         private boolean value;

         ComparableBoolean(String boolValue) {
             value = Boolean.valueOf(boolValue).booleanValue();
         }

         public int compareTo(Object obj) {
             ComparableBoolean cb = (ComparableBoolean) obj;
             return (cb.value == value ? 0 : (value ? 1 : -1));
         }
     }
 }
	/*
	* 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.metatype;


	import java.util.*;

	import org.apache.felix.metatype.internal.Activator;
	import org.osgi.service.log.LogService;
	import org.osgi.service.metatype.AttributeDefinition;


	/**
	* The <code>AD</code> class represents the <code>AD</code> element of the
	* meta type descriptor.
	*
	* @author fmeschbe
	*/
	public class AD
	{

	/**
	* The message returned from the {@link #validate(String)} method if the
	* value is not any of the specified {@link #getOptionValues() option values}
	* (value is "%not a valid option").
	*/
	public static final String VALIDATE_NOT_A_VALID_OPTION = "%not a valid option";

	/**
	* The message returned from the {@link #validate(String)} method if the
	* value is greater than the specified {@link #getMax() maximum value}
	* (value is "%greater than maximum").
	*/
	public static final String VALIDATE_GREATER_THAN_MAXIMUM = "%greater than maximum";

	/**
	* The message returned from the {@link #validate(String)} method if the
	* value is less than the specified {@link #getMin() minimum value}
	* (value is "%less than minimum").
	*/
	public static final String VALIDATE_LESS_THAN_MINIMUM = "%less than minimum";

	private String id;
	private String name;
	private String description;
	private int type;
	private int cardinality = 0;
	private String[] optionLabels;
	private String[] optionValues;
	private String[] defaultValue;
	private String min;
	private String max;
	private boolean isRequired = true;


	public String getID()
	{
	return id;
	}


	public String getName()
	{
	return name;
	}


	public String getDescription()
	{
	return description;
	}


	public int getType()
	{
	return type;
	}


	public int getCardinality()
	{
	return cardinality;
	}


	public String[] getOptionLabels()
	{
	return optionLabels;
	}


	public String[] getOptionValues()
	{
	return optionValues;
	}


	public String[] getDefaultValue()
	{
	return defaultValue;
	}


	public String getMin()
	{
	return min;
	}


	public String getMax()
	{
	return max;
	}


	public boolean isRequired()
	{
	return isRequired;
	}


	/**
	* Implements validation of the <code>valueString</code> and returns an
	* indication of the success:
	* <dl>
	* <dt><code>null</code>
	* <dd>If neither a {@link #getMin() minimal value} nor a
	* {@link #getMax() maximal value} nor any
	* {@link #getOptionValues() optional values} are defined in this
	* instance, validation cannot be performed.
	* <dt>Empty String
	* <dd>If validation succeeds. This value is also returned if the
	* <code>valueString</code> is empty or <code>null</code> or cannot be
	* converted into a numeric type.
	* <dt><b>%</b>message
	* <dd>If the value falls below the minimum, higher than the maximum or is
	* not any of the option values, an explanatory message, which may be
	* localized is returned. If any of the minimum, maximum or option
	* values is <code>null</code>, the respective value is not checked.
	* </dl>
	*
	* @param valueString The string representation of the value to validate.
	*
	* @return As explained above.
	*
	* @see #VALIDATE_GREATER_THAN_MAXIMUM
	* @see #VALIDATE_LESS_THAN_MINIMUM
	* @see #VALIDATE_NOT_A_VALID_OPTION
	*/
	public String validate( String valueString )
	{
	// no validation if no min and max
	if ( getMin() == null && getMax() == null && getOptionValues() == null )
	{
	return null;
	}

	Comparable value = convertToType( valueString );
	if ( value == null )
	{
	return ""; // accept null value
	}

	Comparable other = convertToType( getMin() );
	if ( other != null )
	{
	if ( value.compareTo( other ) < 0 )
	{
	return VALIDATE_LESS_THAN_MINIMUM;
	}
	}

	other = convertToType( getMax() );
	if ( other != null )
	{
	if ( value.compareTo( other ) > 0 )
	{
	return VALIDATE_GREATER_THAN_MAXIMUM;
	}
	}

	String[] optionValues = getOptionValues();
	if ( optionValues != null && optionValues.length > 0)
	{
	for ( int i = 0; i < optionValues.length; i++ )
	{
	other = convertToType( optionValues[i] );
	if ( value.compareTo( other ) == 0 )
	{
	// one of the option values
	return "";
	}
	}

	// not any of the option values, fail
	return VALIDATE_NOT_A_VALID_OPTION;
	}

	// finally, we accept the value
	return "";
	}


	//--------- Setters for setting up this instance --------------------------

	/**
	* @param id the id to set
	*/
	public void setID( String id )
	{
	this.id = id;
	}


	/**
	* @param name the name to set
	*/
	public void setName( String name )
	{
	this.name = name;
	}


	/**
	* @param description the description to set
	*/
	public void setDescription( String description )
	{
	this.description = description;
	}


	/**
	* @param typeString the type to set
	*/
	public void setType( String typeString )
	{
	this.type = toType( typeString );
	}


	/**
	* @param cardinality the cardinality to set
	*/
	public void setCardinality( int cardinality )
	{
	this.cardinality = cardinality;
	}


	/**
	* @param options the options to set
	*/
	public void setOptions( Map options )
	{
	optionLabels = new String[options.size()];
	optionValues = new String[options.size()];
	int i = 0;
	for ( Iterator oi = options.entrySet().iterator(); oi.hasNext(); i++ )
	{
	Map.Entry entry = ( Map.Entry ) oi.next();
	optionValues[i] = String.valueOf( entry.getKey() );
	optionLabels[i] = String.valueOf( entry.getValue() );
	}
	}


	/**
	* @param defaultValue the defaultValue to set
	*/
	public void setDefaultValue( String defaultValue )
	{
	this.defaultValue = splitList( defaultValue );
	}


	/**
	* @param min the min to set
	*/
	public void setMin( String min )
	{
	this.min = min;
	}


	/**
	* @param max the max to set
	*/
	public void setMax( String max )
	{
	this.max = max;
	}


	/**
	* @param defaultValue the defaultValue to set
	*/
	public void setDefaultValue( String[] defaultValue )
	{
	this.defaultValue = ( String[] ) defaultValue.clone();
	}


	/**
	* @param isRequired the isRequired to set
	*/
	public void setRequired( boolean isRequired )
	{
	this.isRequired = isRequired;
	}


	public static int toType( String typeString )
	{
	if ( "String".equals( typeString ) )
	{
	return AttributeDefinition.STRING;
	}
	else if ( "Long".equals( typeString ) )
	{
	return AttributeDefinition.LONG;
	}
	else if ( "Double".equals( typeString ) )
	{
	return AttributeDefinition.DOUBLE;
	}
	else if ( "Float".equals( typeString ) )
	{
	return AttributeDefinition.FLOAT;
	}
	else if ( "Integer".equals( typeString ) )
	{
	return AttributeDefinition.INTEGER;
	}
	else if ( "Byte".equals( typeString ) )
	{
	return AttributeDefinition.BYTE;
	}
	else if ( "Char".equals( typeString ) )
	{
	return AttributeDefinition.CHARACTER;
	}
	else if ( "Boolean".equals( typeString ) )
	{
	return AttributeDefinition.BOOLEAN;
	}
	else if ( "Short".equals( typeString ) )
	{
	return AttributeDefinition.SHORT;
	}

	// finally fall back to string for illegal values
	return AttributeDefinition.STRING;
	}


	public static String[] splitList( String listString )
	{
	// return nothing ...
	if ( listString == null )
	{
	return null;
	}

	List values = new ArrayList();
	boolean escape = false;
	StringBuffer buf = new StringBuffer();
	for ( int i = 0; i < listString.length(); i++ )
	{
	char c = listString.charAt( i );

	if ( escape )
	{
	// just go ahead
	escape = false;
	}
	else if ( c == ',' )
	{
	String value = buf.toString().trim();
	if ( value.length() > 0 )
	{
	values.add( value );
	}
	buf.delete( 0, buf.length() );
	continue;
	}
	else if ( c == '\\' )
	{
	escape = true;
	continue;
	}

	buf.append( c );
	}

	// add last string
	if ( buf.length() > 0 )
	{
	String value = buf.toString().trim();
	if ( value.length() > 0 )
	{
	values.add( value );
	}
	}

	return values.isEmpty() ? null : ( String[] ) values.toArray( new String[values.size()] );
	}


	protected Comparable convertToType( final String value )
	{
	if ( value != null && value.length() > 0 )
	{
	try
	{
	switch ( getType() )
	{
	case AttributeDefinition.BOOLEAN:
	// Boolean is only Comparable starting with Java 5
	return new ComparableBoolean(value);
	case AttributeDefinition.CHARACTER:
	return new Character( value.charAt( 0 ) );
	case AttributeDefinition.BYTE:
	return Byte.valueOf( value );
	case AttributeDefinition.SHORT:
	return Short.valueOf( value );
	case AttributeDefinition.INTEGER:
	return Integer.valueOf( value );
	case AttributeDefinition.LONG:
	return Long.valueOf( value );
	case AttributeDefinition.FLOAT:
	return Float.valueOf( value );
	case AttributeDefinition.DOUBLE:
	return Double.valueOf( value );
	case AttributeDefinition.STRING:
	default:
	return value;
	}
	}
	catch ( NumberFormatException nfe )
	{
	Activator.log( LogService.LOG_INFO, "Cannot convert value '" + value + "'", nfe );
	}
	}

	return null;
	}

	private static class ComparableBoolean implements Comparable {
	private boolean value;

	ComparableBoolean(String boolValue) {
	value = Boolean.valueOf(boolValue).booleanValue();
	}

	public int compareTo(Object obj) {
	ComparableBoolean cb = (ComparableBoolean) obj;
	return (cb.value == value ? 0 : (value ? 1 : -1));
	}
	}
	}