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.Date;
 import java.util.List;
 
A holder for builtins that didn't fit into any other category.
 
 
     static class cBI extends AbstractCBI implements ICIChainMember {
         
         static class BIBeforeICE2d3d21 extends AbstractCBI {
 
             protected TemplateModel formatNumber(Environment envTemplateModel modelthrows TemplateModelException {
                 Number num = EvalUtil.modelToNumber((TemplateNumberModelmodel);
                 if (num instanceof Integer || num instanceof Long) {
                     // Accelerate these fairly common cases
                     return new SimpleScalar(num.toString());
                 } else {
                     return new SimpleScalar(env.getCNumberFormat().format(num));
                 }
             }
             
         }
         
         private final BIBeforeICE2d3d21 prevICIObj = new BIBeforeICE2d3d21();
 
         TemplateModel _eval(Environment envthrows TemplateException {
             TemplateModel model = .eval(env);
             if (model instanceof TemplateNumberModel) {
                 return formatNumber(envmodel);
             } else if (model instanceof TemplateBooleanModel) {
                 return new SimpleScalar(((TemplateBooleanModelmodel).getAsBoolean()
                         ? . : .);
             } else {
                 throw new UnexpectedTypeException(
                         model,
                         "number or boolean"new Class[] { TemplateNumberModel.classTemplateBooleanModel.class },
                         env);
             }
         }
 
         protected TemplateModel formatNumber(Environment envTemplateModel modelthrows TemplateModelException {
             Number num = EvalUtil.modelToNumber((TemplateNumberModelmodel);
             if (num instanceof Integer || num instanceof Long) {
                 // Accelerate these fairly common cases
                 return new SimpleScalar(num.toString());
             } else if (num instanceof Double) {
                 double n = num.doubleValue();
                 if (n == .) {
                     return new SimpleScalar("INF");
                 }
                 if (n == .) {
                     return new SimpleScalar("-INF");
                 }
                if (Double.isNaN(n)) {
                    return new SimpleScalar("NaN");
                }
                // Deliberately falls through
            } else if (num instanceof Float) {
                float n = num.floatValue();
                if (n == .) {
                    return new SimpleScalar("INF");
                }
                if (n == .) {
                    return new SimpleScalar("-INF");
                }
                if (Float.isNaN(n)) {
                    return new SimpleScalar("NaN");
                }
                // Deliberately falls through
            }
        
            return new SimpleScalar(env.getCNumberFormat().format(num));
        }
        public int getMinimumICIVersion() {
            return .;
        }
        
        public Object getPreviousICIChainMember() {
            return ;
        }
        
    }
    static class dateBI extends BuiltIn {
        private class DateParser
        implements
            TemplateDateModel,
            TemplateMethodModel,
            TemplateHashModel
        {
            private final String text;
            private final Environment env;
            private final TemplateDateFormat defaultFormat;
            private Date cachedValue;
            
            DateParser(String textEnvironment env)
            throws
                TemplateModelException
            {
                this. = text;
                this. = env;
                // Deliberately creating a snapshot here:
                this. = env.getTemplateDateFormat(Date.class);
            }
            
            public Object exec(List argsthrows TemplateModelException {
                checkMethodArgCount(args, 1);
                return get((Stringargs.get(0));
            }
            
            public TemplateModel get(String patternthrows TemplateModelException {
                return new SimpleDate(
                    parse(.getTemplateDateFormat(Date.classpattern)),
                    );
            }
    
            public Date getAsDate() throws TemplateModelException {
                if( == null) {
                     = parse();
                }
                return ;
            }
    
            public int getDateType() {
                return ;
            }
    
            public boolean isEmpty()
            {
                return false;
            }
    
            private Date parse(TemplateDateFormat df)
            throws
                TemplateModelException
            {
                try {
                    return df.parse();
                }
                catch(java.text.ParseException e) {
                    throw new _TemplateModelException(enew Object[] {
                            "The string doesn't match the expected date/time/date-time format. "
                            + "The string to parse was: "new _DelayedJQuote(), ". ",
                            "The expected format was: "new _DelayedJQuote(df.getDescription()), ".",
                            e.getMessage() != null ? "\nThe nested reason given follows:\n" : "",
                            e.getMessage() != null ? e.getMessage() : "" });
                }
            }
            
        }
        
        private final int dateType;
        
        dateBI(int dateType) {
            this. = dateType;
        }
        
        TemplateModel _eval(Environment env)
                throws TemplateException
        {
            TemplateModel model = .eval(env);
            if (model instanceof TemplateDateModel) {
                TemplateDateModel dmodel = (TemplateDateModel)model;
                int dtype = dmodel.getDateType();
                // Any date model can be coerced into its own type
                if( == dtype) {
                    return model;
                }
                // unknown and datetime can be coerced into any date type
                if(dtype == . || dtype == .) {
                    return new SimpleDate(dmodel.getAsDate(), );
                }
                throw new _MiscTemplateException(thisnew Object[] {
                            "Cannot convert "..get(dtype),
                            " to "..get() });
            }
            // Otherwise, interpret as a string and attempt 
            // to parse it into a date.
            String s = .evalAndCoerceToString(env);
            return new DateParser(senv);
        }
    }
    static class apiBI extends BuiltIn {
        TemplateModel _eval(Environment envthrows TemplateException {
            if (!env.isAPIBuiltinEnabled()) {
                throw new _MiscTemplateException(thisnew Object[] {
                        "Can't use ?api, because the \"".,
                        "\" configuration setting is false. Think twice before you set it to true though. Especially, "
                        + "it shouldn't abussed for modifying Map-s and Collection-s." });
            }
            final TemplateModel tm = .eval(env);
            if (!(tm instanceof TemplateModelWithAPISupport)) {
                .assertNonNull(tmenv);
                throw new APINotSupportedTemplateException(envtm);
            }
            return ((TemplateModelWithAPISupporttm).getAPI();
        }
    }
    static class has_apiBI extends BuiltIn {
        TemplateModel _eval(Environment envthrows TemplateException {
            final TemplateModel tm = .eval(env);
            .assertNonNull(tmenv);
            return tm instanceof TemplateModelWithAPISupport ? . : .;
        }
    }
    
    static class is_booleanBI extends BuiltIn {
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel tm = .eval(env);
            .assertNonNull(tmenv);
            return (tm instanceof TemplateBooleanModel)  ?
                . : .;
        }
    }
    static class is_collectionBI extends BuiltIn {
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel tm = .eval(env);
            .assertNonNull(tmenv);
            return (tm instanceof TemplateCollectionModel) ? . : .;
        }
    }
    static class is_collection_exBI extends BuiltIn {
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel tm = .eval(env);
            .assertNonNull(tmenv);
            return (tm instanceof TemplateCollectionModelEx) ? . : .;
        }
    }
    static class is_dateLikeBI extends BuiltIn {
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel tm = .eval(env);
            .assertNonNull(tmenv);
            return (tm instanceof TemplateDateModel)  ?
                . : .;
        }
    }
    static class is_dateOfTypeBI extends BuiltIn {
        
        private final int dateType;
        
        is_dateOfTypeBI(int dateType) {
            this. = dateType;
        }
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel tm = .eval(env);
            .assertNonNull(tmenv);
            return (tm instanceof TemplateDateModel) && ((TemplateDateModeltm).getDateType() == 
                ? . : .;
        }
    }
    static class is_directiveBI extends BuiltIn {
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel tm = .eval(env);
            .assertNonNull(tmenv);
            // WRONG: it also had to check Macro.isFunction()
            return (tm instanceof TemplateTransformModel || tm instanceof Macro || tm instanceof TemplateDirectiveModel) ?
                . : .;
        }
    }
    static class is_enumerableBI extends BuiltIn {
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel tm = .eval(env);
            .assertNonNull(tmenv);
            return (tm instanceof TemplateSequenceModel || tm instanceof TemplateCollectionModel)
                    && (_TemplateAPI.getTemplateLanguageVersionAsInt(this) < .
                        // These implement TemplateSequenceModel, yet they can't be #list-ed:
                        || !(tm instanceof SimpleMethodModel || tm instanceof OverloadedMethodsModel))
                    ? . : .;
        }
    }
    static class is_hash_exBI extends BuiltIn {
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel tm = .eval(env);
            .assertNonNull(tmenv);
            return (tm instanceof TemplateHashModelEx) ? . : .;
        }
    }
    static class is_hashBI extends BuiltIn {
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel tm = .eval(env);
            .assertNonNull(tmenv);
            return (tm instanceof TemplateHashModel) ? . : .;
        }
    }
    static class is_indexableBI extends BuiltIn {
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel tm = .eval(env);
            .assertNonNull(tmenv);
            return (tm instanceof TemplateSequenceModel) ? . : .;
        }
    }
    static class is_macroBI extends BuiltIn {
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel tm = .eval(env);
            .assertNonNull(tmenv);
            // WRONG: it also had to check Macro.isFunction()
            return (tm instanceof Macro)  ?
                . : .;
        }
    }
    static class is_methodBI extends BuiltIn {
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel tm = .eval(env);
            .assertNonNull(tmenv);
            return (tm instanceof TemplateMethodModel)  ?
                . : .;
        }
    }
    static class is_nodeBI extends BuiltIn {
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel tm = .eval(env);
            .assertNonNull(tmenv);
            return (tm instanceof TemplateNodeModel)  ?
                . : .;
        }
    }
    static class is_numberBI extends BuiltIn {
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel tm = .eval(env);
            .assertNonNull(tmenv);
            return (tm instanceof TemplateNumberModel)  ?
                . : .;
        }
    }
    static class is_sequenceBI extends BuiltIn {
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel tm = .eval(env);
            .assertNonNull(tmenv);
            return (tm instanceof TemplateSequenceModel) ? . : .;
        }
    }
    static class is_stringBI extends BuiltIn {
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel tm = .eval(env);
            .assertNonNull(tmenv);
            return (tm instanceof TemplateScalarModel)  ?
                . : .;
        }
    }
    static class is_transformBI extends BuiltIn {
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel tm = .eval(env);
            .assertNonNull(tmenv);
            return (tm instanceof TemplateTransformModel)  ?
                . : .;
        }
    }
    static class namespaceBI extends BuiltIn {
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel tm = .eval(env);
            if (!(tm instanceof Macro)) {
                throw new UnexpectedTypeException(
                        tm,
                        "macro or function"new Class[] { Macro.class },
                        env);
            } else {
                return env.getMacroNamespace((Macrotm);
            }
        }
    }
    static class sizeBI extends BuiltIn {
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel model = .eval(env);
            final int size;
            if (model instanceof TemplateSequenceModel) {
                size = ((TemplateSequenceModelmodel).size();
            } else if (model instanceof TemplateCollectionModelEx) {
                size = ((TemplateCollectionModelExmodel).size();
            } else if (model instanceof TemplateHashModelEx) {
                size = ((TemplateHashModelExmodel).size();
            } else {
                throw new UnexpectedTypeException(
                        model,
                        "extended-hash or sequence or extended collection",
                        new Class[] {
                                TemplateHashModelEx.class,
                                TemplateSequenceModel.class,
                                TemplateCollectionModelEx.class
                        },
                        env);
            }
            return new SimpleNumber(size);
        }
    }
    
    static class stringBI extends BuiltIn {
        
        private class BooleanFormatter
        implements 
            TemplateScalarModel
            TemplateMethodModel 
        {
            private final TemplateBooleanModel bool;
            private final Environment env;
            
            BooleanFormatter(TemplateBooleanModel boolEnvironment env) {
                this. = bool;
                this. = env;
            }
    
            public Object exec(List argsthrows TemplateModelException {
                checkMethodArgCount(args, 2);
                return new SimpleScalar((Stringargs.get(.getAsBoolean() ? 0 : 1));
            }
    
            public String getAsString() throws TemplateModelException {
                // Boolean should have come first... but that change would be non-BC. 
                if ( instanceof TemplateScalarModel) {
                    return ((TemplateScalarModel).getAsString();
                } else {
                    try {
                        return .formatBoolean(.getAsBoolean(), true);
                    } catch (TemplateException e) {
                        throw new TemplateModelException(e);
                    }
                }
            }
        }
    
        private class DateFormatter
        implements
            TemplateScalarModel,
            TemplateHashModel,
            TemplateMethodModel
        {
            private final TemplateDateModel dateModel;
            private final Environment env;
            private final TemplateDateFormat defaultFormat;
            private String cachedValue;
    
            DateFormatter(TemplateDateModel dateModelEnvironment env)
            throws
                TemplateModelException
            {
                this. = dateModel;
                this. = env;
                
                final int dateType = dateModel.getDateType();
                this. = dateType == .
                        ? null  // Lazy unknown type error in getAsString()
                        : env.getTemplateDateFormat(
                                dateType, EvalUtil.modelToDate(dateModel).getClass(), );
            }
    
            public Object exec(List argsthrows TemplateModelException {
                checkMethodArgCount(args, 1);
                return get((Stringargs.get(0));
            }
            public TemplateModel get(String key)
            throws
                TemplateModelException
            {
                return new SimpleScalar(.formatDate(key));
            }
            
            public String getAsString()
            throws
                TemplateModelException
            {
                if( == null) {
                    try {
                        if ( == null) {
                            if (.getDateType() == .) {
                                throw MessageUtil.newCantFormatUnknownTypeDateException(null);
                            } else {
                                throw new BugException();
                            }
                        }
                         = .format();
                    } catch (UnformattableDateException e) {
                        throw MessageUtil.newCantFormatDateException(e);
                    }
                }
                return ;
            }
    
            public boolean isEmpty()
            {
                return false;
            }
        }
        
        private class NumberFormatter
        implements
            TemplateScalarModel,
            TemplateHashModel,
            TemplateMethodModel
        {
            private final Number number;
            private final Environment env;
            private final NumberFormat defaultFormat;
            private String cachedValue;
    
            NumberFormatter(Number numberEnvironment env)
            {
                this. = number;
                this. = env;
                 = env.getNumberFormatObject(env.getNumberFormat());
            }
    
            public Object exec(List argsthrows TemplateModelException {
                checkMethodArgCount(args, 1);
                return get((Stringargs.get(0));
            }
    
            public TemplateModel get(String key)
            {
                return new SimpleScalar(.getNumberFormatObject(key).format());
            }
            
            public String getAsString()
            {
                if( == null) {
                     = .format();
                }
                return ;
            }
    
            public boolean isEmpty()
            {
                return false;
            }
        }
    
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel model = .eval(env);
            if (model instanceof TemplateNumberModel) {
                return new NumberFormatter(EvalUtil.modelToNumber((TemplateNumberModel)model), env);
            } else if (model instanceof TemplateDateModel) {
                TemplateDateModel dm = (TemplateDateModel)model;
                return new DateFormatter(dmenv);
            } else if (model instanceof SimpleScalar) {
                return model;
            } else if (model instanceof TemplateBooleanModel) {
                return new BooleanFormatter((TemplateBooleanModelmodelenv);
            } else if (model instanceof TemplateScalarModel) {
                return new SimpleScalar(((TemplateScalarModelmodel).getAsString());
            } else if (env.isClassicCompatible() && model instanceof BeanModel) {
                return new SimpleScalar(_BeansAPI.getAsClassicCompatibleString((BeanModelmodel));
            } else {            
                throw new UnexpectedTypeException(
                        model,
                        "number, date, boolean or string",
                        new Class[] {
                            TemplateNumberModel.classTemplateDateModel.classTemplateBooleanModel.class,
                            TemplateScalarModel.class
                        },
                        env);
            }
        }
    }
    // Can't be instantiated
    private BuiltInsForMultipleTypes() { }
    static abstract class AbstractCBI extends BuiltIn {
        
        TemplateModel _eval(Environment envthrows TemplateException {
            TemplateModel model = .eval(env);
            if (model instanceof TemplateNumberModel) {
                return formatNumber(envmodel);
            } else if (model instanceof TemplateBooleanModel) {
                return new SimpleScalar(((TemplateBooleanModelmodel).getAsBoolean()
                        ? . : .);
            } else {
                throw new UnexpectedTypeException(
                        model,
                        "number or boolean"new Class[] { TemplateNumberModel.classTemplateBooleanModel.class },
                        env);
            }
        }
    
        protected abstract TemplateModel formatNumber(Environment envTemplateModel modelthrows TemplateModelException;
        
    }