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;
 
An instruction that makes a single assignment, like [#local x=1]. This is also used as the child of AssignmentInstruction, if there are multiple assignments in the same tag, like in [#local x=1 x=2].
 
 final class Assignment extends TemplateElement {
 
     // These must not clash with ArithmeticExpression.TYPE_... constants: 
     private static final int OPERATOR_TYPE_EQUALS = 0x10000;
     private static final int OPERATOR_TYPE_PLUS_EQUALS = 0x10001;
     private static final int OPERATOR_TYPE_PLUS_PLUS = 0x10002;
     private static final int OPERATOR_TYPE_MINUS_MINUS = 0x10003;
     
     private final int/*enum*/ scope;
     private final String variableName;
     private final int operatorType;
     private final Expression valueExp;
     private Expression namespaceExp;
 
     static final int NAMESPACE = 1;
     static final int LOCAL = 2;
     static final int GLOBAL = 3;
     
     // Java 5: Integer.valueOf(1)
     private static final Number ONE = new Integer(1);

    

Parameters:
variableName the variable name to assign to.
valueExp the expression to assign.
scope the scope of the assignment, one of NAMESPACE, LOCAL, or GLOBAL
 
     Assignment(String variableName,
             int operator,
             Expression valueExp,
             int scope) {
         this. = scope;
         
         this. = variableName;
         
         if (operator == .) {
              = ;
         } else {
             switch (operator) {
             case .:
                  = ;
                 break;
             case .:
                  = ;
                 break;
             case .:
                  = ;
                 break;
             case .:
                  = .;
                 break;
             case .:
                  = .;
                 break;
             case .:
                  = .;
                 break;
             case .:
                  = .;
                 break;
             default:
                 throw new BugException();
             }
         }
         
         this. = valueExp;
     }
     
     void setNamespaceExp(Expression namespaceExp) {
         if ( !=  && namespaceExp != nullthrow new BugException();
         this. =  namespaceExp;
     }
    void accept(Environment envthrows TemplateException {
        final Environment.Namespace namespace;
        if ( == null) {
            switch () {
            case :
                namespace = null;
                break;
            case :
                namespace = env.getGlobalNamespace();
                break;
            case :
                namespace = env.getCurrentNamespace();
                break;
            default:
                throw new BugException("Unexpected scope type: " + );
            }
        } else {
            TemplateModel namespaceTM = .eval(env);
            try {
                namespace = (Environment.NamespacenamespaceTM;
            } catch (ClassCastException e) {
                throw new NonNamespaceException(namespaceTMenv);
            }
            if (namespace == null) {
                throw InvalidReferenceException.getInstance(env);
            }
        }
        
        TemplateModel value;
        if ( == ) {
            value = .eval(env);
            if (value == null) {
                if (env.isClassicCompatible()) {
                    value = .;
                } else {
                    throw InvalidReferenceException.getInstance(env);
                }
            }
        } else {
            TemplateModel lhoValue;
            if (namespace == null) {
                lhoValue = env.getLocalVariable();
            } else {
                lhoValue = namespace.get();
            }
            
            if ( == ) {  // Add or concat operation
                if (lhoValue == null) {
                    if (env.isClassicCompatible()) {
                        lhoValue = .;
                    } else {
                        throw InvalidReferenceException.getInstance(
                                getOperatorTypeAsString(), env);
                    }
                }
                
                value = .eval(env);
                if (value == null) {
                    if (env.isClassicCompatible()) {
                        value = .;
                    } else {
                        throw InvalidReferenceException.getInstance(env);
                    }
                }
                value = AddConcatExpression._eval(envnulllhoValuevalue);
            } else {  // Numerical operation
                Number lhoNumber;
                if (lhoValue instanceof TemplateNumberModel) {
                    lhoNumber = EvalUtil.modelToNumber((TemplateNumberModellhoValuenull);
                } else if (lhoValue == null) {
                    throw InvalidReferenceException.getInstance(getOperatorTypeAsString(), env);
                } else {
                    throw new NonNumericalException(lhoValuenullenv);
                }
                if ( == ) {
                    value  = AddConcatExpression._evalOnNumbers(envgetParentElement(), lhoNumber);
                } else if ( == ) {
                    value = ArithmeticExpression._eval(
                            envgetParentElement(), lhoNumber.);
                } else { // operatorType == ArithmeticExpression.TYPE_...
                    Number rhoNumber = .evalToNumber(env);
                    value = ArithmeticExpression._eval(envthislhoNumberrhoNumber);
                }
            }
        }
        
        if (namespace == null) {
            env.setLocalVariable(value);
        } else {
            namespace.put(value);
        }
    }
    protected String dump(boolean canonical) {
        StringBuffer buf = new StringBuffer();
        String dn = getParentElement() instanceof AssignmentInstruction ? null : getNodeTypeSymbol();
        if (dn != null) {
            if (canonicalbuf.append("<");
            buf.append(dn);
            buf.append(' ');
        }
        
        buf.append(_CoreStringUtils.toFTLTopLevelTragetIdentifier());
        
        if ( != null) {
            buf.append(' ');
        }
        buf.append(getOperatorTypeAsString());
        if ( != null) {
            buf.append(' ');
            buf.append(.getCanonicalForm());
        }
        if (dn != null) {
            if ( != null) {
                buf.append(" in ");
                buf.append(.getCanonicalForm());
            }
            if (canonicalbuf.append(">");
        }
        String result = buf.toString();
        return result;
    }
    
        return getDirectiveName();
    }
    
    static String getDirectiveName(int scope) {
        if (scope == .) {
            return "#local";
        } else if (scope == .) {
            return "#global";
        } else if (scope == .) {
            return "#assign";
        } else {
            return "#{unknown_assignment_type}";
        }
    }
    
    int getParameterCount() {
        return 5;
    }
    Object getParameterValue(int idx) {
        switch (idx) {
        case 0: return ;
        case 1: return getOperatorTypeAsString();
        case 2: return ;
        case 3: return new Integer();
        case 4: return ;
        defaultthrow new IndexOutOfBoundsException();
        }
    }
    ParameterRole getParameterRole(int idx) {
        switch (idx) {
        case 0: return .;
        case 1: return .;
        case 2: return .;
        case 3: return .;
        case 4: return .;
        defaultthrow new IndexOutOfBoundsException();
        }
    }
    boolean isNestedBlockRepeater() {
        return false;
    }
    
    private String getOperatorTypeAsString() {
        if ( == ) {
            return "=";
        } else if ( == ) {
            return "+=";
        } else if ( == ) {
            return "++";
        } else if ( == ) {
            return "--";
        } else {
            return ArithmeticExpression.getOperatorSymbol() + "=";
        }
    }
    
New to GrepCode? Check out our FAQ X