Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2003-2007 the original author or authors.
   *
   * 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 org.codehaus.groovy.runtime.callsite;
 
 
POGO call site meta class - cached method - cached
 
 public class PogoMetaMethodSite extends MetaMethodSite {
     public PogoMetaMethodSite(CallSite siteMetaClassImpl metaClassMetaMethod metaMethodClass params[]) {
         super(sitemetaClassmetaMethodparams);
     }
 
     public Object invoke(Object receiverObject[] argsthrows Throwable {
         MetaClassHelper.unwrap(args);
         try {
             return .doMethodInvoke(receiver,  args);
         } catch (GroovyRuntimeException gre) {
             throw ScriptBytecodeAdapter.unwrap(gre);
         }
     }
 
     public Object callCurrent(GroovyObject receiverObject[] argsthrows Throwable {
         if(checkCall(receiverargs)) {
             try {
                 return invoke(receiver,args);
             } catch (GroovyRuntimeException gre) {
                 throw ScriptBytecodeAdapter.unwrap(gre);
             }
         } else {
             return CallSiteArray.defaultCallCurrent(thisreceiverargs);
         }
     }
 
     public Object call(Object receiverObject[] argsthrows Throwable {
         if(checkCall(receiverargs)) {
             try {
                 return invoke(receiver,args);
             } catch (GroovyRuntimeException gre) {
                 throw ScriptBytecodeAdapter.unwrap(gre);
             }
         } else {
             return CallSiteArray.defaultCall(thisreceiverargs);
         }
     }
 
     protected boolean checkCall(Object receiverObject[] args) {
         try {
             return .get() == 0
                && ((GroovyObject)receiver).getMetaClass() ==  // metaClass still be valid
                && MetaClassHelper.sameClasses(args);
         }
         catch (NullPointerException e) {
             if (receiver == null)
               return false;
             throw e;
         }
         catch (ClassCastException e) {
             if (!(receiver instanceof GroovyObject))
               return false;
             throw e;
         }
     }
 
     protected boolean checkCall(Object receiver) {
         try {
             return .get() == 0
                && ((GroovyObject)receiver).getMetaClass() ==  // metaClass still be valid
                && MetaClassHelper.sameClasses();
         }
         catch (NullPointerException e) {
             if (receiver == null)
               return false;
             throw e;
        }
        catch (ClassCastException e) {
            if (!(receiver instanceof GroovyObject))
              return false;
            throw e;
        }
    }
    protected boolean checkCall(Object receiverObject arg1) {
        try {
            return .get() == 0
               && ((GroovyObject)receiver).getMetaClass() ==  // metaClass still be valid
               && MetaClassHelper.sameClasses(arg1);
        }
        catch (NullPointerException e) {
            if (receiver == null)
              return false;
            throw e;
        }
        catch (ClassCastException e) {
            if (!(receiver instanceof GroovyObject))
              return false;
            throw e;
        }
    }
    protected boolean checkCall(Object receiverObject arg1Object arg2) {
        try {
            return .get() == 0
               && ((GroovyObject)receiver).getMetaClass() ==  // metaClass still be valid
               && MetaClassHelper.sameClasses(arg1arg2);
        }
        catch (NullPointerException e) {
            if (receiver == null)
              return false;
            throw e;
        }
        catch (ClassCastException e) {
            if (!(receiver instanceof GroovyObject))
              return false;
            throw e;
        }
    }
    protected boolean checkCall(Object receiverObject arg1Object arg2Object arg3) {
        try {
            return .get() == 0
               && ((GroovyObject)receiver).getMetaClass() ==  // metaClass still be valid
               && MetaClassHelper.sameClasses(arg1arg2arg3);
        }
        catch (NullPointerException e) {
            if (receiver == null)
              return false;
            throw e;
        }
        catch (ClassCastException e) {
            if (!(receiver instanceof GroovyObject))
              return false;
            throw e;
        }
    }
    protected boolean checkCall(Object receiverObject arg1Object arg2Object arg3Object arg4) {
        try {
            return .get() == 0
               && ((GroovyObject)receiver).getMetaClass() ==  // metaClass still be valid
               && MetaClassHelper.sameClasses(arg1arg2arg3arg4);
        }
        catch (NullPointerException e) {
            if (receiver == null)
              return false;
            throw e;
        }
        catch (ClassCastException e) {
            if (!(receiver instanceof GroovyObject))
              return false;
            throw e;
        }
    }
    public static CallSite createPogoMetaMethodSite(CallSite siteMetaClassImpl metaClassMetaMethod metaMethodClass[] paramsObject[] args) {
        if (metaMethod.getClass() == CachedMethod.class)
          return createCachedMethodSite (sitemetaClass, (CachedMethodmetaMethodparamsargs);
        return createNonAwareCallSite(sitemetaClassmetaMethodparamsargs);
    }
    private static CallSite createNonAwareCallSite(CallSite siteMetaClassImpl metaClassMetaMethod metaMethodClass[] paramsObject[] args) {
        if (metaMethod.correctArguments(args) == args) {
            if (noWrappers(args)) {
                if (noCoerce(metaMethod,args))
                    return new PogoMetaMethodSiteNoUnwrap(sitemetaClassmetaMethodparams);
                else {
                    return new PogoMetaMethodSiteNoUnwrapNoCoerce(sitemetaClassmetaMethodparams);
                }
            }
        }
        return new PogoMetaMethodSite(sitemetaClassmetaMethodparams);
    }
    public static CallSite createCachedMethodSite(CallSite siteMetaClassImpl metaClassCachedMethod metaMethodClass[] paramsObject[] args) {
        if (metaMethod.correctArguments(args) == args) {
            if (noWrappers(args)) {
                if (noCoerce(metaMethod,args))
                    return new PogoCachedMethodSiteNoUnwrap(sitemetaClassmetaMethodparams);
                else {
                    return metaMethod.createPogoMetaMethodSite(sitemetaClassparams);
                }
            }
        }
        return new PogoCachedMethodSite(sitemetaClassmetaMethodparams);
    }
    public static class PogoCachedMethodSite extends PogoMetaMethodSite {
        final Method reflect;
        public PogoCachedMethodSite(CallSite siteMetaClassImpl metaClassCachedMethod metaMethodClass[] params) {
            super(sitemetaClassmetaMethodparams);
             = metaMethod.setAccessible();
        }
        public Object invoke(Object receiverObject[] argsthrows Throwable {
            MetaClassHelper.unwrap(args);
            args = .coerceArgumentsToClasses(args);
            try {
                return .invoke(receiverargs);
            } catch (InvocationTargetException e) {
                Throwable cause = e.getCause();
                if (cause instanceof GroovyRuntimeException) {
                    throw ScriptBytecodeAdapter.unwrap ((GroovyRuntimeExceptioncause);
                } else {
                    throw cause;
                }
            }
        }
    }
    public static class PogoCachedMethodSiteNoUnwrap extends PogoCachedMethodSite {
        public PogoCachedMethodSiteNoUnwrap(CallSite siteMetaClassImpl metaClassCachedMethod metaMethodClass params[]) {
            super(sitemetaClassmetaMethodparams);
        }
        public final Object invoke(Object receiverObject[] argsthrows Throwable {
            args = .coerceArgumentsToClasses(args);
            try {
                return .invoke(receiverargs);
            } catch (InvocationTargetException e) {
                Throwable cause = e.getCause();
                if (cause instanceof GroovyRuntimeException) {
                    throw ScriptBytecodeAdapter.unwrap ((GroovyRuntimeExceptioncause);
                } else {
                    throw cause;
                }
            }
        }
    }
    public static class PogoCachedMethodSiteNoUnwrapNoCoerce extends PogoCachedMethodSite {
        public PogoCachedMethodSiteNoUnwrapNoCoerce(CallSite siteMetaClassImpl metaClassCachedMethod metaMethodClass params[]) {
            super(sitemetaClassmetaMethodparams);
        }
        public final Object invoke(Object receiverObject[] argsthrows Throwable {
            try {
                return .invoke(receiverargs);
            } catch (InvocationTargetException e) {
                Throwable cause = e.getCause();
                if (cause instanceof GroovyRuntimeException) {
                    throw ScriptBytecodeAdapter.unwrap ((GroovyRuntimeExceptioncause);
                } else {
                    throw cause;
                }
            }
        }
    }

    
Call site where we know there is no need to unwrap arguments
    public static class PogoMetaMethodSiteNoUnwrap extends PogoMetaMethodSite {
        public PogoMetaMethodSiteNoUnwrap(CallSite siteMetaClassImpl metaClassMetaMethod metaMethodClass params[]) {
            super(sitemetaClassmetaMethodparams);
        }
        public final Object invoke(Object receiverObject[] argsthrows Throwable {
            try {
                return .doMethodInvoke(receiver,  args);
            } catch (GroovyRuntimeException gre) {
                throw ScriptBytecodeAdapter.unwrap(gre);
            }
        }
    }

    
Call site where we know there is no need neither unwrap nor coerce arguments
    public static class PogoMetaMethodSiteNoUnwrapNoCoerce extends PogoMetaMethodSite {
        public PogoMetaMethodSiteNoUnwrapNoCoerce(CallSite siteMetaClassImpl metaClassMetaMethod metaMethodClass params[]) {
            super(sitemetaClassmetaMethodparams);
        }
        public final Object invoke(Object receiverObject[] argsthrows Throwable {
            try {
                return .invoke(receiver,  args);
            } catch (GroovyRuntimeException gre) {
                throw ScriptBytecodeAdapter.unwrap(gre);
            }
        }
    }
New to GrepCode? Check out our FAQ X