import org.codehaus.groovy.runtime.GroovyCategorySupport; //导入依赖的package包/类
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 = ((MetaClassImpl) metaClass).getEffectiveGetMetaProperty(receiver.getClass(), receiver, name, false);
        if (effective != null) {
            if (effective instanceof CachedField)
                site = new GetEffectivePojoFieldSite(this, (MetaClassImpl) metaClass, (CachedField) effective);
            else
                site = new GetEffectivePojoPropertySite(this, (MetaClassImpl) metaClass, effective);
        } else {
            site = new PojoMetaClassGetPropertySite(this);
        }
    }

    array.array[index] = site;
    return site;
}
 

import org.codehaus.groovy.runtime.GroovyCategorySupport; //导入依赖的package包/类
private CallSite createPogoMetaClassGetPropertySite(GroovyObject receiver) {
    MetaClass metaClass = receiver.getMetaClass();

    CallSite site;
    if (metaClass.getClass() != MetaClassImpl.class || GroovyCategorySupport.hasCategoryInCurrentThread()) {
        site = new PogoMetaClassGetPropertySite(this, metaClass);
    } else {
        final MetaProperty effective = ((MetaClassImpl) metaClass).getEffectiveGetMetaProperty(this.array.owner, receiver, name, false);
        if (effective != null) {
            if (effective instanceof CachedField)
                site = new GetEffectivePogoFieldSite(this, metaClass, (CachedField) effective);
            else
                site = new GetEffectivePogoPropertySite(this, metaClass, effective);
        } else {
            site = new PogoMetaClassGetPropertySite(this, metaClass);
        }
    }

    array.array[index] = site;
    return site;
}
 

import org.codehaus.groovy.runtime.GroovyCategorySupport; //导入依赖的package包/类
private MetaMethod getMethodWithCachingInternal (Class sender, CallSite site, Class [] params) {
    if (GroovyCategorySupport.hasCategoryInCurrentThread())
        return getMethodWithoutCaching(sender, site.getName (), params, false);

    final MetaMethodIndex.Entry e = metaMethodIndex.getMethods(sender, site.getName());
    if (e == null) {
        return null;
    }

    MetaMethodIndex.CacheEntry cacheEntry;
    final Object methods = e.methods;
    if (methods == null)
      return null;

    cacheEntry = e.cachedMethod;
    if (cacheEntry != null && (sameClasses(cacheEntry.params, params))) {
         return cacheEntry.method;
    }

    cacheEntry = new MetaMethodIndex.CacheEntry (params, (MetaMethod) chooseMethod(e.name, methods, params));
    e.cachedMethod = cacheEntry;
    return cacheEntry.method;
}
 

import org.codehaus.groovy.runtime.GroovyCategorySupport; //导入依赖的package包/类
private Tuple2<MetaMethod, MetaProperty> createMetaMethodAndMetaProperty(final Class senderForMP, final Class senderForCMG, final String name, final boolean useSuper, final boolean isStatic) {
    MetaMethod method = null;
    MetaProperty mp = getMetaProperty(senderForMP, name, useSuper, isStatic);
    if (mp != null) {
        if (mp instanceof MetaBeanProperty) {
            MetaBeanProperty mbp = (MetaBeanProperty) mp;
            method = mbp.getGetter();
            mp = mbp.getField();
        }
    }

    // check for a category method named like a getter
    if (!useSuper && !isStatic && GroovyCategorySupport.hasCategoryInCurrentThread()) {
        String getterName = GroovyCategorySupport.getPropertyCategoryGetterName(name);
        if (getterName != null) {
            MetaMethod categoryMethod = getCategoryMethodGetter(senderForCMG, getterName, false);
            if (categoryMethod != null)
                method = categoryMethod;
        }
    }

    return new Tuple2<MetaMethod, MetaProperty>(method, mp);
}
 

import org.codehaus.groovy.runtime.GroovyCategorySupport; //导入依赖的package包/类
private static MetaMethod getCategoryMethodGetter(Class sender, String name, boolean useLongVersion) {
    List possibleGenericMethods = GroovyCategorySupport.getCategoryMethods(name);
    if (possibleGenericMethods != null) {
        for (Iterator iter = possibleGenericMethods.iterator(); iter.hasNext();) {
            MetaMethod mmethod = (MetaMethod) iter.next();
            if (!mmethod.getDeclaringClass().getTheClass().isAssignableFrom(sender))
              continue;

            CachedClass[] paramTypes = mmethod.getParameterTypes();
            if (useLongVersion) {
                if (paramTypes.length == 1 && paramTypes[0].getTheClass() == String.class) {
                    return mmethod;
                }
            } else {
                if (paramTypes.length == 0) return mmethod;
            }
        }
    }
    return null;
}
 

import org.codehaus.groovy.runtime.GroovyCategorySupport; //导入依赖的package包/类
private static MetaMethod getCategoryMethodSetter(Class sender, String name, boolean useLongVersion) {
    List possibleGenericMethods = GroovyCategorySupport.getCategoryMethods(name);
    if (possibleGenericMethods != null) {
        for (Iterator iter = possibleGenericMethods.iterator(); iter.hasNext();) {
            MetaMethod mmethod = (MetaMethod) iter.next();
            if (!mmethod.getDeclaringClass().getTheClass().isAssignableFrom(sender))
              continue;

            CachedClass[] paramTypes = mmethod.getParameterTypes();
            if (useLongVersion) {
                if (paramTypes.length == 2 && paramTypes[0].getTheClass() == String.class) {
                    return mmethod;
                }
            } else {
                if (paramTypes.length == 1) return mmethod;
            }
        }
    }
    return null;
}
 

import org.codehaus.groovy.runtime.GroovyCategorySupport; //导入依赖的package包/类
/**
 * Create a CallSite
 */
public CallSite createPogoCallSite(CallSite site, Object[] args) {
    if (!GroovyCategorySupport.hasCategoryInCurrentThread() && !(this instanceof AdaptingMetaClass)) {
        Class [] params = MetaClassHelper.convertToTypeArray(args);
        CallSite tempSite = site;
        if (site.getName().equals("call") && GeneratedClosure.class.isAssignableFrom(theClass)) {
            // here, we want to point to a method named "doCall" instead of "call"
            // but we don't want to replace the original call site name, otherwise
            // we loose the fact that the original method name was "call" so instead
            // we will point to a metamethod called "doCall"
            // see GROOVY-5806 for details
            tempSite = new AbstractCallSite(site.getArray(),site.getIndex(),"doCall");
        }
        MetaMethod metaMethod = getMethodWithCachingInternal(theClass, tempSite, params);
        if (metaMethod != null)
           return PogoMetaMethodSite.createPogoMetaMethodSite(site, this, metaMethod, params, args);
    }
    return new PogoMetaClassSite(site, this);
}
 

import org.codehaus.groovy.runtime.GroovyCategorySupport; //导入依赖的package包/类
public static List<Row> asListOfRows(Parameters existsParameters, Closure<?> tableData) {
  context.set(new ArrayList<Row>());
  tableData.setDelegate(new ShareDataAwardDelegate(existsParameters));
  tableData.setResolveStrategy(Closure.DELEGATE_FIRST);

  GroovyCategorySupport.use(TableParser.class, tableData);
  List<Row> rows = context.get();
  
  if (rows.size() <= 1)
    throw new DslException("table requires at least 2 rows, first row for column names, the rest for the data.");
  
  if (rows.size() > 0){
    for (int i = 0; i < rows.size(); i++){
      rows.get(i).setRowHeader(rows.get(0));
    }
  }
  rows.remove(0);
  
  return rows;
}
 

import org.codehaus.groovy.runtime.GroovyCategorySupport; //导入依赖的package包/类
/** for testing only */
public Outcome run(final int max) {
    return GroovyCategorySupport.use(Continuable.categories, new Closure<Outcome>(null) {
        @Override
        public Outcome call() {
            int remaining = max;
            List<String> functions = new ArrayList<String>();
            Next n = Next.this;
            while(n.yield==null) {
                functions.add(n.f.getClass().getCanonicalName());
                if (--remaining == 0) {
                    int len = functions.size();
                    throw new AssertionError("Did not terminate; ran " + len + " steps ending with: " + functions.subList(len - 20, len));
                }
                n = n.step();
            }
            return n.yield;
        }
    });
}
 

import org.codehaus.groovy.runtime.GroovyCategorySupport; //导入依赖的package包/类
/**
 * Resumes this program by either returning the value from {@link Continuable#suspend(Object)} or
 * throwing an exception
 */
public Outcome run0(final Outcome cn, List<Class> categories) {
    return GroovyCategorySupport.use(categories, new Closure<Outcome>(null) {
        @Override
        public Outcome call() {
            Next n = cn.resumeFrom(e,k);

            while(n.yield==null) {
                if (interrupt!=null) {
                    // TODO: correctly reporting a source location requires every block to have the line number
                    n = new Next(new ThrowBlock(UNKNOWN, new ConstantBlock(interrupt), true),n.e,n.k);
                    interrupt = null;
                }
                n = n.step();
            }

            e = n.e;
            k = n.k;

            return n.yield;
        }
    });
}
 

import org.codehaus.groovy.runtime.GroovyCategorySupport; //导入依赖的package包/类
public final CallSite acceptGetProperty(Object receiver) {
//        if (GroovyCategorySupport.hasCategoryInCurrentThread() || !(receiver instanceof GroovyObject) || ((GroovyObject)receiver).getMetaClass() != metaClass) {
        if (GroovyCategorySupport.hasCategoryInCurrentThread() || receiver==null || receiver.getClass() != metaClass.getTheClass()
            || version != metaClass.getVersion()) { // metaClass is invalid
            return createGetPropertySite(receiver);
        } else {
            return this;
        }
    }
 

import org.codehaus.groovy.runtime.GroovyCategorySupport; //导入依赖的package包/类
public final Object callGetProperty (Object receiver) throws Throwable {
    if (GroovyCategorySupport.hasCategoryInCurrentThread() || !(receiver instanceof GroovyObject) || ((GroovyObject) receiver).getMetaClass() != metaClass) {
        return createGetPropertySite(receiver).getProperty(receiver);
    } else {
        return getProperty(receiver);
    }
}
 

import org.codehaus.groovy.runtime.GroovyCategorySupport; //导入依赖的package包/类
public final CallSite acceptGetProperty(Object receiver) {
    if (GroovyCategorySupport.hasCategoryInCurrentThread() || !(receiver instanceof GroovyObject) || ((GroovyObject)receiver).getMetaClass() != metaClass) {
        return createGetPropertySite(receiver);
    } else {
        return this;
    }
}
 

import org.codehaus.groovy.runtime.GroovyCategorySupport; //导入依赖的package包/类
public final Object callGroovyObjectGetProperty (Object receiver) throws Throwable {
    if (GroovyCategorySupport.hasCategoryInCurrentThread() || ((GroovyObject) receiver).getMetaClass() != metaClass) {
        return createGroovyObjectGetPropertySite(receiver).getProperty(receiver);
    } else {
        return getProperty(receiver);
    }
}
 

import org.codehaus.groovy.runtime.GroovyCategorySupport; //导入依赖的package包/类
public final CallSite acceptGroovyObjectGetProperty(Object receiver) {
    if (GroovyCategorySupport.hasCategoryInCurrentThread() || !(receiver instanceof GroovyObject) || ((GroovyObject)receiver).getMetaClass() != metaClass) {
        return createGroovyObjectGetPropertySite(receiver);
    } else {
        return this;
    }
}
 

import org.codehaus.groovy.runtime.GroovyCategorySupport; //导入依赖的package包/类
public final Object callGetProperty (Object receiver) throws Throwable {
    if (GroovyCategorySupport.hasCategoryInCurrentThread() || !(receiver instanceof GroovyObject) || ((GroovyObject) receiver).getMetaClass() != metaClass) {
        return createGetPropertySite(receiver).getProperty(receiver);
    } else {
        try {
            return effective.getProperty(receiver);
        } catch (GroovyRuntimeException gre) {
            throw ScriptBytecodeAdapter.unwrap(gre);
        }
    }
}
 

import org.codehaus.groovy.runtime.GroovyCategorySupport; //导入依赖的package包/类
public final Object callGroovyObjectGetProperty (Object receiver) throws Throwable {
    if (GroovyCategorySupport.hasCategoryInCurrentThread() || !(receiver instanceof GroovyObject) || ((GroovyObject) receiver).getMetaClass() != metaClass) {
        return createGetPropertySite(receiver).getProperty(receiver);
    } else {
        try {
            return effective.getProperty(receiver);
        } catch (GroovyRuntimeException gre) {
            throw ScriptBytecodeAdapter.unwrap(gre);
        }
    }
}
 

import org.codehaus.groovy.runtime.GroovyCategorySupport; //导入依赖的package包/类
public final CallSite acceptGetProperty(Object receiver) {
    if (GroovyCategorySupport.hasCategoryInCurrentThread() || receiver.getClass() != metaClass.getTheClass()
        || version != metaClass.getVersion()) { // metaClass is invalid
        return createGetPropertySite(receiver);
    } else {
        return this;
    }
}
 

import org.codehaus.groovy.runtime.GroovyCategorySupport; //导入依赖的package包/类
public MetaMethod getMethodWithCaching(Class sender, String methodName, Object[] arguments, boolean isCallToSuper) {
    // let's try use the cache to find the method
    if (!isCallToSuper && GroovyCategorySupport.hasCategoryInCurrentThread()) {
        return getMethodWithoutCaching(sender, methodName, MetaClassHelper.convertToTypeArray(arguments), isCallToSuper);
    } else {
        final MetaMethodIndex.Entry e = metaMethodIndex.getMethods(sender, methodName);
        if (e == null)
          return null;

        return isCallToSuper ? getSuperMethodWithCaching(arguments, e) : getNormalMethodWithCaching(arguments, e);
    }
}
 

import org.codehaus.groovy.runtime.GroovyCategorySupport; //导入依赖的package包/类
/**
 * Create a CallSite
 */
public CallSite createPogoCallCurrentSite(CallSite site, Class sender, Object[] args) {
    if (!GroovyCategorySupport.hasCategoryInCurrentThread() && !(this instanceof AdaptingMetaClass)) {
      Class [] params = MetaClassHelper.convertToTypeArray(args);
      MetaMethod metaMethod = getMethodWithCachingInternal(sender, site, params);
      if (metaMethod != null)
        return PogoMetaMethodSite.createPogoMetaMethodSite(site, this, metaMethod, params, args);
    }
    return new PogoMetaClassSite(site, this);
}