package org.apache.commons.ognl.enhance;

 /*

  * 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.

  */

 import javassist.CannotCompileException;

 import javassist.ClassPool;

 import javassist.CtClass;

 import javassist.CtField;

 import javassist.CtMethod;

 import javassist.CtNewConstructor;

 import javassist.CtNewMethod;

 import javassist.LoaderClassPath;

 import javassist.NotFoundException;

 import org.apache.commons.ognl.ASTAnd;

 import org.apache.commons.ognl.ASTChain;

 import org.apache.commons.ognl.ASTConst;

 import org.apache.commons.ognl.ASTCtor;

 import org.apache.commons.ognl.ASTList;

 import org.apache.commons.ognl.ASTMethod;

 import org.apache.commons.ognl.ASTOr;

 import org.apache.commons.ognl.ASTProperty;

 import org.apache.commons.ognl.ASTRootVarRef;

 import org.apache.commons.ognl.ASTStaticField;

 import org.apache.commons.ognl.ASTStaticMethod;

 import org.apache.commons.ognl.ASTThisVarRef;

 import org.apache.commons.ognl.ASTVarRef;

 import org.apache.commons.ognl.ClassResolver;

 import org.apache.commons.ognl.ExpressionNode;

 import org.apache.commons.ognl.Node;

 import org.apache.commons.ognl.OgnlContext;

 import org.apache.commons.ognl.OgnlRuntime;

 import java.lang.reflect.Method;

 import java.lang.reflect.Modifier;

 import java.util.Collection;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import static java.lang.String.format;

 /**

  * Responsible for managing/providing functionality related to compiling generated java source expressions via bytecode

  * enhancements for a given ognl expression.

  */

 public class ExpressionCompiler

     implements OgnlExpressionCompiler

 {

     /**

      * Key used to store any java source string casting statements in the {@link OgnlContext} during class compilation.

      */

     public static final String PRE_CAST = "_preCast";

     /**

      * {@link ClassLoader} instances.

      */

     protected Map<ClassResolver, EnhancedClassLoader> loaders = new HashMap<ClassResolver, EnhancedClassLoader>();

     /**

      * Javassist class definition poool.

      */

     protected ClassPool pool;

     protected int classCounter = 0;

     /**

      * Used by {@link #castExpression(org.apache.commons.ognl.OgnlContext, org.apache.commons.ognl.Node, String)} to

      * store the cast java source string in to the current {@link org.apache.commons.ognl.OgnlContext}. This will either

      * add to the existing string present if it already exists or create a new instance and store it using the static

      * key of {@link #PRE_CAST}.

      * 

      * @param context The current execution context.

      * @param cast The java source string to store in to the context.

      */

     public static void addCastString( OgnlContext context, String cast )

     {

         String value = (String) context.get( PRE_CAST );

         if ( value != null )

         {

             value = cast + value;

         }

         else

         {

             value = cast;

         }

         context.put( PRE_CAST, value );

     }

     /**

      * Returns the appropriate casting expression (minus parens) for the specified class type.

      * <p/>

      * For instance, if given an {@link Integer} object the string <code>"java.lang.Integer"</code> would be returned.

      * For an array of primitive ints <code>"int[]"</code> and so on..

      * </p>

      * 

      * @param type The class to cast a string expression for.

      * @return The converted raw string version of the class name.

      */

     public static String getCastString( Class<?> type )

     {

         if ( type == null )

         {

             return null;

         }

         return type.isArray() ? type.getComponentType().getName() + "[]" : type.getName();

     }

     /**

      * Convenience method called by many different property/method resolving AST types to get a root expression

      * resolving string for the given node. The callers are mostly ignorant and rely on this method to properly

      * determine if the expression should be cast at all and take the appropriate actions if it should.

      * 

      * @param expression The node to check and generate a root expression to if necessary.

      * @param root The root object for this execution.

      * @param context The current execution context.

      * @return Either an empty string or a root path java source string compatible with javassist compilations from the

      *         root object up to the specified {@link Node}.

      */

     public static String getRootExpression( Node expression, Object root, OgnlContext context )

     {

         String rootExpr = "";

         if ( !shouldCast( expression ) )

         {

             return rootExpr;

         }

         if ( ( !ASTList.class.isInstance( expression ) && !ASTVarRef.class.isInstance( expression )

             && !ASTStaticMethod.class.isInstance( expression ) && !ASTStaticField.class.isInstance( expression )

             && !ASTConst.class.isInstance( expression ) && !ExpressionNode.class.isInstance( expression )

             && !ASTCtor.class.isInstance( expression ) && !ASTStaticMethod.class.isInstance( expression )

             && root != null ) || ( root != null && ASTRootVarRef.class.isInstance( expression ) ) )

         {

             Class<?> castClass = OgnlRuntime.getCompiler( context ).getRootExpressionClass( expression, context );

             if ( castClass.isArray() || ASTRootVarRef.class.isInstance( expression ) || ASTThisVarRef.class.isInstance(

                 expression ) )

             {

                 rootExpr = "((" + getCastString( castClass ) + ")$2)";

                 if ( ASTProperty.class.isInstance( expression ) && !( (ASTProperty) expression ).isIndexedAccess() )

                 {

                     rootExpr += ".";

                 }

             }

             else if ( ( ASTProperty.class.isInstance( expression ) && ( (ASTProperty) expression ).isIndexedAccess() )

                 || ASTChain.class.isInstance( expression ) )

             {

                 rootExpr = "((" + getCastString( castClass ) + ")$2)";

             }

             else

             {

                 rootExpr = "((" + getCastString( castClass ) + ")$2).";

             }

         }

         return rootExpr;

     }

     /**

      * Used by {@link #getRootExpression(org.apache.commons.ognl.Node, Object, org.apache.commons.ognl.OgnlContext)} to

      * determine if the expression needs to be cast at all.

      *

      * @param expression The node to check against.

      * @return Yes if the node type should be cast - false otherwise.

      */

     public static boolean shouldCast( Node expression )

     {

         if ( ASTChain.class.isInstance( expression ) )

         {

             Node child = expression.jjtGetChild( 0 );

             if ( ASTConst.class.isInstance( child ) || ASTStaticMethod.class.isInstance( child )

                 || ASTStaticField.class.isInstance( child ) || ( ASTVarRef.class.isInstance( child )

                 && !ASTRootVarRef.class.isInstance( child ) ) )

             {

                 return false;

             }

         }

         return !ASTConst.class.isInstance( expression );

     }

     /**

      * {@inheritDoc}

      */

     public String castExpression( OgnlContext context, Node expression, String body )

     {

         //TODO: ok - so this looks really f-ed up ...and it is ..eh if you can do it better I'm all for it :)

         if ( context.getCurrentAccessor() == null || context.getPreviousType() == null

             || context.getCurrentAccessor().isAssignableFrom( context.getPreviousType() ) || (

             context.getCurrentType() != null && context.getCurrentObject() != null

                 && context.getCurrentType().isAssignableFrom( context.getCurrentObject().getClass() )

                 && context.getCurrentAccessor().isAssignableFrom( context.getPreviousType() ) ) || body == null

             || body.trim().length() < 1 || ( context.getCurrentType() != null && context.getCurrentType().isArray() && (

             context.getPreviousType() == null || context.getPreviousType() != Object.class ) )

             || ASTOr.class.isInstance( expression ) || ASTAnd.class.isInstance( expression )

             || ASTRootVarRef.class.isInstance( expression ) || context.getCurrentAccessor() == Class.class || (

             context.get( ExpressionCompiler.PRE_CAST ) != null && ( (String) context.get(

                 ExpressionCompiler.PRE_CAST ) ).startsWith( "new" ) ) || ASTStaticField.class.isInstance( expression )

             || ASTStaticMethod.class.isInstance( expression ) || ( OrderedReturn.class.isInstance( expression )

             && ( (OrderedReturn) expression ).getLastExpression() != null ) )

         {

             return body;

         }

         /*

          * System.out.println("castExpression() with expression " + expression + " expr class: " + expression.getClass()

          * + " currentType is: " + context.getCurrentType() + " previousType: " + context.getPreviousType() +

          * "\n current Accessor: " + context.getCurrentAccessor() + " previous Accessor: " +

          * context.getPreviousAccessor() + " current object " + context.getCurrentObject());

          */

         ExpressionCompiler.addCastString( context,

                                           "((" + ExpressionCompiler.getCastString( context.getCurrentAccessor() )

                                               + ")" );

         return ")" + body;

     }

     /**

      * {@inheritDoc}

      */

     public String getClassName( Class<?> clazz )

     {

         if ( "java.util.AbstractList$Itr".equals( clazz.getName() ) )

         {

             return Iterator.class.getName();

         }

         if ( Modifier.isPublic( clazz.getModifiers() ) && clazz.isInterface() )

         {

             return clazz.getName();

         }

         Class<?>[] interfaces = clazz.getInterfaces();

         for ( Class<?> intface : interfaces )

         {

             if ( intface.getName().indexOf( "util.List" ) > 0 )

             {

                 return intface.getName();

             }

             else if ( intface.getName().indexOf( "Iterator" ) > 0 )

             {

                 return intface.getName();

             }

         }

         if ( clazz.getSuperclass() != null && clazz.getSuperclass().getInterfaces().length > 0 )

         {

             return getClassName( clazz.getSuperclass() );

         }

         return clazz.getName();

     }

     /**

      * {@inheritDoc}

      */

     public Class<?> getSuperOrInterfaceClass( Method m, Class<?> clazz )

     {

         if ( clazz.getInterfaces() != null && clazz.getInterfaces().length > 0 )

         {

             Class<?>[] intfs = clazz.getInterfaces();

             Class<?> intClass;

             for ( Class<?> intf : intfs )

             {

                 intClass = getSuperOrInterfaceClass( m, intf );

                 if ( intClass != null )

                 {

                     return intClass;

                 }

                 if ( Modifier.isPublic( intf.getModifiers() ) && containsMethod( m, intf ) )

                 {

                     return intf;

                 }

             }

         }

         if ( clazz.getSuperclass() != null )

         {

             Class<?> superClass = getSuperOrInterfaceClass( m, clazz.getSuperclass() );

             if ( superClass != null )

             {

                 return superClass;

             }

         }

         if ( Modifier.isPublic( clazz.getModifiers() ) && containsMethod( m, clazz ) )

         {

             return clazz;

         }

         return null;

     }

     /**

      * Helper utility method used by compiler to help resolve class->method mappings during method calls to

      * {@link OgnlExpressionCompiler#getSuperOrInterfaceClass(java.lang.reflect.Method, Class)}.

      * 

      * @param m The method to check for existance of.

      * @param clazz The class to check for the existance of a matching method definition to the method passed in.

      * @return True if the class contains the specified method, false otherwise.

      */

     public boolean containsMethod( Method m, Class<?> clazz )

     {

         Method[] methods = clazz.getMethods();

         if ( methods == null )

         {

             return false;

         }

         for ( Method method : methods )

         {

             if ( method.getName().equals( m.getName() ) && method.getReturnType() == m.getReturnType() )

             {

                 Class<?>[] parms = m.getParameterTypes();

                 if ( parms == null )

                 {

                     continue;

                 }

                 Class<?>[] mparms = method.getParameterTypes();

                 if ( mparms == null || mparms.length != parms.length )

                 {

                     continue;

                 }

                 boolean parmsMatch = true;

                 for ( int p = 0; p < parms.length; p++ )

                 {

                     if ( parms[p] != mparms[p] )

                     {

                         parmsMatch = false;

                         break;

                     }

                 }

                 if ( !parmsMatch )

                 {

                     continue;

                 }

                 Class<?>[] exceptions = m.getExceptionTypes();

                 if ( exceptions == null )

                 {

                     continue;

                 }

                 Class<?>[] mexceptions = method.getExceptionTypes();

                 if ( mexceptions == null || mexceptions.length != exceptions.length )

                 {

                     continue;

                 }

                 boolean exceptionsMatch = true;

                 for ( int e = 0; e < exceptions.length; e++ )

                 {

                     if ( exceptions[e] != mexceptions[e] )

                     {

                         exceptionsMatch = false;

                         break;

                     }

                 }

                 if ( !exceptionsMatch )

                 {

                     continue;

                 }

                 return true;

             }

         }

         return false;

     }

     /**

      * {@inheritDoc}

      */

     public Class<?> getInterfaceClass( Class<?> clazz )

     {

         if ( "java.util.AbstractList$Itr".equals( clazz.getName() ) )

         {

             return Iterator.class;

         }

         if ( Modifier.isPublic( clazz.getModifiers() ) && clazz.isInterface() || clazz.isPrimitive() )

         {

             return clazz;

         }

         Class<?>[] intf = clazz.getInterfaces();

         for ( Class<?> anIntf : intf )

         {

             if ( List.class.isAssignableFrom( anIntf ) )

             {

                 return List.class;

             }

             else if ( Iterator.class.isAssignableFrom( anIntf ) )

             {

                 return Iterator.class;

             }

             else if ( Map.class.isAssignableFrom( anIntf ) )

             {

                 return Map.class;

             }

             else if ( Set.class.isAssignableFrom( anIntf ) )

             {

                 return Set.class;

             }

             else if ( Collection.class.isAssignableFrom( anIntf ) )

             {

                 return Collection.class;

             }

         }

         if ( clazz.getSuperclass() != null && clazz.getSuperclass().getInterfaces().length > 0 )

         {

             return getInterfaceClass( clazz.getSuperclass() );

         }

         return clazz;

     }

     /**

      * {@inheritDoc}

      */

     public Class<?> getRootExpressionClass( Node rootNode, OgnlContext context )

     {

         if ( context.getRoot() == null )

         {

             return null;

         }

         Class<?> ret = context.getRoot().getClass();

         if ( context.getFirstAccessor() != null && context.getFirstAccessor().isInstance( context.getRoot() ) )

         {

             ret = context.getFirstAccessor();

         }

         return ret;

     }

     /**

      * {@inheritDoc}

      */

     public void compileExpression( OgnlContext context, Node expression, Object root )

         throws Exception

     {

         // System.out.println("Compiling expr class " + expression.getClass().getName() + " and root " + root);

         if ( expression.getAccessor() != null )

         {

             return;

         }

         String getBody, setBody;

         EnhancedClassLoader loader = getClassLoader( context );

         ClassPool classPool = getClassPool( context, loader );

         CtClass newClass = classPool.makeClass(

             expression.getClass().getName() + expression.hashCode() + classCounter++ + "Accessor" );

         newClass.addInterface( getCtClass( ExpressionAccessor.class ) );

         CtClass ognlClass = getCtClass( OgnlContext.class );

         CtClass objClass = getCtClass( Object.class );

         CtMethod valueGetter = new CtMethod( objClass, "get", new CtClass[] { ognlClass, objClass }, newClass );

         CtMethod valueSetter =

             new CtMethod( CtClass.voidType, "set", new CtClass[] { ognlClass, objClass, objClass }, newClass );

         CtField nodeMember = null; // will only be set if uncompilable exception is thrown

         CtClass nodeClass = getCtClass( Node.class );

         CtMethod setExpression = null;

         try

         {

             getBody = generateGetter( context, newClass, objClass, classPool, valueGetter, expression, root );

         }

         catch ( UnsupportedCompilationException uc )

         {

             // uc.printStackTrace();

             nodeMember = new CtField( nodeClass, "_node", newClass );

             newClass.addField( nodeMember );

             getBody = generateOgnlGetter( newClass, valueGetter, nodeMember );

             setExpression = CtNewMethod.setter( "setExpression", nodeMember );

             newClass.addMethod( setExpression );

         }

         try

         {

             setBody = generateSetter( context, newClass, objClass, classPool, valueSetter, expression, root );

         }

         catch ( UnsupportedCompilationException uc )

         {

             // uc.printStackTrace();

             if ( nodeMember == null )

             {

                 nodeMember = new CtField( nodeClass, "_node", newClass );

                 newClass.addField( nodeMember );

             }

             setBody = generateOgnlSetter( newClass, valueSetter, nodeMember );

             if ( setExpression == null )

             {

                 setExpression = CtNewMethod.setter( "setExpression", nodeMember );

                 newClass.addMethod( setExpression );

             }

         }

         try

         {

             newClass.addConstructor( CtNewConstructor.defaultConstructor( newClass ) );

             Class<?> clazz = classPool.toClass( newClass );

             newClass.detach();

             expression.setAccessor( (ExpressionAccessor) clazz.newInstance() );

             // need to set expression on node if the field was just defined.

             if ( nodeMember != null )

             {

                 expression.getAccessor().setExpression( expression );

             }

         }

         catch ( Throwable t )

         {

             // t.printStackTrace();

             throw new RuntimeException( "Error compiling expression on object " + root + " with expression node "

                 + expression + " getter body: " + getBody + " setter body: " + setBody, t );

         }

     }

     protected String generateGetter( OgnlContext context, CtClass newClass, CtClass objClass, ClassPool classPool,

                                      CtMethod valueGetter, Node expression, Object root )

         throws Exception

     {

         String pre = "";

         String post = "";

         String body;

         context.setRoot( root );

         // the ExpressionAccessor API has to reference the generic Object class for get/set operations, so this sets up

         // that known

         // type beforehand

         context.remove( PRE_CAST );

         // Recursively generate the java source code representation of the top level expression

         String getterCode = expression.toGetSourceString( context, root );

         if ( getterCode == null || getterCode.trim().length() <= 0

             && !ASTVarRef.class.isAssignableFrom( expression.getClass() ) )

         {

             getterCode = "null";

         }

         String castExpression = (String) context.get( PRE_CAST );

         if ( context.getCurrentType() == null || context.getCurrentType().isPrimitive()

             || Character.class.isAssignableFrom( context.getCurrentType() )

             || Object.class == context.getCurrentType() )

         {

             pre = pre + " ($w) (";

             post = post + ")";

         }

         String rootExpr = !"null".equals( getterCode ) ? getRootExpression( expression, root, context ) : "";

         String noRoot = (String) context.remove( "_noRoot" );

         if ( noRoot != null )

         {

             rootExpr = "";

         }

         createLocalReferences( context, classPool, newClass, objClass, valueGetter.getParameterTypes() );

         if ( OrderedReturn.class.isInstance( expression )

             && ( (OrderedReturn) expression ).getLastExpression() != null )

         {

             body = "{ " + ( ASTMethod.class.isInstance( expression ) || ASTChain.class.isInstance( expression )

                 ? rootExpr

                 : "" ) + ( castExpression != null ? castExpression : "" )

                 + ( (OrderedReturn) expression ).getCoreExpression() + " return " + pre

                 + ( (OrderedReturn) expression ).getLastExpression() + post + ";}";

         }

         else

         {

             body =

                 "{  return " + pre + ( castExpression != null ? castExpression : "" ) + rootExpr + getterCode + post

                     + ";}";

         }

         body = body.replaceAll( "\\.\\.", "." );

         // System.out.println("Getter Body: ===================================\n" + body);

         valueGetter.setBody( body );

         newClass.addMethod( valueGetter );

         return body;

     }

     /**

      * {@inheritDoc}

      */

     public String createLocalReference( OgnlContext context, String expression, Class<?> type )

     {

         String referenceName = "ref" + context.incrementLocalReferenceCounter();

         context.addLocalReference( referenceName, new LocalReferenceImpl( referenceName, expression, type ) );

         String castString = "";

         if ( !type.isPrimitive() )

         {

             castString = "(" + ExpressionCompiler.getCastString( type ) + ") ";

         }

         return castString + referenceName + "($$)";

     }

     void createLocalReferences( OgnlContext context, ClassPool classPool, CtClass clazz, CtClass unused,

                                 CtClass[] params )

         throws NotFoundException, CannotCompileException

     {

         Map<String, LocalReference> referenceMap = context.getLocalReferences();

         if ( referenceMap == null || referenceMap.isEmpty() )

         {

             return;

         }

         Iterator<LocalReference> it = referenceMap.values().iterator();

         while( it.hasNext() )

         {

             LocalReference ref = it.next();

             String widener = ref.getType().isPrimitive() ? " " : " ($w) ";

             String body = format( "{ return %s %s; }", widener, ref.getExpression() ).replaceAll( "\\.\\.", "." );

             // System.out.println("adding method " + ref.getName() + " with body:\n" + body + " and return type: " +

             // ref.getType());

             CtMethod method =

                 new CtMethod( classPool.get( getCastString( ref.getType() ) ), ref.getName(), params, clazz );

             method.setBody( body );

             clazz.addMethod( method );

             it.remove();

         }

     }

     protected String generateSetter( OgnlContext context, CtClass newClass, CtClass objClass, ClassPool classPool,

                                      CtMethod valueSetter, Node expression, Object root )

         throws Exception

     {

         if ( ExpressionNode.class.isInstance( expression ) || ASTConst.class.isInstance( expression ) )

         {

             throw new UnsupportedCompilationException( "Can't compile expression/constant setters." );

         }

         context.setRoot( root );

         context.remove( PRE_CAST );

         String body;

         String setterCode = expression.toSetSourceString( context, root );

         String castExpression = (String) context.get( PRE_CAST );

         if ( setterCode == null || setterCode.trim().length() < 1 )

         {

             throw new UnsupportedCompilationException( "Can't compile null setter body." );

         }

         if ( root == null )

         {

             throw new UnsupportedCompilationException( "Can't compile setters with a null root object." );

         }

         String pre = getRootExpression( expression, root, context );

         String noRoot = (String) context.remove( "_noRoot" );

         if ( noRoot != null )

         {

             pre = "";

         }

         createLocalReferences( context, classPool, newClass, objClass, valueSetter.getParameterTypes() );

         body = "{" + ( castExpression != null ? castExpression : "" ) + pre + setterCode + ";}";

         body = body.replaceAll( "\\.\\.", "." );

         // System.out.println("Setter Body: ===================================\n" + body);

         valueSetter.setBody( body );

         newClass.addMethod( valueSetter );

         return body;

     }

     /**

      * Fail safe getter creation when normal compilation fails.

      * 

      * @param clazz The javassist class the new method should be attached to.

      * @param valueGetter The method definition the generated code will be contained within.

      * @param node The root expression node.

      * @return The generated source string for this method, the method will still be added via the javassist API either

      *         way so this is really a convenience for exception reporting / debugging.

      * @throws Exception If a javassist error occurs.

      */

     protected String generateOgnlGetter( CtClass clazz, CtMethod valueGetter, CtField node )

         throws Exception

     {

         String body = "return " + node.getName() + ".getValue($1, $2);";

         valueGetter.setBody( body );

         clazz.addMethod( valueGetter );

         return body;

     }

     /**

      * Fail safe setter creation when normal compilation fails.

      * 

      * @param clazz The javassist class the new method should be attached to.

      * @param valueSetter The method definition the generated code will be contained within.

      * @param node The root expression node.

      * @return The generated source string for this method, the method will still be added via the javassist API either

      *         way so this is really a convenience for exception reporting / debugging.

      * @throws Exception If a javassist error occurs.

      */

     protected String generateOgnlSetter( CtClass clazz, CtMethod valueSetter, CtField node )

         throws Exception

     {

         String body = node.getName() + ".setValue($1, $2, $3);";

         valueSetter.setBody( body );

         clazz.addMethod( valueSetter );

         return body;

     }

     /**

      * Creates a {@link ClassLoader} instance compatible with the javassist classloader and normal OGNL class resolving

      * semantics.

      * 

      * @param context The current execution context.

      * @return The created {@link ClassLoader} instance.

      */

     protected EnhancedClassLoader getClassLoader( OgnlContext context )

     {

         EnhancedClassLoader ret = loaders.get( context.getClassResolver() );

         if ( ret != null )

         {

             return ret;

         }

         ClassLoader classLoader = new ContextClassLoader( OgnlContext.class.getClassLoader(), context );

         ret = new EnhancedClassLoader( classLoader );

         loaders.put( context.getClassResolver(), ret );

         return ret;

     }

     /**

      * Loads a new class definition via javassist for the specified class.

      * 

      * @param searchClass The class to load.

      * @return The javassist class equivalent.

      * @throws javassist.NotFoundException When the class definition can't be found.

      */

     protected CtClass getCtClass( Class<?> searchClass )

         throws NotFoundException

     {

         return pool.get( searchClass.getName() );

     }

     /**

      * Gets either a new or existing {@link ClassPool} for use in compiling javassist classes. A new class path object

      * is inserted in to the returned {@link ClassPool} using the passed in <code>loader</code> instance if a new pool

      * needs to be created.

      * 

      * @param context The current execution context.

      * @param loader The {@link ClassLoader} instance to use - as returned by

      *            {@link #getClassLoader(org.apache.commons.ognl.OgnlContext)}.

      * @return The existing or new {@link ClassPool} instance.

      */

     protected ClassPool getClassPool( OgnlContext context, EnhancedClassLoader loader )

     {

         if ( pool != null )

         {

             return pool;

         }

         pool = ClassPool.getDefault();

         pool.insertClassPath( new LoaderClassPath( loader.getParent() ) );

         return pool;

     }

 }