Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2014 Attila Szegedi, Daniel Dekany, Jonathan Revusky
   * 
   * 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.
  */
 
 package freemarker.core;
 
 import java.util.Map;
 
 
 
     private static final Map JAVA_DATE_FORMATS = new HashMap();
     
     private final Locale locale
     
     private Map/*<TemplateDateFormat>*/[] formatCache;
 
     public JavaTemplateDateFormatFactory(TimeZone timeZoneLocale locale) {
         super(timeZone);
         this. = locale;
     }
 
     public boolean isLocaleBound() {
         return true;
     }

    

Parameters:
zonelessInput Has no effect in this implementation.
 
     public TemplateDateFormat get(int dateTypeboolean zonelessInputString formatDescriptor)
         Map/*<TemplateDateFormat>*/[] formatCache = this.;
         if(formatCache == null) {
             formatCache = new Map[4]; // Index 0..3: values of TemplateDateModel's date type constants
             this. = formatCache
         }
         
         Map/*<TemplateDateFormat>*/ formatsForDateType = formatCache[dateType];
         if (formatsForDateType == null) {
             formatsForDateType = new HashMap/*<TemplateDateFormat>*/();
             formatCache[dateType] = formatsForDateType
         }
 
         TemplateDateFormat format = (TemplateDateFormatformatsForDateType.get(formatDescriptor);
         if(format == null) {
             format = new JavaTemplateDateFormat(getJavaDateFormat(dateTypeformatDescriptor));
             formatsForDateType.put(formatDescriptorformat);
         }
         return format;
     }
 
     private DateFormat getJavaDateFormat(int dateTypeString nameOrPattern)
 
         // Get DateFormat from global cache:
         DateFormatKey cacheKey = new DateFormatKey(
                 dateTypenameOrPatterngetTimeZone());
         DateFormat jDateFormat;
         synchronized () {
             jDateFormat = (DateFormat.get(cacheKey);
             if (jDateFormat == null) {
                 // Add format to global format cache.
                 StringTokenizer tok = new StringTokenizer(nameOrPattern"_");
                 int tok1Style = tok.hasMoreTokens() ? parseDateStyleToken(tok.nextToken()) : .;
                 if (tok1Style != -1) {
                     switch (dateType) {
                         case .: {
                             throw new UnknownDateTypeFormattingUnsupportedException();
                         }
                         case .: {
                             jDateFormat = DateFormat.getTimeInstance(tok1StylecacheKey.locale);
                             break;
                         }
                         case .: {
                             jDateFormat = DateFormat.getDateInstance(tok1StylecacheKey.locale);
                             break;
                         }
                         case .: {
                            int tok2Style = tok.hasMoreTokens() ? parseDateStyleToken(tok.nextToken()) : tok1Style;
                            if(tok2Style != -1) {
                                jDateFormat = DateFormat.getDateTimeInstance(tok1Styletok2StylecacheKey.locale);
                            }
                            break;
                        }
                    }
                }
                if (jDateFormat == null) {
                    try {
                        jDateFormat = new SimpleDateFormat(nameOrPatterncacheKey.locale);
                    } catch(IllegalArgumentException e) {
                        final String msg = e.getMessage();
                        throw new ParseException(msg != null ? msg : "Illegal SimpleDateFormat pattern", 0);
                    }
                }
                jDateFormat.setTimeZone(cacheKey.timeZone);
                
                .put(cacheKeyjDateFormat);
            }  // if cache miss
        }  // sync
        
        // Store the value from the global cache in to the local cache:
        return (DateFormatjDateFormat.clone();  // For thread safety
    }
    private static final class DateFormatKey {
        private final int dateType;
        private final String pattern;
        private final Locale locale;
        private final TimeZone timeZone;
        DateFormatKey(int dateTypeString patternLocale localeTimeZone timeZone) {
            this. = dateType;
            this. = pattern;
            this. = locale;
            this. = timeZone;
        }
        public boolean equals(Object o) {
            if (o instanceof DateFormatKey) {
                DateFormatKey fk = (DateFormatKeyo;
                return  == fk.dateType && fk.pattern.equals() && fk.locale.equals()
                        && fk.timeZone.equals();
            }
            return false;
        }
        public int hashCode() {
            return  ^ .hashCode() ^ .hashCode() ^ .hashCode();
        }
    }
    private int parseDateStyleToken(String token) {
        if ("short".equals(token)) {
            return .;
        }
        if ("medium".equals(token)) {
            return .;
        }
        if ("long".equals(token)) {
            return .;
        }
        if ("full".equals(token)) {
            return .;
        }
        return -1;
    }
    
New to GrepCode? Check out our FAQ X