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;
 
 import groovy.lang.*;
 
 
Base class for all call sites

Author(s):
Alex Tkachman
 
 public class AbstractCallSite implements CallSite {
     protected final int index;
     protected final String name;
     protected final CallSiteArray array;
     protected final AtomicInteger usage;
 
     public AbstractCallSite(CallSiteArray arrayint indexString name) {
         this. = name;
         this. = index;
         this. = array;
         this. = GroovyCategorySupport.getCategoryNameUsage(name);
     }
 
     public AbstractCallSite(CallSite prev) {
         this. = prev.getName();
         this. = prev.getIndex();
         this. = prev.getArray();
         this. = prev.getUsage();
     }
 
     public int getIndex() {
         return ;
     }
 
     public CallSiteArray getArray() {
         return ;
     }
 
     public String getName() {
         return ;
     }
 
     public AtomicInteger getUsage() {
         return ;
     }
 
     public final Object callSafe(Object receiverObject[] argsthrows Throwable {
         if (receiver == null)
             return null;
 
         return call (receiverargs);
     }
 
     public final Object callSafe (Object receiverthrows Throwable {
         if (receiver == null)
             return null;
 
         return call(receiver);
     }
 
     public final Object callSafe (Object receiverObject arg1throws Throwable {
         if (receiver == null)
             return null;
 
         return call(receiverarg1);
     }
 
     public final Object callSafe (Object receiverObject arg1Object arg2throws Throwable {
         if (receiver == null)
             return null;
 
         return call(receiverarg1arg2);
     }
 
    public final Object callSafe (Object receiverObject arg1Object arg2Object arg3throws Throwable {
        if (receiver == null)
            return null;
        return call(receiverarg1arg2arg3);
    }
    public Object callSafe (Object receiverObject arg1Object arg2Object arg3Object arg4throws Throwable {
        if (receiver == null)
            return null;
        return call(receiverarg1arg2arg3arg4);
    }
    public Object call(Object receiverObject[] argsthrows Throwable {
        return CallSiteArray.defaultCall(thisreceiverargs);
    }
    public Object call (Object receiverthrows Throwable {
        return call(receiver.);
    }
    public Object call (Object receiverObject arg1throws Throwable {
        return call(receiver, ArrayUtil.createArray(arg1));
    }
    public Object call (Object receiverObject arg1Object arg2throws Throwable {
        return call(receiver, ArrayUtil.createArray(arg1arg2));
    }
    public Object call (Object receiverObject arg1Object arg2Object arg3throws Throwable {
        return call(receiver, ArrayUtil.createArray(arg1arg2arg3));
    }
    public Object call (Object receiverObject arg1Object arg2Object arg3Object arg4throws Throwable {
        return call(receiver, ArrayUtil.createArray(arg1arg2arg3arg4));
    }
    public Object callCurrent (GroovyObject receiverObject [] argsthrows Throwable {
        return CallSiteArray.defaultCallCurrent(thisreceiverargs);
    }
    public Object callCurrent (GroovyObject receiverthrows Throwable {
        return callCurrent(receiver.);
    }
    public Object callCurrent (GroovyObject receiverObject arg1throws Throwable {
        return callCurrent(receiver, ArrayUtil.createArray(arg1));
    }
    public Object callCurrent (GroovyObject receiverObject arg1Object arg2throws Throwable {
        return callCurrent(receiver, ArrayUtil.createArray(arg1arg2));
    }
    public Object callCurrent (GroovyObject receiverObject arg1Object arg2Object arg3throws Throwable {
        return callCurrent(receiver, ArrayUtil.createArray(arg1arg2arg3));
    }
    public Object callCurrent (GroovyObject receiverObject arg1Object arg2Object arg3Object arg4throws Throwable {
        return callCurrent(receiver, ArrayUtil.createArray(arg1arg2arg3arg4));
    }
    public Object callStatic (Class receiverObject [] argsthrows Throwable {
        return CallSiteArray.defaultCallStatic(thisreceiverargs);
    }
    public Object callStatic (Class receiverthrows Throwable {
        return callStatic(receiver.);
    }
    public Object callStatic (Class receiverObject arg1throws Throwable {
        return callStatic(receiver, ArrayUtil.createArray(arg1));
    }
    public Object callStatic (Class receiverObject arg1Object arg2throws Throwable {
        return callStatic(receiver, ArrayUtil.createArray(arg1arg2));
    }
    public Object callStatic (Class receiverObject arg1Object arg2Object arg3throws Throwable {
        return callStatic(receiver, ArrayUtil.createArray(arg1arg2arg3));
    }
    public Object callStatic (Class receiverObject arg1Object arg2Object arg3Object arg4throws Throwable {
        return callStatic(receiver, ArrayUtil.createArray(arg1arg2arg3arg4));
    }
    public Object callConstructor (Object receiverObject [] argsthrows Throwable {
        return CallSiteArray.defaultCallConstructor(thisreceiverargs);
    }
    public Object callConstructor (Object receiverthrows Throwable {
        return callConstructor(receiver.);
    }
    public Object callConstructor (Object receiverObject arg1throws Throwable {
        return callConstructor(receiver, ArrayUtil.createArray(arg1));
    }
    public Object callConstructor (Object receiverObject arg1Object arg2throws Throwable {
        return callConstructor(receiver, ArrayUtil.createArray(arg1arg2));
    }
    public Object callConstructor (Object receiverObject arg1Object arg2Object arg3throws Throwable {
        return callConstructor(receiver, ArrayUtil.createArray(arg1arg2arg3));
    }
    public Object callConstructor (Object receiverObject arg1Object arg2Object arg3Object arg4throws Throwable {
        return callConstructor(receiver, ArrayUtil.createArray(arg1arg2arg3arg4));
    }
    static boolean noCoerce(ParameterTypes metaMethodObject[] args) {
        final CachedClass[] paramClasses = metaMethod.getParameterTypes();
        if (paramClasses.length != args.length)
          return false;
        for (int i = 0; i < paramClasses.lengthi++) {
            CachedClass paramClass = paramClasses[i];
            if (args[i] != null && !paramClass.isDirectlyAssignable(args[i]))
              return true;
        }
        return false;
    }
    static boolean noWrappers(Object[] args) {
        for (int i = 0; i != args.length; ++i)
          if (args [iinstanceof Wrapper)
            return false;
        return true;
    }
    public Object callGetProperty (Object receiverthrows Throwable {
        return acceptGetProperty(receiver).getProperty(receiver);
    }
    public Object callGroovyObjectGetProperty (Object receiverthrows Throwable {
        return acceptGroovyObjectGetProperty(receiver).getProperty(receiver);
    }
    public CallSite acceptGetProperty(Object receiver) {
        return createGetPropertySite(receiver);
    }
    public CallSite acceptGroovyObjectGetProperty(Object receiver) {
        return createGroovyObjectGetPropertySite(receiver);
    }
    protected final CallSite createGetPropertySite(Object receiver) {
        if (receiver==null) {
            return new NullCallSite(this);
        } else if (receiver instanceof GroovyObject) {
            return createGroovyObjectGetPropertySite(receiver);
        } else if (receiver instanceof Class) {
            return createClassMetaClassGetPropertySite ((Classreceiver);
        }
        return createPojoMetaClassGetPropertySite(receiver);
    }
    protected final CallSite createGroovyObjectGetPropertySite(Object receiver) {
        Class aClass = receiver.getClass();
        try {
            final Method method = aClass.getMethod("getProperty"String.class);
            if (method != null && method.isSynthetic() && ((GroovyObject)receiver).getMetaClass() instanceof MetaClassImpl)
              return createPogoMetaClassGetPropertySite ((GroovyObject)receiver);
        } catch (NoSuchMethodException e) {
            // fall threw
        }
        return createPogoGetPropertySite (aClass);
    }
    public Object getProperty(Object receiverthrows Throwable {
        throw new UnsupportedOperationException();
    }
    private CallSite createPojoMetaClassGetPropertySite(Object receiver) {
        final MetaClass metaClass = InvokerHelper.getMetaClass(receiver);
        CallSite site;
        if (metaClass.getClass() != MetaClassImpl.class || GroovyCategorySupport.hasCategoryInCurrentThread()) {
            site = new PojoMetaClassGetPropertySite(this);
        }
        else {
            final MetaProperty effective = ((MetaClassImplmetaClass).getEffectiveGetMetaProperty(receiver.getClass(), receiverfalse);
            if (effective != null) {
                if (effective instanceof CachedField)
                    site = new GetEffectivePojoFieldSite(this, (MetaClassImplmetaClass, (CachedFieldeffective);
                else
                    site = new GetEffectivePojoPropertySite(this, (MetaClassImplmetaClasseffective);
            }
            else {
                site = new PojoMetaClassGetPropertySite(this);
            }
        }
        .[] = site;
        return site;
    }
        CallSite site = new ClassMetaClassGetPropertySite(thisaClass);
        .[] = site;
        return site;
    }
        MetaClass metaClass = receiver.getMetaClass();
        CallSite site;
        if (metaClass.getClass() != MetaClassImpl.class || GroovyCategorySupport.hasCategoryInCurrentThread()) {
            site = new PogoMetaClassGetPropertySite(thismetaClass);
        }
        else {
            final MetaProperty effective = ((MetaClassImplmetaClass).getEffectiveGetMetaProperty(metaClass.getClass(), receiverfalse);
            if (effective != null) {
                if (effective instanceof CachedField)
                    site = new GetEffectivePogoFieldSite(thismetaClass, (CachedFieldeffective);
                else
                    site = new GetEffectivePogoPropertySite(thismetaClasseffective);
            }
            else {
                site = new PogoMetaClassGetPropertySite(thismetaClass);
            }
        }
        .[] = site;
        return site;
    }
    private CallSite createPogoGetPropertySite(Class aClass) {
        CallSite site = new PogoGetPropertySite(thisaClass);
        .[] = site;
        return site;
    }
    public final Object callGetPropertySafe (Object receiverthrows Throwable {
        if (receiver == null)
          return null;
        else
          return callGetProperty(receiver);
    }
    public final Object callGroovyObjectGetPropertySafe (Object receiverthrows Throwable {
        if (receiver == null)
          return null;
        else
          return callGroovyObjectGetProperty(receiver);
    }
New to GrepCode? Check out our FAQ X