1 /*

     2  * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 /*

    25  * This is pluggable context used by test for 6398614

    26  */

    27 

    28 import javax.script.*;

    29 import java.util.*;

    30 import java.io.*;

    31 

    32 public class MyContext  implements ScriptContext {

    33 

    34     public static final int APP_SCOPE = 125;

    35 

    36     protected Writer writer;

    37 

    38     protected Writer errorWriter;

    39 

    40     protected Reader reader;

    41 

    42 

    43     protected Bindings appScope;

    44     protected Bindings engineScope;

    45     protected Bindings globalScope;

    46 

    47 

    48     public MyContext() {

    49         appScope = new SimpleBindings();

    50         engineScope = new SimpleBindings();

    51         globalScope = null;

    52         reader = new InputStreamReader(System.in);

    53         writer = new PrintWriter(System.out , true);

    54         errorWriter = new PrintWriter(System.err, true);

    55     }

    56 

    57     public void setBindings(Bindings bindings, int scope) {

    58 

    59         switch (scope) {

    60             case APP_SCOPE:

    61                 if (bindings == null) {

    62                     throw new NullPointerException("App scope cannot be null.");

    63                 }

    64                 appScope = bindings;

    65                 break;

    66 

    67             case ENGINE_SCOPE:

    68                 if (bindings == null) {

    69                     throw new NullPointerException("Engine scope cannot be null.");

    70                 }

    71                 engineScope = bindings;

    72                 break;

    73             case GLOBAL_SCOPE:

    74                 globalScope = bindings;

    75                 break;

    76             default:

    77                 throw new IllegalArgumentException("Invalid scope value.");

    78         }

    79     }

    80 

    81     public Object getAttribute(String name) {

    82         if (engineScope.containsKey(name)) {

    83             return getAttribute(name, ENGINE_SCOPE);

    84         } else if (appScope.containsKey(name)) {

    85             return getAttribute(name, APP_SCOPE);

    86         } else if (globalScope != null && globalScope.containsKey(name)) {

    87             return getAttribute(name, GLOBAL_SCOPE);

    88         }

    89 

    90         return null;

    91     }

    92 

    93     public Object getAttribute(String name, int scope) {

    94 

    95         switch (scope) {

    96             case APP_SCOPE:

    97                 return appScope.get(name);

    98 

    99             case ENGINE_SCOPE:

   100                 return engineScope.get(name);

   101 

   102             case GLOBAL_SCOPE:

   103                 if (globalScope != null) {

   104                     return globalScope.get(name);

   105                 }

   106                 return null;

   107 

   108             default:

   109                 throw new IllegalArgumentException("Illegal scope value.");

   110         }

   111     }

   112 

   113     public Object removeAttribute(String name, int scope) {

   114 

   115         switch (scope) {

   116             case APP_SCOPE:

   117                 if (getBindings(APP_SCOPE) != null) {

   118                     return getBindings(APP_SCOPE).remove(name);

   119                 }

   120                 return null;

   121 

   122 

   123             case ENGINE_SCOPE:

   124                 if (getBindings(ENGINE_SCOPE) != null) {

   125                     return getBindings(ENGINE_SCOPE).remove(name);

   126                 }

   127                 return null;

   128 

   129             case GLOBAL_SCOPE:

   130                 if (getBindings(GLOBAL_SCOPE) != null) {

   131                     return getBindings(GLOBAL_SCOPE).remove(name);

   132                 }

   133                 return null;

   134 

   135             default:

   136                 throw new IllegalArgumentException("Illegal scope value.");

   137         }

   138     }

   139 

   140     public void setAttribute(String name, Object value, int scope) {

   141 

   142         switch (scope) {

   143             case APP_SCOPE:

   144                 appScope.put(name, value);

   145                 return;

   146 

   147             case ENGINE_SCOPE:

   148                 engineScope.put(name, value);

   149                 return;

   150 

   151             case GLOBAL_SCOPE:

   152                 if (globalScope != null) {

   153                     globalScope.put(name, value);

   154                 }

   155                 return;

   156 

   157             default:

   158                 throw new IllegalArgumentException("Illegal scope value.");

   159         }

   160     }

   161 

   162     public Writer getWriter() {

   163         return writer;

   164     }

   165 

   166     public Reader getReader() {

   167         return reader;

   168     }

   169 

   170     public void setReader(Reader reader) {

   171         this.reader = reader;

   172     }

   173 

   174     public void setWriter(Writer writer) {

   175         this.writer = writer;

   176     }

   177 

   178     public Writer getErrorWriter() {

   179         return errorWriter;

   180     }

   181 

   182     public void setErrorWriter(Writer writer) {

   183         this.errorWriter = writer;

   184     }

   185 

   186     public int getAttributesScope(String name) {

   187         if (engineScope.containsKey(name)) {

   188             return ENGINE_SCOPE;

   189         } else if (appScope.containsKey(name)) {

   190             return APP_SCOPE;

   191         } else if (globalScope != null && globalScope.containsKey(name)) {

   192             return GLOBAL_SCOPE;

   193         } else {

   194             return -1;

   195         }

   196     }

   197 

   198     public Bindings getBindings(int scope) {

   199         if (scope == ENGINE_SCOPE) {

   200             return engineScope;

   201         } else if (scope == APP_SCOPE) {

   202             return appScope;

   203         } else if (scope == GLOBAL_SCOPE) {

   204             return globalScope;

   205         } else {

   206             throw new IllegalArgumentException("Illegal scope value.");

   207         }

   208     }

   209 

   210     public List<Integer> getScopes() {

   211         return scopes;

   212     }

   213 

   214     private static List<Integer> scopes;

   215     static {

   216         scopes = new ArrayList<Integer>(3);

   217         scopes.add(ENGINE_SCOPE);

   218         scopes.add(APP_SCOPE);

   219         scopes.add(GLOBAL_SCOPE);

   220         scopes = Collections.unmodifiableList(scopes);

   221     }

   222 }