Java DefaultGroovyMethods类代码示例

import org.codehaus.groovy.runtime.DefaultGroovyMethods; //导入依赖的package包/类
public void createBuilderAfterEvaluate() throws Exception {

        AndroidBuilder androidBuilder = appPluginHook.getAndroidBuilder();

        if (null == androidBuilder) {
            return;
        }

        AndroidBuilder atlasBuilder = new AtlasBuilder(project.equals(project.getRootProject()) ? project
                .getName() : project.getPath(),
                                                       creator,
                                                       new GradleProcessExecutor(project),
                                                       new GradleJavaProcessExecutor(project),
                                                       DefaultGroovyMethods.asType(ReflectUtils.getField(
                                                               androidBuilder,
                                                               "mErrorReporter"),
                                                                                   ErrorReporter.class),
                                                       LoggerWrapper.getLogger(AtlasBuilder.class),
                                                       DefaultGroovyMethods.asType(ReflectUtils.getField(
                                                               androidBuilder,
                                                               "mVerboseExec"), Boolean.class));

        ((AtlasBuilder) atlasBuilder).setDefaultBuilder(androidBuilder);
        ((AtlasBuilder) atlasBuilder).setAtlasExtension(atlasExtension);
        AtlasBuildContext.androidBuilderMap.put(project, (AtlasBuilder) (atlasBuilder));
    }
 

import org.codehaus.groovy.runtime.DefaultGroovyMethods; //导入依赖的package包/类
public void configTasksAfterEvaluate() {

        if (PluginTypeUtils.isAppProject(project)) {
            AppExtension appExtension = DefaultGroovyMethods.asType(DefaultGroovyMethods.getAt(
                    project.getExtensions(),
                    "android"), AppExtension.class);
            new AtlasAppTaskManager(AtlasBuildContext.androidBuilderMap.get(project),
                                    appExtension,
                                    project,
                                    atlasExtension).run();
        } else if (PluginTypeUtils.isLibraryProject(project)) {
            LibraryExtension libExtension = DefaultGroovyMethods.asType(DefaultGroovyMethods.getAt(
                    project.getExtensions(),
                    "android"), LibraryExtension.class);
            new AtlasLibTaskManager(AtlasBuildContext.androidBuilderMap.get(project),
                                    libExtension,
                                    project,
                                    atlasExtension).run();
        }
    }
 

import org.codehaus.groovy.runtime.DefaultGroovyMethods; //导入依赖的package包/类
@Override
default Publisher<SnapshotT> getSnapshot(long maxPosition, AggregateT aggregate) {
    return toPublisher(defer(() -> {
        //noinspection unchecked
        List<SnapshotT> snapshots = (List<SnapshotT>) (maxPosition == Long.MAX_VALUE ?
                invokeStaticMethod(
                        getSnapshotClass(),
                        SNAPSHOTS_BY_AGGREGATE,
                        new Object[]{aggregate.getId(), LATEST_BY_POSITION}) :
                invokeStaticMethod(
                        getSnapshotClass(),
                        SNAPSHOTS_BY_POSITION,
                        new Object[]{aggregate.getId(), maxPosition, LATEST_BY_POSITION}));

        return DefaultGroovyMethods.asBoolean(snapshots) ?
                just(detachSnapshot(snapshots.get(0))) :
                empty();
    }));
}
 

import org.codehaus.groovy.runtime.DefaultGroovyMethods; //导入依赖的package包/类
@Test
public void testChangePassword() throws Exception {
  ArgumentCaptor<String> rawPasswordCaptor =
      (ArgumentCaptor<String>) ArgumentCaptor.forClass(String.class);

  when(passwordSecurity.ecrypt(rawPasswordCaptor.capture()))
      .thenReturn(new Password("test", "test"));

  User changedUser = userService.changePassword(user1.getId(), "somepassword");
  Assert.assertNotNull(changedUser);
  Assert.assertNotNull(changedUser.getPassword());

  DefaultGroovyMethods
      .invokeMethod(Mockito.verify(passwordSecurity), "ecrypt", new Object[]{"somepassword"});

  assertEmittedUserEvent(PASSWORD_CHANGED);
}
 

import org.codehaus.groovy.runtime.DefaultGroovyMethods; //导入依赖的package包/类
/**
 * Mix all the static methods of the given class into their
 * respective types.
 * @param classToMix a category class.
 */
protected void mixinGlobally(Class<?> classToMix) {
  // find the set of types into which it needs to be mixed.
  // this means the types of the first argument of each
  // static method in the class.
  Set<Class<?>> typesToMixInto = new HashSet<Class<?>>();
  for(Method method : classToMix.getMethods()) {
    if(Modifier.isStatic(method.getModifiers())
            && method.getDeclaringClass() == classToMix
            && method.getParameterTypes().length > 0) {
      typesToMixInto.add(method.getParameterTypes()[0]);
    }
  }
  for(Class<?> clazz : typesToMixInto) {
    DefaultGroovyMethods.mixin(clazz, classToMix);
  }
}
 

import org.codehaus.groovy.runtime.DefaultGroovyMethods; //导入依赖的package包/类
@NotNull
@Override
public List<PsiType[]> inferExpectedSignatures(@NotNull final PsiMethod method,
                                               @NotNull PsiSubstitutor substitutor,
                                               @NotNull String[] options) {
  return Collections.singletonList(ContainerUtil.map(options, new Function<String, PsiType>() {
    @Override
    public PsiType fun(String value) {
      try {
        PsiType type = JavaPsiFacade.getElementFactory(method.getProject()).createTypeFromText(value, method);
        return DefaultGroovyMethods.asBoolean(type) ? type : PsiType.NULL;
      }
      catch (IncorrectOperationException e) {
        return PsiType.NULL;
      }
    }
  }, new PsiType[options.length]));
}
 

import org.codehaus.groovy.runtime.DefaultGroovyMethods; //导入依赖的package包/类
@NotNull
@Override
protected PsiElementPredicate getElementPredicate() {
  return new PsiElementPredicate() {
    @Override
    public boolean satisfiedBy(PsiElement element) {
      if (!element.getNode().getElementType().equals(GroovyTokenTypes.kIF)) return false;
      if (!(element.getParent() instanceof GrIfStatement)) return false;

      final GrIfStatement ifStatement = DefaultGroovyMethods.asType(element.getParent(), GrIfStatement.class);

      final GrIfStatement elseIf = getElseIf(ifStatement);
      return elseIf != null && checkIf(ifStatement) && checkIf(elseIf);
    }
  };
}
 

import org.codehaus.groovy.runtime.DefaultGroovyMethods; //导入依赖的package包/类
@NotNull
@Override
protected PsiElementPredicate getElementPredicate() {
  return new PsiElementPredicate() {
    @Override
    public boolean satisfiedBy(PsiElement element) {
      PsiElement parent = element.getParent();
      if (parent instanceof GrArgumentLabel &&
          ((GrArgumentLabel)parent).getNameElement().equals(element) &&
          parent.getParent() != null &&
          parent.getParent().getParent() instanceof GrListOrMap) {
        GrListOrMap map = DefaultGroovyMethods.asType(parent.getParent().getParent(), GrListOrMap.class);
        if (!ErrorUtil.containsError(map) && map.getInitializers().length == 0 && isLiteralKeys(map.getNamedArguments())) {
          return true;
        }
      }


      return false;
    }
  };
}
 

import org.codehaus.groovy.runtime.DefaultGroovyMethods; //导入依赖的package包/类
public Set<GroovyClassDoc> getParentInterfaces() {
    Set<GroovyClassDoc> result = new LinkedHashSet<GroovyClassDoc>();
    result.add(this);
    Set<GroovyClassDoc> next = new LinkedHashSet<GroovyClassDoc>();
    next.addAll(Arrays.asList(this.interfaces()));
    while (!next.isEmpty()) {
        Set<GroovyClassDoc> temp = next;
        next = new LinkedHashSet<GroovyClassDoc>();
        for (GroovyClassDoc t : temp) {
            if (t instanceof SimpleGroovyClassDoc) {
                next.addAll(((SimpleGroovyClassDoc)t).getParentInterfaces());
            } else if (t instanceof ExternalGroovyClassDoc) {
                ExternalGroovyClassDoc d = (ExternalGroovyClassDoc) t;
                next.addAll(getJavaInterfaces(d));
            }
        }
        next = DefaultGroovyMethods.minus(next, result);
        result.addAll(next);
    }
    return result;
}
 

import org.codehaus.groovy.runtime.DefaultGroovyMethods; //导入依赖的package包/类
public static void serialize(final String name, final Object ast) {
    if (name == null || name.length() == 0) return;

    XStream xstream = new XStream(new StaxDriver());
    FileWriter astFileWriter = null;
    try {
        File astFile = astFile(name);
        if (astFile == null) {
            System.out.println("File-name for writing " + name + " AST could not be determined!");
            return;
        }
        astFileWriter = new FileWriter(astFile, false);
        xstream.toXML(ast, astFileWriter);
        System.out.println("Written AST to " + name + ".xml");

    } catch (Exception e) {
        System.out.println("Couldn't write to " + name + ".xml");
        e.printStackTrace();
    } finally {
        DefaultGroovyMethods.closeQuietly(astFileWriter);
    }
}
 

import org.codehaus.groovy.runtime.DefaultGroovyMethods; //导入依赖的package包/类
public String toString() {
    List buffer = new ArrayList();

    if (this.years != 0) buffer.add(this.years + " years");
    if (this.months != 0) buffer.add(this.months + " months");
    if (this.days != 0) buffer.add(this.days + " days");
    if (this.hours != 0) buffer.add(this.hours + " hours");
    if (this.minutes != 0) buffer.add(this.minutes + " minutes");

    if (this.seconds != 0 || this.millis != 0) {
        int norm_millis = this.millis % 1000;
        int norm_seconds = this.seconds + DefaultGroovyMethods.intdiv(this.millis - norm_millis, 1000).intValue();
        CharSequence millisToPad = "" + Math.abs(norm_millis);
        buffer.add((norm_seconds == 0 ? (norm_millis < 0 ? "-0" : "0") : norm_seconds) + "." + StringGroovyMethods.padLeft(millisToPad, 3, "0") + " seconds");
    }

    if (!buffer.isEmpty()) {
        return DefaultGroovyMethods.join(buffer.iterator(), ", ");
    } else {
        return "0";
    }
}
 

import org.codehaus.groovy.runtime.DefaultGroovyMethods; //导入依赖的package包/类
private void connectMultimethods(List<CachedClass> superClasses, CachedClass firstGroovyClass) {
    superClasses = DefaultGroovyMethods.reverse(superClasses);
    MetaMethodIndex.Header last = null;
    for (final CachedClass c : superClasses) {
        MetaMethodIndex.Header methodIndex = metaMethodIndex.getHeader(c.getTheClass());
        // We don't copy DGM methods to superclasses' indexes
        // The reason we can do that is particular set of DGM methods in use,
        // if at some point we will define DGM method for some Groovy class or
        // for a class derived from such, we will need to revise this condition.
        // It saves us a lot of space and some noticeable time
        if (last != null) metaMethodIndex.copyNonPrivateNonNewMetaMethods(last, methodIndex);
        last = methodIndex;

        if (c == firstGroovyClass)
            break;
    }
}
 

import org.codehaus.groovy.runtime.DefaultGroovyMethods; //导入依赖的package包/类
private List breadthFirstRest(boolean preorder) {
    List answer = new NodeList();
    Stack stack = new Stack();
    List nextLevelChildren = preorder ? getDirectChildren() : DefaultGroovyMethods.reverse(getDirectChildren());
    while (!nextLevelChildren.isEmpty()) {
        List working = new NodeList(nextLevelChildren);
        nextLevelChildren = new NodeList();
        for (Object child : working) {
            if (preorder) {
                answer.add(child);
            } else {
                stack.push(child);
            }
            if (child instanceof Node) {
                Node childNode = (Node) child;
                List children = childNode.getDirectChildren();
                if (children.size() > 1 || (children.size() == 1 && !(children.get(0) instanceof String))) nextLevelChildren.addAll(preorder ? children : DefaultGroovyMethods.reverse(children));
            }
        }
    }
    while (!stack.isEmpty()) {
        answer.add(stack.pop());
    }
    return answer;
}
 

import org.codehaus.groovy.runtime.DefaultGroovyMethods; //导入依赖的package包/类
@Test
public void testAfterPropertiesSet() {
    try {
        generator.setLinkService(null);
        generator.afterPropertiesSet();
        Assert.fail("expected illegal arg exception");
    } catch (Exception e) {
        // NOOP
    }

    generator.setLinkService(DefaultGroovyMethods.asType(new Closure<Void>(this, this) {
        public void doCall(Object it) {
        }

        public void doCall() {
            doCall(null);
        }

    }, ILinkService.class));
    generator.afterPropertiesSet();
}
 

import org.codehaus.groovy.runtime.DefaultGroovyMethods; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
protected Set<Class> findActions()  {
	Set<Class> set = super.findActions();
	for( int index = 0; groovyActionPackages != null && index < groovyActionPackages.length; index++ ){
		try{
			String groovyPackage = srcPath+groovyActionPackages[index];
			URL url = new URL(groovyPackage);
			File folderList=new File(url.toURI()); 
			File list[] = folderList.listFiles(); 
	        for(int i=0;i <list.length;i++) {
	        	File file = list[i];
	        	if(file.toString().endsWith(Constants.GROOVY_EXTENSION) && !file.isDirectory()){
	        		String groovyPath = url.toString()+"/"+file.getName();
	        		URL gUrl = new URL(groovyPath);
	        		Class scriptClass = groovyClassLoader.parseClass(DefaultGroovyMethods.getText(gUrl, "UTF-8") );
	    			set.add(scriptClass);
	        	}
	        }
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	return set;
}