public static void main(String[] args) {
Collection<String> collection = new HashSet<String>();
collection.add("one");
collection.add("two");
Iterator<String> iterator = collection.iterator();
while (iterator.hasNext()) {
String s = iterator.next();
System.out.println(s);
}
System.out.println("======================================");
TreeSet<String> set = new TreeSet<String>(collection);
Iterator<String> itor = set.iterator();
while (itor.hasNext()) {
System.out.println(itor.next());
}
Collection<String> colList = new ArrayList<String>();
colList.add("one");
colList.add("two");
colList.add("three");
if (colList.containsAll(collection)) {
System.out.println("true");
}
System.out.println("=================");
String[] strings = colList.toArray(new String[0]);
String[] strings1 = (String[]) colList.toArray();
}
// FIXME: does not integrate with recursive session method calls: recursionEnter/Exit and also
// recurse do not match the control flow of recursive calls, and hence runtime type monitoring
// does not work.
private Node translateSJRecursion(SJRecursion r, QQ qq)
// recursionEnter inserted by node factory, but translation is finished here..
{
SJSessionOperationExt soe = getSJSessionOperationExt(r);
Position pos = r.position();
Collection<Object> mapping = new LinkedList<Object>();
String bname = getRecursionBooleanName(soe.targetNames(), r.label());
mapping.add(bname);
mapping.add(bname);
String translation = "for (boolean %s = true; %s; ) { }";
For f = (For) qq.parseStmt(translation, mapping.toArray());
mapping.clear();
r = (SJRecursion) r.inits(f.inits());
r = (SJRecursion) r.cond(f.cond());
List stmts = new LinkedList();
stmts.addAll(r.body().statements());
translation = "%s = %E;";
mapping.add(bname);
mapping.add(((Eval) stmts.remove(0)).expr()); // Factor out constant.
Eval e = (Eval) qq.parseStmt(translation, mapping.toArray());
stmts.add(0, e);
r = (SJRecursion) r.body(sjnf.Block(pos, stmts));
/*// Appending the recursion-exit hook. // Disabled to support delegation from within recursion scopes (socket will be null on recursion-exit).
List<Local> targets = new LinkedList<Local>(); // FIXME: should be SJLocalSockets.
for (String sjname : soe.targetNames()) // Unicast optimisation for SJRecursionExit is done within the NodeFactory method - this pass comes after SJUnicastOptimiser.
{
targets.add(sjnf.Local(pos, sjnf.Id(pos, sjname))); // Would it be bad to instead alias the recursionEnter targets?
}
SJRecursionExit re = sjnf.SJRecursionExit(pos, targets); // Problem: the sockets argument array is not yet filled (for other (internal) basic operations, this was done earlier by SJSessionOperationParser)...
re = (SJRecursionExit) SJVariableParser.parseSJSessionOperation(this, re); // ...Current fix: use those routines form those earlier passes.
re = (SJRecursionExit) SJSessionOperationParser.fixSJBasicOperationArguments(this, re);*/
// return sjnf.Block(pos, r, sjnf.Eval(pos, re));
return sjnf.Block(pos, r);
}
@NotNull
private static PsiSubstitutor replaceVariables(Collection<InferenceVariable> inferenceVariables) {
final List<InferenceVariable> targetVars = new ArrayList<InferenceVariable>();
PsiSubstitutor substitutor = PsiSubstitutor.EMPTY;
final InferenceVariable[] oldVars =
inferenceVariables.toArray(new InferenceVariable[inferenceVariables.size()]);
for (InferenceVariable variable : oldVars) {
final InferenceVariable newVariable =
new InferenceVariable(
variable.getCallContext(), variable.getParameter(), variable.getName());
substitutor =
substitutor.put(
variable,
JavaPsiFacade.getElementFactory(variable.getProject()).createType(newVariable));
targetVars.add(newVariable);
if (variable.isThrownBound()) {
newVariable.setThrownBound();
}
}
for (int i = 0; i < targetVars.size(); i++) {
InferenceVariable var = targetVars.get(i);
for (InferenceBound boundType : InferenceBound.values()) {
for (PsiType bound : oldVars[i].getBounds(boundType)) {
var.addBound(substitutor.substitute(bound), boundType, null);
}
}
}
return substitutor;
}
private Node translateSJInbranch(SJInbranch ib, QQ qq) {
StringBuilder translation = new StringBuilder("{ ");
Collection<Object> mapping = new LinkedList<Object>();
String labVar = UniqueID.newID(SJ_INBRANCH_LABEL_FIELD_PREFIX);
translation.append("%T %s = %E; ");
mapping.add(qq.parseType(SJ_LABEL_CLASS));
mapping.add(labVar);
mapping.add(ib.inlabel());
for (Iterator<SJInbranchCase> i = ib.branchCases().iterator(); i.hasNext(); ) {
SJInbranchCase ibc = i.next();
translation.append("if (%s.equals(%E)) { %LS } ");
mapping.add(labVar);
mapping.add(sjnf.StringLit(ib.position(), ibc.label().labelValue()));
mapping.add(ibc.statements());
if (i.hasNext()) {
translation.append("else ");
}
}
translation.append("else { throw new SJIOException(\"Unexpected inbranch label: \" + %s); }");
mapping.add(labVar);
// FIXME: need a final else case to better handle, if runtime monitoring is disabled,
// non-sj-compatibility mode and in case of malicious peers.
translation.append('}');
return qq.parseStmt(translation.toString(), mapping.toArray());
}
private static void testPotato(
Class<? extends Collection> implClazz, Class<? extends List> argClazz) throws Throwable {
try {
System.out.printf("implClazz=%s, argClazz=%s\n", implClazz.getName(), argClazz.getName());
final int iterations = 100000;
final List<Integer> list = (List<Integer>) argClazz.newInstance();
final Integer one = Integer.valueOf(1);
final List<Integer> oneElementList = Collections.singletonList(one);
final Constructor<? extends Collection> constr = implClazz.getConstructor(Collection.class);
final Thread t =
new CheckedThread() {
public void realRun() {
for (int i = 0; i < iterations; i++) {
list.add(one);
list.remove(one);
}
}
};
t.setDaemon(true);
t.start();
for (int i = 0; i < iterations; i++) {
Collection<?> coll = constr.newInstance(list);
Object[] elts = coll.toArray();
check(elts.length == 0 || (elts.length == 1 && elts[0] == one));
}
} catch (Throwable t) {
unexpected(t);
}
}
@Test
public void testCookies_whenCookiesArePresent() {
Collection<Cookie> cookies = new ArrayList<>();
cookies.add(new Cookie("cookie1", "cookie1value"));
cookies.add(new Cookie("cookie2", "cookie2value"));
Map<String, String> expected = new HashMap<>();
for (Cookie cookie : cookies) {
expected.put(cookie.getName(), cookie.getValue());
}
Cookie[] cookieArray = cookies.toArray(new Cookie[cookies.size()]);
when(servletRequest.getCookies()).thenReturn(cookieArray);
assertTrue(
"The count of cookies returned should be the same as those in the request",
request.cookies().size() == 2);
assertEquals(
"A Map of Cookies should have been returned because they exist",
expected,
request.cookies());
}
@Nullable
public static PsiClass[] getAllTestClasses(final TestClassFilter filter, boolean sync) {
final PsiClass[][] holder = new PsiClass[1][];
final Runnable process =
() -> {
final ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator();
final Collection<PsiClass> set = new LinkedHashSet<>();
final PsiManager manager = PsiManager.getInstance(filter.getProject());
final GlobalSearchScope projectScope =
GlobalSearchScope.projectScope(manager.getProject());
final GlobalSearchScope scope = projectScope.intersectWith(filter.getScope());
for (final PsiClass psiClass : AllClassesSearch.search(scope, manager.getProject())) {
if (filter.isAccepted(psiClass)) {
if (indicator != null) {
indicator.setText2(
"Found test class " + ReadAction.compute(psiClass::getQualifiedName));
}
set.add(psiClass);
}
}
holder[0] = set.toArray(new PsiClass[set.size()]);
};
if (sync) {
ProgressManager.getInstance()
.runProcessWithProgressSynchronously(
process, "Searching For Tests...", true, filter.getProject());
} else {
process.run();
}
return holder[0];
}
/**
* Set an array parameter.<br>
* See {@link #addParameter(String, Object...)} for details
*/
public Query addParameter(String name, final Collection<?> values) {
if (values == null) {
throw new NullPointerException("Array parameter cannot be null");
}
return addParameter(name, values.toArray());
}
/**
* Constructs a vector containing the elements of the specified collection, in the order they are
* returned by the collection's iterator.
*
* @param c the collection whose elements are to be placed into this vector
* @throws NullPointerException if the specified collection is null
* @since 1.2
*/
public Vector(Collection<? extends E> c) {
elementData = c.toArray();
elementCount = elementData.length;
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
}
/**
* Update all known Provisioners of the new ResourceCapability
*
* @param resourceCapability The ResourceCapability object
* @param deployedServices List of deployed services
*/
void updateMonitors(
ResourceCapability resourceCapability, List<DeployedService> deployedServices) {
ProvisionLeaseManager[] mgrs;
synchronized (leaseTable) {
Collection<ProvisionLeaseManager> c = leaseTable.values();
mgrs = c.toArray(new ProvisionLeaseManager[c.size()]);
}
if (mgrs == null) return;
if (mgrs.length == 0) return;
for (ProvisionLeaseManager mgr : mgrs) {
try {
mgr.provisioner.update(
adapter.getInstantiator(), resourceCapability, deployedServices, serviceLimit);
} catch (Throwable t) {
if (logger.isLoggable(Level.FINEST))
logger.log(Level.FINEST, "Updating ProvisionManager", t);
boolean connected = false;
/* Determine if we should even try to reconnect */
final int category = ThrowableConstants.retryable(t);
if (category == ThrowableConstants.INDEFINITE
|| category == ThrowableConstants.UNCATEGORIZED) {
connected = mgr.reconnect();
}
if (!connected) {
removeProvisionManager(mgr.provisioner, mgr.serviceID);
}
}
}
}
/**
* add a collection
*
* @param index
* @param c a collection to add
* @return true if the collection was modified
*/
public boolean addAll(int index, Collection c) {
if (c != null) {
if (this.collection == null) this.collection = this.initCollection();
boolean modified = false;
int i = index;
for (Iterator it = c.iterator(); it.hasNext(); ) {
Object object = it.next();
if (this.itemAllowed(object)) {
this.add(i++, object);
}
}
/* fire event */
int[] positions = new int[c.size()];
for (int j = 0; j < c.size(); j++) positions[j] = j + index;
this.firePropertyChange(
new ContentChangeEvent(
this,
PROPERTY_CONTENT,
ContentChangeEvent.ADD,
positions,
(AbstractSibType[]) c.toArray(new AbstractSibType[] {})));
return modified;
}
return false;
}
/**
* @param databaseTableDescription - table for columns actually in the database
* @param configColumns - column names of configurated columns
*/
private void checkUnknownColumns(
TableDescription databaseTableDescription, String[] configColumns) {
Collection<String> c = getUnmappedColumns(databaseTableDescription.getTableName());
String[] unmappedColumns = c.toArray(new String[0]);
// check that unmapped columns exist in database
for (String unmapped : c) {
assertTrue(
"Column: "
+ databaseTableDescription.getTableName()
+ "."
+ unmapped
+ " [declared as unknown, but] not in database",
databaseTableDescription.getColumn(unmapped) != null);
}
String[] dbColumns = databaseTableDescription.getColumnNames();
for (String theDbColumn : dbColumns) {
if (!containsIgnoreCase(unmappedColumns, theDbColumn)) {
assertTrue(
"Table "
+ databaseTableDescription.getTableName()
+ " contains unknown column: '"
+ theDbColumn
+ "'",
containsIgnoreCase(configColumns, theDbColumn));
}
}
}
public int run(String[] args) throws Exception {
Configuration conf = getConf();
Collection<String> topWords = parseTopWords(conf);
String[] topWordsArr = topWords.toArray(new String[topWords.size()]);
conf.setStrings(TOP_WORDS_KEY, topWordsArr);
Job job = new Job(conf);
job.setJarByClass(InversedIndexTool.class);
job.setJobName("inversed_index");
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(ArticleNameAndFrequency.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(ArticleNameAndFrequency.class);
job.setMapperClass(Map.class);
job.setInputFormatClass(TextInputFormat.class);
job.setOutputFormatClass(TextOutputFormat.class);
job.setNumReduceTasks(0);
FileInputFormat.setInputPaths(job, inputPath);
FileOutputFormat.setOutputPath(job, outputPath);
boolean success = job.waitForCompletion(true);
articlesCount = job.getCounters().findCounter(Counters.ARTICLE_COUNTER).getValue();
return success ? 0 : 1;
}
/**
* This returns an enumeration of all Darts in Graph G in a canonical order starting with
* firstDart. The order is canonical in the sense that it only depends on the oriented isomorphism
* class of G (and firstDart). That is, if there is an oriented iso G <-> G' sending firstDart <->
* firstDart', then that bijection will send getDarts <-> getDarts'.
*
* <p>This enumeration is useful in finding explicit bijections of isomorphic graphs.
*/
public static Dart[] getDarts(Dart firstDart, Graph G) {
/**
* Description of algorithm: Return all the couples around V0=firstDart.V, then all couples
* around V1, .... The order for couples around firstDart.V is counterclockwise starting with
* firstDart.F. clockwise around V1,... So we need to order the vertices V0,V1,... and pick the
* first face to use at each vertex and the rest is determined. Order on V0,... = first
* encountered. Order on faces at vertex = first encountered.
*/
distinctFIFO vQueue = new distinctFIFO();
util.ConditionGetter fQueue = new util.ConditionGetter();
fQueue.add(firstDart.getF());
vQueue.put(firstDart.getV());
Collection coups = new ArrayList();
int coupsIndex = 0;
Vertex V;
while ((V = (Vertex) vQueue.remove()) != null) {
Face F = (Face) fQueue.get(new incidence(V));
for (int i = 0; i < V.size(); i++) {
Face Fx = V.next(F, i);
coups.add(new Dart(V, Fx));
vQueue.put(Fx.next(V, 1));
fQueue.add(Fx);
}
}
return (Dart[]) coups.toArray(new Dart[coups.size()]);
}
public AddGradleDslPluginAction() {
getTemplatePresentation()
.setDescription(GradleBundle.message("gradle.codeInsight.action.apply_plugin.description"));
getTemplatePresentation()
.setText(GradleBundle.message("gradle.codeInsight.action.apply_plugin.text"));
getTemplatePresentation().setIcon(GradleIcons.GradlePlugin);
Collection<KeyValue> pluginDescriptions = new ArrayList<KeyValue>();
for (GradlePluginDescriptionsExtension extension :
GradlePluginDescriptionsExtension.EP_NAME.getExtensions()) {
for (Map.Entry<String, String> pluginDescription :
extension.getPluginDescriptions().entrySet()) {
pluginDescriptions.add(
KeyValue.create(pluginDescription.getKey(), pluginDescription.getValue()));
}
}
myPlugins = pluginDescriptions.toArray(new KeyValue[pluginDescriptions.size()]);
Arrays.sort(
myPlugins,
new Comparator<KeyValue>() {
@Override
public int compare(KeyValue o1, KeyValue o2) {
return String.valueOf(o1.getKey()).compareTo(String.valueOf(o2.getKey()));
}
});
}
private String[] getStringProperty(String name, Object value) {
// Don't log a warning if the value is null. The filter guarantees at least one of the necessary
// properties
// is there. If others are not, this method will get called with value equal to null.
if (value == null) return new String[0];
if (value instanceof String) {
return new String[] {(String) value};
}
if (value instanceof String[]) {
return (String[]) value;
}
Exception e = null;
if (value instanceof Collection) {
@SuppressWarnings("unchecked")
Collection<String> temp = (Collection<String>) value;
try {
return temp.toArray(new String[temp.size()]);
} catch (ArrayStoreException ase) {
e = ase;
}
}
log.log(
LogService.LOG_WARNING,
NLS.bind(
MetaTypeMsg.INVALID_PID_METATYPE_PROVIDER_IGNORED,
new Object[] {_bundle.getSymbolicName(), _bundle.getBundleId(), name, value}),
e);
return new String[0];
}
/**
* Returns the file representing the Git repository directory for the given file path or any of
* its parent in the filesystem. If the file doesn't exits, is not a Git repository or an error
* occurred while transforming the given path into a store <code>null</code> is returned.
*
* @param path expected format /file/{Workspace}/{projectName}[/{path}]
* @return the .git folder if found or <code>null</code> the give path cannot be resolved to a
* file or it's not under control of a git repository
* @throws CoreException
*/
public static File getGitDir(IPath path) throws CoreException {
Map<IPath, File> gitDirs = GitUtils.getGitDirs(path, Traverse.GO_UP);
if (gitDirs == null) return null;
Collection<File> values = gitDirs.values();
if (values.isEmpty()) return null;
return values.toArray(new File[] {})[0];
}
@Override
public AbstractFile[] ls() throws IOException, UnsupportedFileOperationException {
List<GuestFileInfo> fileInfos = new ArrayList<GuestFileInfo>();
int index = 0;
VsphereConnHandler connHandler = null;
try {
connHandler = getConnHandler();
ManagedObjectReference fileManager = getFileManager(connHandler);
boolean haveRemaining;
do {
GuestListFileInfo res =
connHandler
.getClient()
.getVimPort()
.listFilesInGuest(fileManager, vm, credentials, getPathInVm(), index, null, null);
haveRemaining = (res.getRemaining() != 0);
fileInfos.addAll(res.getFiles());
index = fileInfos.size();
} while (haveRemaining);
String parentPath = PathUtils.removeTrailingSeparator(fileURL.getPath()) + SEPARATOR;
Collection<AbstractFile> res = new ArrayList<AbstractFile>();
for (GuestFileInfo f : fileInfos) {
final String name = getFileName(f.getPath());
if (name.equals(".") || name.equals("..")) {
continue;
}
FileURL childURL = (FileURL) fileURL.clone();
childURL.setPath(parentPath + name);
AbstractFile newFile = new VSphereFile(childURL, this, f);
res.add(newFile);
}
return res.toArray(new AbstractFile[0]);
} catch (FileFaultFaultMsg e) {
translateandLogException(e);
} catch (GuestOperationsFaultFaultMsg e) {
translateandLogException(e);
} catch (InvalidStateFaultMsg e) {
translateandLogException(e);
} catch (RuntimeFaultFaultMsg e) {
translateandLogException(e);
} catch (TaskInProgressFaultMsg e) {
translateandLogException(e);
} catch (InvalidPropertyFaultMsg e) {
translateandLogException(e);
} catch (URISyntaxException e) {
translateandLogException(e);
} finally {
releaseConnHandler(connHandler);
}
// we never get here..
return null;
}
private static void copyCollection(
Object target,
String[] effectiveProperties,
String[] ignoreProperties,
Boolean nullBeCopied,
PropertyDescriptor targetPd,
Object sourceValue,
Method writeMethod)
throws IllegalAccessException, InvocationTargetException, UtilException,
ClassNotFoundException, InstantiationException, NoSuchFieldException {
Method targetReadMethod = targetPd.getReadMethod();
Collection targetValue = (Collection) targetReadMethod.invoke(target, null);
List tempList = new ArrayList();
if (sourceValue == null) {
writeMethod.invoke(target, sourceValue);
return;
}
if (targetValue == null) {
if (Set.class.isAssignableFrom(targetPd.getPropertyType())) {
targetValue = new HashSet();
} else if (List.class.isAssignableFrom(targetPd.getPropertyType())) {
targetValue = new ArrayList();
} else {
return;
}
}
Object[] sourceArray = ((Collection) sourceValue).toArray();
Object[] targetArray = targetValue.toArray();
for (int i = 0; i < sourceArray.length; i++) {
if (targetValue.contains(sourceArray[i])) {
for (int j = 0; j < targetArray.length; j++) {
if (sourceArray[i].equals(targetArray[j])) {
copyProperties(
sourceArray[i],
targetArray[j],
effectiveProperties,
ignoreProperties,
nullBeCopied);
tempList.add(targetArray[j]);
break;
}
}
} else {
Object tempTarget = Class.forName(sourceArray[i].getClass().getName()).newInstance();
// 基本类型直接赋值
if (sourceArray[i].getClass().isPrimitive() || sourceArray[i] instanceof String) {
tempTarget = sourceArray[i];
} else {
copyProperties(
sourceArray[i], tempTarget, effectiveProperties, ignoreProperties, nullBeCopied);
}
tempList.add(tempTarget);
}
}
targetValue.clear();
targetValue.addAll(tempList);
return;
}
/**
* Makes <tt>RTCPSDES</tt> packets for all the RTP streams that we're sending.
*
* @return a <tt>List</tt> of <tt>RTCPSDES</tt> packets for all the RTP streams that we're
* sending.
*/
private RTCPSDESPacket makeSDESPacket() {
Collection<RTCPSDES> sdesChunks = new ArrayList<RTCPSDES>();
// Create an SDES for our own SSRC.
RTCPSDES ownSDES = new RTCPSDES();
SSRCInfo ourinfo = getStream().getStreamRTPManager().getSSRCCache().ourssrc;
ownSDES.ssrc = (int) getLocalSSRC();
Collection<RTCPSDESItem> ownItems = new ArrayList<RTCPSDESItem>();
ownItems.add(new RTCPSDESItem(RTCPSDESItem.CNAME, ourinfo.sourceInfo.getCNAME()));
// Throttle the source description bandwidth. See RFC3550#6.3.9
// Allocation of Source Description Bandwidth.
if (sdesCounter % 3 == 0) {
if (ourinfo.name != null && ourinfo.name.getDescription() != null)
ownItems.add(new RTCPSDESItem(RTCPSDESItem.NAME, ourinfo.name.getDescription()));
if (ourinfo.email != null && ourinfo.email.getDescription() != null)
ownItems.add(new RTCPSDESItem(RTCPSDESItem.EMAIL, ourinfo.email.getDescription()));
if (ourinfo.phone != null && ourinfo.phone.getDescription() != null)
ownItems.add(new RTCPSDESItem(RTCPSDESItem.PHONE, ourinfo.phone.getDescription()));
if (ourinfo.loc != null && ourinfo.loc.getDescription() != null)
ownItems.add(new RTCPSDESItem(RTCPSDESItem.LOC, ourinfo.loc.getDescription()));
if (ourinfo.tool != null && ourinfo.tool.getDescription() != null)
ownItems.add(new RTCPSDESItem(RTCPSDESItem.TOOL, ourinfo.tool.getDescription()));
if (ourinfo.note != null && ourinfo.note.getDescription() != null)
ownItems.add(new RTCPSDESItem(RTCPSDESItem.NOTE, ourinfo.note.getDescription()));
}
sdesCounter++;
ownSDES.items = ownItems.toArray(new RTCPSDESItem[ownItems.size()]);
sdesChunks.add(ownSDES);
for (Map.Entry<Integer, byte[]> entry : cnameRegistry.entrySet()) {
RTCPSDES sdes = new RTCPSDES();
sdes.ssrc = entry.getKey();
sdes.items = new RTCPSDESItem[] {new RTCPSDESItem(RTCPSDESItem.CNAME, entry.getValue())};
}
RTCPSDES[] sps = sdesChunks.toArray(new RTCPSDES[sdesChunks.size()]);
RTCPSDESPacket sp = new RTCPSDESPacket(sps);
return sp;
}
private static String[] toStringArray(Collection coll) {
Object[] objArray = coll.toArray();
String[] strArray = new String[objArray.length];
for (int i = 0; i < objArray.length; i++) {
strArray[i] = (String) objArray[i];
}
return strArray;
}
@Override
public CompilerMessage[] getMessages(CompilerMessageCategory category) {
Collection<CompilerMessage> collection = myMessages.get(category);
if (collection == null) {
return CompilerMessage.EMPTY_ARRAY;
}
return collection.toArray(new CompilerMessage[collection.size()]);
}
private static void copyClassesImpl(
final String copyClassName,
final Project project,
final Map<PsiFile, PsiClass[]> classes,
final HashMap<PsiFile, String> map,
final Object targetDirectory,
final PsiDirectory defaultTargetDirectory,
final String commandName,
final boolean selectInActivePanel,
final boolean openInEditor) {
final boolean[] result = new boolean[] {false};
Runnable command =
() -> {
final Runnable action =
() -> {
try {
PsiDirectory target;
if (targetDirectory instanceof PsiDirectory) {
target = (PsiDirectory) targetDirectory;
} else {
target =
((MoveDestination) targetDirectory)
.getTargetDirectory(defaultTargetDirectory);
}
Collection<PsiFile> files =
doCopyClasses(classes, map, copyClassName, target, project);
if (files != null) {
if (openInEditor) {
for (PsiFile file : files) {
CopyHandler.updateSelectionInActiveProjectView(
file, project, selectInActivePanel);
}
EditorHelper.openFilesInEditor(files.toArray(new PsiFile[files.size()]));
}
result[0] = true;
}
} catch (final IncorrectOperationException ex) {
ApplicationManager.getApplication()
.invokeLater(
() ->
Messages.showMessageDialog(
project,
ex.getMessage(),
RefactoringBundle.message("error.title"),
Messages.getErrorIcon()));
}
};
ApplicationManager.getApplication().runWriteAction(action);
};
CommandProcessor processor = CommandProcessor.getInstance();
processor.executeCommand(project, command, commandName, null);
if (result[0]) {
ToolWindowManager.getInstance(project)
.invokeLater(() -> ToolWindowManager.getInstance(project).activateEditorComponent());
}
}
@SuppressWarnings("unchecked")
private void evaluateProvidedArtefacts() {
Object result =
GrailsClassUtils.getPropertyOrStaticPropertyOrFieldValue(plugin, PROVIDED_ARTEFACTS);
if (result instanceof Collection) {
final Collection artefactList = (Collection) result;
providedArtefacts = (Class<?>[]) artefactList.toArray(new Class[artefactList.size()]);
}
}
/**
* Returns an {@link Iterator} over a {@link Collection} of Throwable types which iterates over
* its elements in a consistent order (maintaining an ordering that is consistent across different
* runs makes it easier to compare sets generated by different implementations of the CFG
* classes).
*
* @param coll The collection to iterate over.
* @return An iterator which presents the elements of <code>coll</code> in order.
*/
private static Iterator sortedThrowableIterator(Collection coll) {
if (coll.size() <= 1) {
return coll.iterator();
} else {
Object array[] = coll.toArray();
Arrays.sort(array, new ThrowableComparator());
return Arrays.asList(array).iterator();
}
}
/**
* Appends all of the elements in the specified Collection to the end of this Vector, in the order
* that they are returned by the specified Collection's Iterator. The behavior of this operation
* is undefined if the specified Collection is modified while the operation is in progress. (This
* implies that the behavior of this call is undefined if the specified Collection is this Vector,
* and this Vector is nonempty.)
*
* @param c elements to be inserted into this Vector
* @return {@code true} if this Vector changed as a result of the call
* @throws NullPointerException if the specified collection is null
* @since 1.2
*/
public synchronized boolean addAll(Collection<? extends E> c) {
modCount++;
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityHelper(elementCount + numNew);
System.arraycopy(a, 0, elementData, elementCount, numNew);
elementCount += numNew;
return numNew != 0;
}
/**
* Return a query that will return docs like the passed lucene document ID.
*
* @param docNum the documentID of the lucene doc to generate the 'More Like This" query for.
* @return a query that will return docs like the passed lucene document ID.
*/
public Query like(int docNum) throws IOException {
if (fieldNames == null) {
// gather list of valid fields from lucene
Collection<String> fields = MultiFields.getIndexedFields(ir);
fieldNames = fields.toArray(new String[fields.size()]);
}
return createQuery(retrieveTerms(docNum));
}
public NSArray(Collection<T> c) {
super((SkipInit) null);
if (c instanceof NSArray) {
initObject(objc_initWithArray(this, initWithArray$, (NSArray<T>) c));
} else {
NSObject[] objects = c.toArray(new NSObject[c.size()]);
initWithObjects(objects);
}
}
public PortalIterator(final PortalManager manager) {
this.manager = manager;
Collection<ABPortal> p = manager.allPortals.values();
portals = p.toArray(new ABPortal[p.size()]);
index = -1;
last = null;
}
public static CompileScope createScopeWithArtifacts(
final CompileScope baseScope,
@NotNull Collection<Artifact> artifacts,
boolean useCustomContentId) {
baseScope.putUserData(ARTIFACTS_KEY, artifacts.toArray(new Artifact[artifacts.size()]));
if (useCustomContentId) {
baseScope.putUserData(CompilerManager.CONTENT_ID_KEY, ARTIFACTS_CONTENT_ID_KEY);
}
return baseScope;
}
