Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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.myfaces.shared.util;
 
 
 import java.util.Date;
 
Utility class for Tag classes

Version:
$Name: $ ($Revision: adfrt/faces/adf-faces-impl/src/main/java/oracle/adfinternal/view/faces/taglib/util/TagUtils.java.1 $) $Date: 11-nov-2005.14:59:38 $
 
 public final class TagUtils
 {
   //private static final Log LOG = LogFactory.getLog(TagUtils.class);
   private static final Logger LOG = Logger.getLogger(TagUtils.class.getName());
 
   private TagUtils()
   {
   }
 
   public static ValueExpression getValueExpression(String valueExpressionClass<?> expectedType)
   {
     FacesContext context = FacesContext.getCurrentInstance();
     ELContext elContext = context.getELContext();
     
     return fact.createValueExpression(elContextvalueExpressionexpectedType);
   }
 
   public static void assertNotNull(Object object)
   {
     if (null == object)
     {
       throw new NullPointerException();
     }
   }
 
   // Helpful with tag auto generation. Though this isn't really required.
   
Return the same string. It is there for convenience and makes life easy while auto generating tags.

Parameters:
value
Returns:
 
   public static String getString(
     Object value)
   {
     if (value == null)
     {
         return null;
     }
 
     return value.toString();
   }

  
String --> boolean

Parameters:
value
Returns:
 
   public static boolean getBoolean(
     Object  value)
   {
     if (value == null)
     {
         return false;
     }
     
     if (value instanceof Boolean)
    {
        return ((Booleanvalue).booleanValue();
    }
    return Boolean.valueOf(value.toString()).booleanValue();
  }

  
String --> int

Parameters:
value
Returns:
  public static int getInteger(
    Object  value)
  {
    if (value == null)
    {
        return 0;
    }
    if (value instanceof Number)
    {
        return ((Numbervalue).intValue();
    }
    return Integer.valueOf(value.toString()).intValue();
  }

  
String --> long

Parameters:
value
Returns:
  public static long getLong(
    Object      value)
  {
    if (value == null)
    {
        return 0;
    }
    return Long.valueOf(value.toString()).longValue();
  }

  
String --> long

Parameters:
value
Returns:
  public static double getDouble(
    Object      value)
  {
    if (value == null)
    {
        return 0;
    }
    return Double.valueOf(value.toString()).doubleValue();
  }

  
String --> long

Parameters:
value
Returns:
  public static float getFloat(
    Object      value)
  {
    if (value == null)
    {
        return 0;
    }
    return Float.valueOf(value.toString()).floatValue();
  }

  
These are normally NMTOKEN type in attributes String --> String[]

Parameters:
value
Returns:

  
These are normally NMTOKEN type in attributes String --> String[]

Parameters:
value
Returns:
  public static String[] getStringArray(
    Object  valuethrows ParseException
  {
    if (value == null)
    {
        return null;
    }
    return getTokensArray(value.toString());
  }

  
ISO Date String --> Date

Parameters:
value
Returns:
  public static Date getDate(
    Object   value)
  {
    if (value == null)
    {
        return null;
    }
    if (value instanceof Date)
    {
        return ((Datevalue);
    }
    return parseISODate(value.toString());
  }

  
String --> Locale

Parameters:
value
Returns:
  public static Locale getLocale(
    Object      value)
  {
    if (value == null)
    {
        return null;
    }
    if (value instanceof Locale)
    {
        return ((Localevalue);
    }
    return getLocaleInternal(value.toString());
  }

  
String --> TimeZone

Parameters:
value
Returns:
public static TimeZone getTimeZone( String value) { return DateUtils.getSupportedTimeZone(value); }
  public static boolean isValueReference(String expression)
  {
    if (null != expression)
    {
      int start = expression.indexOf("#{");
      if ((start >= 0) && (expression.indexOf('}'start + 1) >= 0))
      {
          return true;
      }
    }
    return false;
  }



  
Takes a string that is a composite of tokens, extracts tokens delimited by any whitespace character sequence combination and returns a String array of such tokens.

Throws:
java.text.ParseException In case of invalid character in the specified composite. The only invalid character is a comma (',').
  private static String[] getTokensArray(String tokenComposite)
    throws ParseException
  {
    if (tokenComposite == null || "".equals(tokenComposite))
    {
        return null;
    }
    return parseNameTokens(tokenComposite);
  }

  
Parse a string into a java.util.Date object. The string must be in ISO 9601 format (yyyy-MM-dd).

Todo:
why not throw the exception in a different format? why do we kill it here and return null?
  static private final Date parseISODate(String stringValue)
  {
    try
    {
      return getDateFormat().parse(stringValue);
    }
    catch (ParseException pe)
    {
      if (.isLoggable(.))
      {
        .log(."CANNOT_PARSE_VALUE_INTO_DATE_WITH_YYYY_MM_DD_PATTERN "stringValuepe);
      }
      return null;
    }
  }
  
  
Parses a whitespace separated series of name tokens.

Parameters:
stringValue the full string
Returns:
an array of each constituent value, or null if there are no tokens (that is, the string is empty or all whitespace)
  static public String[] parseNameTokens(String stringValue)
  {
    if (stringValue == null)
    {
        return null;
    }
    ArrayList<Stringlist = new ArrayList<String>(5);
    int     length = stringValue.length();
    boolean inSpace = true;
    int     start = 0;
    for (int i = 0; i < lengthi++)
    {
      char ch = stringValue.charAt(i);
      // We're in whitespace;  if we've just departed
      // a run of non-whitespace, append a string.
      // Now, why do we use the supposedly deprecated "Character.isSpace()"
      // function instead of "isWhitespace"?  We're following XML rules
      // here for the meaning of whitespace, which specifically
      // EXCLUDES general Unicode spaces.
      if (Character.isWhitespace(ch))
      {
        if (!inSpace)
        {
          list.add(stringValue.substring(starti));
          inSpace = true;
        }
      }
      // We're out of whitespace;  if we've just departed
      // a run of whitespace, start keeping track of this string
      else
      {
        if (inSpace)
        {
          start = i;
          inSpace = false;
        }
      }
    }
    if (!inSpace)
    {
        list.add(stringValue.substring(start));
    }
    if (list.isEmpty())
    {
        return null;
    }
    return list.toArray(new String[list.size()]);
  }
  
  private static Locale getLocaleInternal(String locale)
  {
    String localeStr = locale.replace('-','_');
    String[] tokens = localeStr.split("[_]", 3);
    Locale locl = null;
    if ( tokens.length == 1)
    {
      locl = new Locale(tokens[0]); //lang
    }
    else if (tokens.length == 2)
    {
      locl = new Locale(tokens[0], tokens[1]); // lang + country
    }
    else if (tokens.length == 3 )
    {
      locl = new Locale(tokens[0], tokens[1], tokens[2]); // lang + country + variant
    }
    else
    {
      if(.isLoggable(.))
      {
          .log(."tokens length should not be greater than 3.");
      }
    }
    return locl;
  }
  // We rely strictly on ISO 8601 formats
  private static DateFormat getDateFormat()
  {
    return new SimpleDateFormat("yyyy-MM-dd");
  }
New to GrepCode? Check out our FAQ X