Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* This Source Code Form is subject to the terms of the Mozilla Public
   * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   * You can obtain one at http://mozilla.org/MPL/2.0/. */
  
  package pt.webdetails.cda.dataaccess;
  
 import java.util.Date;
 import java.util.List;
 
 import  org.pentaho.reporting.engine.classic.core.ParameterDataRow;
 import  org.pentaho.reporting.libraries.base.util.CSVTokenizer;
 
 import  org.apache.commons.lang.StringUtils;
 import  org.apache.commons.logging.Log;
 import  org.apache.commons.logging.LogFactory;
 import  org.dom4j.Element;
 
 
Created by IntelliJ IDEA. User: pedro Date: Feb 4, 2010 Time: 4:09:48 PM
 
 public class Parameter implements java.io.Serializable {
 
   static Log logger = LogFactory.getLog(Parameter.class);
   
   private static final long serialVersionUID = 3L;
   
   final static String DEFAULT_ARRAY_SEPERATOR = ";";
 
   private String name;
   private Type type;
   private Object defaultValue;
   private String pattern = StringUtils.EMPTY;
   private Object value;
   private Access access = .;
 
   
   public enum Access {
   	PRIVATE("private"),
   	PUBLIC("public");
   	
   	private String name;
   	
   	Access(String name){ this. = name; }
   	
   	public static Access parse(String text){
   		for(Access type : Access.values()){
   			if(text != null && type.name.equals(text.trim().toLowerCase())){
   				return type;
   			}
   		}
   		return ;//default
   	}
   	public String toString(){ return this.;}
   }
   
   private final static String FORMULA_BEGIN = "${";
   private final static String FORMULA_END = "}";
   
   public enum Type {
   	
   	STRING("String"),
   	INTEGER("Integer"),
   	NUMERIC("Numeric"),
   	DATE("Date"),
     STRING_ARRAY("StringArray"),
     INTEGER_ARRAY("IntegerArray"),
     NUMERIC_ARRAY("NumericArray"),
     DATE_ARRAY("DateArray");
   	
   	private String name;
   	
   	Type(String name){
   		this. = name;
   	}
   	
   	public final String getName(){
   		return ;
   	}
   	
   	public String toString(){
   		return ;
   	}
   	
   	public boolean isArrayType(){
  	  switch(this){
  	    case :
  	    case :
  	    case :
  	    case :
  	      return true;
  	    default:
  	      return false;
  	  }
  	}
  	
    public static Type parse(String typeString) {
      for (Type type : Type.values()) {
        if (type.name.equals(typeString)) {
          return type;
        }
      }
      return null;
    }
  	
    public static Type inferTypeFromObject(Object obj) {
      if (obj != null) {
        if (Object[].class.isAssignableFrom(obj.getClass())) {
          if (Double[].class.isAssignableFrom(obj.getClass())) {
            return ;
          } else if (Integer[].class.isAssignableFrom(obj.getClass())) {
            return ;
          } else if (Date[].class.isAssignableFrom(obj.getClass())) {
            return ;
          } else if (String[].class.isAssignableFrom(obj.getClass())) {
            return ;
          }
        } else if (Double.class.isAssignableFrom(obj.getClass())) {
          return ;
        } else if (Integer.class.isAssignableFrom(obj.getClass())) {
          return ;
        } else if (Date.class.isAssignableFrom(obj.getClass())) {
          return ;
        } else if (String.class.isAssignableFrom(obj.getClass())) {
          return ;
        }
      }
      return null;// default
    }
  }
  
  
  /* *****
   * CTORS
   ********/
  public Parameter()
  {
  }
  public Parameter(final String namefinal String typefinal String defaultValuefinal String patternfinal String access)
  {
    this. = name;
    this. = Type.parse(type);//defaults to null
    this. = defaultValue;
    this. = pattern;
    this. = Access.parse(access);//defaults to public
  }
  
  
Defensive copy constructor

Parameters:
param Parameter to clone
  public Parameter(Parameter param)
  {
    this(param.getName(), param.getTypeAsString(), param.getStringValue(), param.getPattern(), param.getAccess().toString() );
    this.setSeparator(param.getSeparator());
  }
  public Parameter(final Element p)
  {
    this(
        p.attributeValue("name"),
        p.attributeValue("type"),
        p.attributeValue("default"),
        p.attributeValue("pattern"),
        p.attributeValue("access")
    );
    this.setSeparator(p.attributeValue("separator"));
  }
  public Parameter(final String namefinal Object value)
  {
    this. = name;
    this. = value;
  }
   
  public void inheritDefaults(Parameter defaultParameter){
    if(this. == nullthis.setType(defaultParameter.getType());
    if(this. == . || this. == .this.setPattern(defaultParameter.getPattern());
    this.setSeparator(defaultParameter.getSeparator());
  }
  {
    final Object objValue =  == null ? getDefaultValue() : ;
    if(objValue instanceof String){//may be a string or a parsed value
      final String strValue = (StringobjValue;
      //check if it is a formula
      if(strValue != null && strValue.trim().startsWith())
      {
        String formula = Util.getContentsBetween(strValue);
        if(formula == null)
        {
          throw new InvalidParameterException("Malformed formula expression"null);
        }
      	Object value = FormulaEvaluator.processFormula(formula);
      	if(getType() == . && !(value instanceof String)){
      	  return getValueAsString(value);
      	}
      	else return value;
      }
      
      Type valueType = getType();
      if(valueType == null){
        throw  new InvalidParameterException("Parameter type " + getType() + " unknown, can't continue",null);
      }
       = getValueFromString(strValuevalueType);
      return ;
    }
    else return objValue;
  }

  

Parameters:
localValue
valueType
Returns:
Throws:
InvalidParameterException
  private Object getValueFromString(final String localValueType valueTypethrows InvalidParameterException {
    
    switch(valueType){
      case :
        return localValue;
      case :
        return Integer.parseInt(localValue);
      case :
        return Double.parseDouble(localValue);
      case :
        if(!StringUtils.isEmpty(getPattern()))
        {
          SimpleDateFormat format = new SimpleDateFormat(getPattern());
          try
          {
            return format.parse(localValue);
          }
          catch (ParseException e)
          {
            throw new InvalidParameterException("Unable to parse " + ..getName() + " '" + localValue + "' with pattern " + getPattern() , e);
          }
        }
        else
        {
          return new Date(Long.parseLong(localValue));
        }
      case :
        return parseToArray(localValue.new String[0]);
      case :
        return parseToArray(localValue.new Date[0]);
      case :
        return parseToArray(localValue.new Integer[0]);
      case :
        return parseToArray(localValue.new Double[0]);
      default:
         return localValue;
    }
  }
  @SuppressWarnings("unchecked")
  private <T> T[] parseToArray(String arrayAsStringType elementType, T[] arraythrows InvalidParameterException
  {    
    CSVTokenizer tokenizer = new CSVTokenizer(arrayAsStringgetSeparator());
    
    ArrayList<T> result = new ArrayList<T>();
    whiletokenizer.hasMoreTokens()){
      result.add((T) getValueFromString(tokenizer.nextToken(), elementType));
    }
    return result.toArray(array);
  }
  public String getName()
  {
    return ;
  }
  public void setName(final String name)
  {
    this. = name;
  }
  public Type getType()
  {
    return ;
  }
  
  public String getTypeAsString(){
    return ( == null) ? null : .getName();
  }
  public void setType(final String type)
  {
    this. = Type.parse(type);
  }
  
  public void setType(final Type type){
    this. = type;
  }
  public Object getDefaultValue()
  {
    return ;
  }
  public void setDefaultValue(final Object defaultValue)
  {
    this. = defaultValue;
  }
  public String getPattern()
  {
    return ;
  }
  public void setPattern(final String pattern)
  {
    this. = pattern;
  }
  
  private String getValueAsString(Object value){
    String separator = getSeparator();
      
    if (value == null) {
      if (getDefaultValue() != nullreturn getDefaultValue().toString();
      else return null;
    }  
    else if (value instanceof String){
      return (Stringvalue;  
    } else if ( != null) {
      switch () {
        case ://csvTokenizer compatible
          
          if(!(value instanceof String[]) && (value instanceof Object[])){
            Object[] oldVal = (Object[]) value;
            String[] newVal = new String[oldVal.length];
            for(int i=0;i<oldVal.length;i++){
              //force toString()
              newVal[i] = "" + oldVal[i];
            }
            value = newVal;
          }
          
          String[] strArr = (String[]) value;
          int i = 0;
          StringBuilder strBuild = new StringBuilder();
          for (String s : strArr) {
            if (i++ > 0) strBuild.append(separator);
            
            strBuild.append('"');
            int lastWritten = 0;
            for(int sepIdx = StringUtils.indexOf(s"'"); sepIdx >=0; sepIdx = StringUtils.indexOf(s"'"sepIdx))
            {//quote separator
              strBuild.append(s.substring(lastWrittensepIdx));
              strBuild.append('"');
              strBuild.append(separator);
              strBuild.append('"');
              lastWritten =  ++sepIdx;
            }
            strBuild.append(StringUtils.substring(slastWrittens.length()));
            strBuild.append('"');
          }
          return strBuild.toString();
        case :
          try {
            Date dt = (DategetValue();
            return (dt == null)? null : "" + dt.getTime();
          } catch (InvalidParameterException e) {
            .error("Parameter of date type " + getName() + " does not yield date."e);
          }
          break;
        case :
        case :
        case :
        default://also handle whan we want a string and have an array
          if(value instanceof Object[]){
            Object[] arr = (Object[]) value;
             i = 0;
             strBuild = new StringBuilder();
            for (Object o : arr) {
              if (i++ > 0) strBuild.append(separator);
              if(o instanceof DatestrBuild.append(((Date)o).getTime());
              else strBuild.append(o);
            }
            return strBuild.toString();
          }//else toString
      }
    }
    return value.toString();
  }
  public String getStringValue() {
    return getValueAsString(this.);
  }
  public void setStringValue(final String stringValue)
  {
    this. = stringValue;
  }
  
  public void setStringValue(final String stringValueType type){
    this. = stringValue;//TODO: parse now?
    this. = type;
  }
  
  public void setValue(final Object value){
    this. = value;
  }
  
  public Access getAccess(){
  	return this.;
  }
  
  protected void setSeparator(String separator){
    this. = separator;
  }
  public String getSeparator(){
    if(this. == nullreturn ;
    else return this.;
  }
  
For debugging purposes
  public String toString(){
  	return getName() + "=" + getStringValue();
  }
  
  public static ParameterDataRow createParameterDataRowFromParameters(final List<Parameterparametersthrows InvalidParameterException
  {
    return createParameterDataRowFromParameters(parameters.toArray(new Parameter[parameters.size()]));
  }
  
  public static ParameterDataRow createParameterDataRowFromParameters(final Parameter[] parametersthrows InvalidParameterException
  {
    final ArrayList<Stringnames = new ArrayList<String>();
    final ArrayList<Objectvalues = new ArrayList<Object>();
    if(parameters != nullfor (final Parameter parameter : parameters)
    {
      names.add(parameter.getName());
      values.add(parameter.getValue());
    }
    final ParameterDataRow parameterDataRow = new ParameterDataRow(names.toArray(new String[]
            {
            }), values.toArray());
    return parameterDataRow;
  }
  
  public boolean equals(Object other){
    
    if(other == nullreturn false;
    if(this == otherreturn true;
    
    if(other instanceof Parameter){
      Parameter param = (Parameterother;
      return StringUtils.equals(getName(), param.getName()) &&
             ((getType() == null && param.getType() == null
               || getType().equals(param.getType())) &&
             StringUtils.equals(getStringValue(), param.getStringValue());
    }
    else return false;
  }
  
  public int hashCode() {
    int hashCode = getName() == null ? 0 : getName().hashCode();
    hashCode = 31 * hashCode + (getType() == null ? 0 : getType().hashCode());
    hashCode = 31 * hashCode + (getStringValue() == null ? 0 : getStringValue().hashCode());
    return hashCode;
  };
  public void readObject(ObjectInputStream inthrows IOException {
    try {
      this.setName((Stringin.readObject());
      this.setType((Typein.readObject());
      //if(isDateType()) this.setPattern((String) in.readObject());
      this.setStringValue((Stringin.readObject(), this.getType());
      this.setSeparator((Stringin.readObject());
    } catch (ClassNotFoundException e) {
      throw new IOException("Error casting read object."e);
    }
  }

  
Should only be called on evaluated parameters
  public void writeObject(ObjectOutputStream outthrows IOException {
    out.writeObject(this.getName());
    out.writeObject(this.getType());
   //if(isDateType()) out.writeObject(this.pattern);
    out.writeObject(this.getStringValue());
    out.writeObject(this.getSeparator());
  }
  public void accept(DomVisitor xmlVisitor, Element daEle) {
		  xmlVisitor.visit(thisdaEle);
  }
New to GrepCode? Check out our FAQ X