下面列出了java.util.LinkedList#addFirst ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
private void deAssign(AssignmentSimple assignmentSimple, Op03SimpleStatement container, List<Op03SimpleStatement> added) {
Expression rhs = assignmentSimple.getRValue();
if (rhs instanceof LValueExpression || rhs instanceof Literal) return;
Deassigner deassigner = new Deassigner();
LinkedList<LValue> lValues = ListFactory.newLinkedList();
while (rhs instanceof AssignmentExpression) {
AssignmentExpression assignmentExpression = (AssignmentExpression)rhs;
lValues.addFirst(assignmentExpression.getlValue());
rhs = assignmentExpression.getrValue();
}
Expression rhs2 = deassigner.rewriteExpression(rhs, container.getSSAIdentifiers(), container, ExpressionRewriterFlags.RVALUE);
if (deassigner.extracted.isEmpty()) return;
for (LValue outer : lValues) {
rhs2 = new AssignmentExpression(outer, rhs2);
}
assignmentSimple.setRValue(rhs2);
rewrite(deassigner, container, added);
}
public void run(String[] args) throws Exception {
LinkedList<Starter> starters = new LinkedList<>();
HashSet<String> consumerIds = new HashSet<>();
for (ConsumerConfig consumerConfig : consumerConfigs) {
if (!validPipeline(consumerConfig)) {
continue;
}
if (consumerIds.contains(consumerConfig.getConsumerId())) {
throw new InvalidConfigException("Duplicate consumerId: " + consumerConfig.getConsumerId());
}
consumerIds.add(consumerConfig.getConsumerId());
starters.add(new ConsumerStarter(consumerConfig, syncerConfig, consumerRegistry).start());
}
// add producer as first item, stop producer first
starters.addFirst(ProducerStarter
.getInstance(producerConfig.getInput(), syncerConfig.getInput(), consumerRegistry)
.start());
Runtime.getRuntime().addShutdownHook(new WaitingAckHook(starters));
SyncerHealth.init(starters);
ExportServer.init(args);
}
@Nullable
private static Collection<Pair<PsiElement, BreadcrumbsProvider>> getLineElements(Document document,
int offset,
VirtualFile file,
Project project,
BreadcrumbsProvider defaultInfoProvider,
boolean checkSettings) {
PsiElement element = findStartElement(document, offset, file, project, defaultInfoProvider, checkSettings);
if (element == null) return null;
LinkedList<Pair<PsiElement, BreadcrumbsProvider>> result = new LinkedList<>();
while (element != null) {
BreadcrumbsProvider provider = findProviderForElement(element, defaultInfoProvider, checkSettings);
if (provider != null && provider.acceptElement(element)) {
result.addFirst(Pair.create(element, provider));
}
element = getParent(element, provider);
if (element instanceof PsiDirectory) break;
}
return result;
}
private HttpInterfaceDTO convertToDTO(HttpInterfaceBO httpInterfaceBO) {
HttpInterfaceDTO httpInterfaceDTO = new HttpInterfaceDTO();
BeanUtils.copyProperties(httpInterfaceBO, httpInterfaceDTO);
// path
Long spaceId = httpInterfaceBO.getSpaceId();
LinkedList<Long> path = new LinkedList<>();
while (!spaceId.equals(ROOT_SPACE_ID)) {
path.addFirst(spaceId);
spaceId = spaceDao.queryById(spaceId).getParentId();
}
httpInterfaceDTO.setPath(path);
// variable
httpInterfaceDTO.setVariable(PrivilegeVerifier.hasPermission(httpInterfaceBO.getAccessAuthority()));
return httpInterfaceDTO;
}
/**
* �S�[���m�[�h�܂ł̃p�X���\�z����
*
* @param node �S�[���m�[�h
* @return �X�^�[�g�m�[�h����S�[���m�[�h�܂ł̃p�X
*/
private LinkedList constructPath(Node node) {
LinkedList path = new LinkedList();
// �e�m�[�h�����X���ǂ�
while (node.parentNode != null) {
// �ŏ��ɒlj�����̂��~�\
// �X�^�[�g�m�[�h��LinkedList�̐擪
// �S�[���m�[�h��LinkedList�̍Ō�ɂȂ�悤�ɂ���
path.addFirst(node);
node = node.parentNode;
}
// �X�^�[�g�m�[�h�inode.parentNode == null�ƂȂ�m�[�h�j
// ���lj�������
path.addFirst(node);
return path;
}
FieldPathIteratorHandler.ModificationStatus iterateSubset(int startPos, int endPos, FieldPath fieldPath, String variable, int nextPos, FieldPathIteratorHandler handler) {
FieldPathIteratorHandler.ModificationStatus retVal = FieldPathIteratorHandler.ModificationStatus.NOT_MODIFIED;
LinkedList<Integer> indicesToRemove = new LinkedList<Integer>();
for (int i = startPos; i <= endPos && i < values.size(); i++) {
if (variable != null) {
handler.getVariables().put(variable, new FieldPathIteratorHandler.IndexValue(i));
}
FieldValue fv = values.get(i);
FieldPathIteratorHandler.ModificationStatus status = fv.iterateNested(fieldPath, nextPos, handler);
if (status == FieldPathIteratorHandler.ModificationStatus.REMOVED) {
indicesToRemove.addFirst(i);
retVal = FieldPathIteratorHandler.ModificationStatus.MODIFIED;
} else if (status == FieldPathIteratorHandler.ModificationStatus.MODIFIED) {
retVal = status;
}
}
if (variable != null) {
handler.getVariables().remove(variable);
}
for (Integer idx : indicesToRemove) {
values.remove(idx.intValue());
}
return retVal;
}
public static List<VirtualFile> findSuitableFilesFor(final String filePath, final Project project) {
final ProjectFileIndex index = ProjectRootManager.getInstance(project).getFileIndex();
// at first let's try to find file as is, by it's real path
// and check that file belongs to current project
// this location provider designed for tests thus we will check only project content
// (we cannot check just sources or tests folders because RM doesn't use it
final VirtualFile file = getByFullPath(filePath);
final boolean inProjectContent = file != null && (index.isInContent(file));
if (inProjectContent) {
return Collections.singletonList(file);
}
//split file by "/" in parts
final LinkedList<String> folders = new LinkedList<String>();
final StringTokenizer st = new StringTokenizer(filePath, "/", false);
String fileName = null;
while (st.hasMoreTokens()) {
final String pathComponent = st.nextToken();
if (st.hasMoreTokens()) {
folders.addFirst(pathComponent);
} else {
// last token
fileName = pathComponent;
}
}
if (fileName == null) {
return Collections.emptyList();
}
return findFilesClosestToTarget(folders, collectCandidates(project, fileName, true), MIN_PROXIMITY_THRESHOLD);
}
/**
* Creates a {@link com.google.cloud.backend.core.Filter} for IN operation.
*
* @param propertyName Name of the target property.
* @param values any number of {@link Object}s for the IN operation.
* @return {@link com.google.cloud.backend.core.Filter} for this operation.
*/
public static Filter in(String propertyName, List<Object> values) {
LinkedList<Object> l = new LinkedList<Object>(values);
l.addFirst(propertyName);
Filter f = new Filter();
f.filterDto.setOperator(Op.IN.name());
f.filterDto.setValues(l);
return f;
}
@Override
public List<Task> getTasksInDocumentOrder() {
List<Task> result = Lists.newArrayList();
LinkedList<Task> deque = new LinkedList<>();
deque.addFirst(getRootTask());
while (!deque.isEmpty()) {
Task head = deque.poll();
result.add(head);
deque.addAll(0, Arrays.asList(head.getNestedTasks()));
}
result.remove(0);
return result;
}
/**
* Deeply compare two SortedMap instances. This method walks the Maps in order,
* taking advantage of the fact that the Maps are SortedMaps.
*
* @param map1 SortedMap one
* @param map2 SortedMap two
* @param stack add items to compare to the Stack (Stack versus recursion)
* @param visited Set containing items that have already been compared, to prevent cycles.
*
* @return false if the Maps are for certain not equals. 'true' indicates that 'on the surface'
* the maps
* are equal, however, it will place the contents of the Maps on the stack for further
* comparisons.
*/
private static boolean compareSortedMap(SortedMap map1, SortedMap map2, LinkedList stack,
Set visited) {
// Same instance check already performed...
if (map1.size() != map2.size()) {
return false;
}
Iterator i1 = map1.entrySet()
.iterator();
Iterator i2 = map2.entrySet()
.iterator();
while (i1.hasNext()) {
Entry entry1 = (Entry) i1.next();
Entry entry2 = (Entry) i2.next();
// Must split the Key and Value so that Map.Entry's equals() method is not used.
DualKey dk = new DualKey(entry1.getKey(), entry2.getKey());
if (!visited.contains(dk)) { // Push Keys for further comparison
stack.addFirst(dk);
}
dk = new DualKey(entry1.getValue(), entry2.getValue());
if (!visited.contains(dk)) { // Push values for further comparison
stack.addFirst(dk);
}
}
return true;
}
public static List<FileProps> createFileProps(Collection<String> paths){
LinkedList<FileProps> list = new LinkedList<>();
for (String path : paths) {
File file = new File(path);
if( ! file.exists()){
log.error("can't find file by path: "+path);
continue;
}
list.addFirst(new FileProps(file));
}
return list;
}
private void registerMouseBinding(boolean first, MouseEventTypeEnum mouseEventType, IMouseEventMatcher mouseEventMatcher, IMouseAction action) {
LinkedList<MouseBinding> mouseEventBindings = mouseBindingsMap.get(mouseEventType);
if (mouseEventBindings == null) {
mouseEventBindings = new LinkedList<MouseBinding>();
mouseBindingsMap.put(mouseEventType, mouseEventBindings);
}
if (first) {
mouseEventBindings.addFirst(new MouseBinding(mouseEventMatcher, action));
} else {
mouseEventBindings.addLast(new MouseBinding(mouseEventMatcher, action));
}
}
/**
* 添加配置
*
* @param generatorConfig 配置信息
* @return 1:原来文件被修改;2:已存在配置且和原来配置相同;3:新配置
*/
public int addConfig(GeneratorConfig generatorConfig) {
File configFile = BaseConstants.getConfigFile();
LinkedList<GeneratorConfig> generatorConfigs;
if (configFile.exists()) {
generatorConfigs = this.loadConfigFromFile();
} else {
generatorConfigs = new LinkedList<>();
}
LinkedList<GeneratorConfig> existConfigLinkedList = generatorConfigs.stream().filter(generatorConfig1 -> generatorConfig.getConfigName().equals(generatorConfig1.getConfigName())).collect(Lists::newLinkedList, LinkedList::add, List::addAll);
//配置已存在,如果内容修改,则修改
if (!existConfigLinkedList.isEmpty()) {
GeneratorConfig olderConfig = existConfigLinkedList.getFirst();
boolean isSame = BeanUtils.checkPropertyOfBean(generatorConfig, olderConfig);
if (!isSame) {
existConfigLinkedList.remove(olderConfig);
existConfigLinkedList.addFirst(generatorConfig);
this.downLoadConfigToFile(existConfigLinkedList);
return 1;
} else {
return 2;
}
} else {
generatorConfigs.addFirst(generatorConfig);
this.downLoadConfigToFile(generatorConfigs);
return 3;
}
}
private void registerMouseBinding(boolean first, MouseEventTypeEnum mouseEventType, IMouseEventMatcher mouseEventMatcher, IMouseAction action) {
LinkedList<MouseBinding> mouseEventBindings = mouseBindingsMap.get(mouseEventType);
if (mouseEventBindings == null) {
mouseEventBindings = new LinkedList<MouseBinding>();
mouseBindingsMap.put(mouseEventType, mouseEventBindings);
}
if (first) {
mouseEventBindings.addFirst(new MouseBinding(mouseEventMatcher, action));
} else {
mouseEventBindings.addLast(new MouseBinding(mouseEventMatcher, action));
}
}
private void loadReportletDataSource( ReportDocumentReader document,
IDocArchiveReader dataSource, String reportletBookmark )
throws EngineException, IOException
{
InstanceID reportletIid = null;
if ( document.isReporltetDocument( ) )
{
String bookmark = document.getReportletBookmark( );
if ( !reportletBookmark.equals( bookmark ) )
{
throw new EngineException(
"The user must specify the same reportlet with the one used to generate the document" );
}
reportletIid = document.getReportletInstanceID( );
}
else
{
// load the result set used by reportlet
long offset = document.getBookmarkOffset( reportletBookmark );
if ( offset == -1 )
{
throw new EngineException(
"The user specified reportlet {0} doesn''t exits in the report document",
new Object[]{reportletBookmark} );
}
ClassLoader loader = document.getClassLoader( );
RAInputStream in = dataSource
.getInputStream( ReportDocumentConstants.CONTENT_STREAM );
try
{
ReportContentReaderV3 reader = new ReportContentReaderV3(
new ReportContent( ), in, loader );
try
{
LinkedList<InstanceID> iids = new LinkedList<InstanceID>( );
while ( offset != -1 )
{
IContent content = reader.readContent( offset );
iids.addFirst( content.getInstanceID( ) );
offset = ( (DocumentExtension) content
.getExtension( IContent.DOCUMENT_EXTENSION ) )
.getParent( );
}
for ( InstanceID iid : iids )
{
if ( reportletIid == null )
{
reportletIid = iid;
}
else
{
reportletIid = new InstanceID( reportletIid, iid );
}
}
}
finally
{
reader.close( );
}
}
finally
{
in.close( );
}
}
// set the datasources
executionContext.setDataSource( new DocumentDataSource( dataSource,
reportletBookmark, reportletIid ) );
}
private void addDocs(int nDocs, int start, LinkedList<Long> versions) throws Exception {
for (int i=0; i<nDocs; i++) {
versions.addFirst( addAndGetVersion( sdoc("id",Integer.toString(start + nDocs)) , null) );
}
}
/** Assumes this is NOT a graph with cycles. Non-recursive to avoid stack overflows. */
final void setRoot() {
// Works, but can be done in one pass TODO
//
// Find first the list of nodes from this node to the current root
// and then proceed in reverse direction!
final LinkedList<Node<T>> path = new LinkedList<Node<T>>();
path.add(this);
Node<T> parent = this.parent;
while (null != parent) {
path.addFirst(parent);
parent = parent.parent;
}
Node<T> newchild = path.removeFirst();
for (final Node<T> nd : path) {
// Made nd the parent of newchild (was the opposite)
// 1 - Find out the confidence of the edge to the child node:
byte conf = MAX_EDGE_CONFIDENCE;
for (int i=0; i<newchild.children.length; i++) {
if (nd == newchild.children[i]) {
conf = newchild.children[i].confidence;
break;
}
}
// 2 - Remove the child node from the parent's child list
newchild.remove(nd);
// 3 - Reverse: add newchild to nd (newchild was parent of nd)
newchild.parent = null;
nd.add(newchild, conf);
// 4 - Prepare next step
newchild = nd;
}
// As root:
this.parent = null;
// TODO Below, it should work, but it doesn't (?)
// It results in all touched nodes not having a parent (all appear as 'S')
/*
Node child = this;
Node parent = this.parent;
while (null != parent) {
// 1 - Find out the confidence of the edge to the child node:
byte conf = MAX_EDGE_CONFIDENCE;
for (int i=0; i<parent.children.length; i++) {
if (child == parent.children[i]) {
conf = parent.children[i].confidence;
break;
}
}
// 2 - Remove the child node from the parent's child list
parent.remove(child);
// 3 - Cache the parent's parent, since it will be overwriten in the next step
Node pp = parent.parent;
// 4 - Add the parent as a child of the child, with the same edge confidence
parent.parent = null; // so it won't be refused
child.add(parent, conf);
// 5 - prepare next step
child = parent;
parent = pp;
}
// Make this node the root node
this.parent = null;
*/
}
public void updateSource(int chatId,
int contactId,
long startTimestamp,
long endTimestamp) {
DcArray locations = dcContext.getLocations(chatId, contactId, startTimestamp, endTimestamp);
MapSource contactMapMetadata = contactMapSources.get(contactId);
if (contactMapMetadata == null) {
contactMapMetadata = addContactMapSource(contactMapSources, contactId);
}
int count = locations.getCnt();
LinkedList<Feature> sortedPointFeatures = featureCollections.get(contactMapMetadata.getMarkerFeatureCollection());
if (sortedPointFeatures != null && sortedPointFeatures.size() == count) {
return;
} else {
sortedPointFeatures = new LinkedList<>();
}
LinkedList<Feature> sortedLineFeatures = new LinkedList<>();
for (int i = count - 1; i >= 0; i--) {
Point point = Point.fromLngLat(locations.getLongitude(i), locations.getLatitude(i));
String codepointChar =
locations.getMarker(i) != null ?
locations.getMarker(i) :
"";
boolean isPoi = locations.isIndependent(i);
int messageId = locations.getMsgId(i);
Feature pointFeature = Feature.fromGeometry(point, new JsonObject(), String.valueOf(locations.getLocationId(i)));
pointFeature.addBooleanProperty(MARKER_SELECTED, false);
pointFeature.addBooleanProperty(LAST_LOCATION, false);
pointFeature.addNumberProperty(CONTACT_ID, contactId);
pointFeature.addNumberProperty(TIMESTAMP, locations.getTimestamp(i));
pointFeature.addNumberProperty(MESSAGE_ID, messageId);
pointFeature.addNumberProperty(ACCURACY, locations.getAccuracy(i));
pointFeature.addStringProperty(MARKER_CHAR, codepointChar);
pointFeature.addStringProperty(MARKER_ICON, isPoi ?
contactMapMetadata.getMarkerPoi() :
contactMapMetadata.getMarkerIcon());
pointFeature.addBooleanProperty(IS_POI, isPoi);
if (isPoi && codepointChar.length() == 0 && messageId != 0) {
//has a long poi label
DcMsg poiMsg = dcContext.getMsg(messageId);
String poiLongDescription = poiMsg.getText();
pointFeature.addStringProperty(POI_LONG_DESCRIPTION, poiLongDescription);
}
sortedPointFeatures.addFirst(pointFeature);
if (!locations.isIndependent(i) && sortedPointFeatures.size() > 1) {
Point lastPoint = (Point) sortedPointFeatures.get(1).geometry();
ArrayList<Point> lineSegmentPoints = new ArrayList<>(3);
lineSegmentPoints.add(lastPoint);
lineSegmentPoints.add(point);
LineString l = LineString.fromLngLats(lineSegmentPoints);
Feature lineFeature = Feature.fromGeometry(l, new JsonObject(), "l_" + pointFeature.id());
lineFeature.addNumberProperty(TIMESTAMP, pointFeature.getNumberProperty(TIMESTAMP));
sortedLineFeatures.addFirst(lineFeature);
}
if (boundingBuilder != null) {
boundingBuilder.include(new LatLng(locations.getLatitude(i), locations.getLongitude(i)));
}
}
if (sortedPointFeatures.size() > 0) {
for (Feature position : sortedPointFeatures) {
if (!position.getBooleanProperty(IS_POI)) {
position.addStringProperty(LAST_POSITION_ICON, contactMapMetadata.getMarkerLastPositon());
position.addStringProperty(LAST_POSITION_LABEL, contactMapMetadata.getDisplayName());
position.removeProperty(MARKER_ICON);
position.addBooleanProperty(LAST_LOCATION, true);
lastPositions.put(contactId, position);
break;
}
}
}
featureCollections.put(contactMapMetadata.getMarkerFeatureCollection(), sortedPointFeatures);
featureCollections.put(contactMapMetadata.getLineFeatureCollection(), sortedLineFeatures);
}
static String generateInnerClassShortName(final IllegalIdentifierDump iid, final JavaRefTypeInstance clazz, JavaRefTypeInstance analysisType, boolean prefixAnalysisType) {
LinkedList<JavaRefTypeInstance> classStack = ListFactory.newLinkedList();
boolean analysisTypeFound = false;
if (clazz.getRawName().startsWith(analysisType.getRawName())) {
// In case we don't have full info.
// This is, at best, a guess.
String possible = clazz.getRawName().substring(analysisType.getRawName().length());
if (!possible.isEmpty()) {
switch (possible.charAt(0)) {
case '$':
case '.':
analysisTypeFound = true;
break;
}
}
}
JavaRefTypeInstance currentClass = clazz;
boolean first = true;
do {
InnerClassInfo innerClassInfo = currentClass.getInnerClassHereInfo();
// Need to skip anonymous classes, see (eg) anonymousInnerClassTest3.
if (!innerClassInfo.isAnonymousClass() || first) {
classStack.addFirst(currentClass);
}
first = false;
if (!innerClassInfo.isInnerClass()) {
break;
}
currentClass = innerClassInfo.getOuterClass();
if (currentClass.equals(analysisType)) {
analysisTypeFound = true;
break; // We don't want to go any further back than here!
}
} while (true);
/*
* Local inner class. We want the smallest postfix. We can drop the local class, but because we're not doing
* imports for local classes, we can't drop any more.
*/
if (analysisTypeFound == currentClass.equals(analysisType)) {
StringBuilder sb = new StringBuilder();
first = true;
/*
* if we've been overridden, we need to prefix the analysis type. (See ShortNameTest5)
*/
if (prefixAnalysisType) {
sb.append(analysisType.getRawShortName(iid));
first = false;
}
for (JavaRefTypeInstance stackClass : classStack) {
first = StringUtils.dot(first, sb);
sb.append(stackClass.getRawShortName(iid));
}
return sb.toString();
} else {
// string approximation.
String clazzRawName = clazz.getRawName(iid);
// Cheat using $.
String analysisTypeRawName = analysisType.getRawName(iid);
if (clazzRawName.equals(analysisTypeRawName)) {
int idx = clazzRawName.lastIndexOf('.');
if (idx >= 1 && idx < (clazzRawName.length() - 1)) {
return clazzRawName.substring(idx + 1);
}
}
if (analysisTypeRawName.length() >= (clazzRawName.length() - 1)) {
return clazzRawName;
}
return clazzRawName.substring(analysisType.getRawName().length() + 1);
}
}
/**
* 设置在线用户列表,并显示在线人数(需要在列表中排除本机用户)
* @param userInfolist 用户集
*/
public void setUserList(LinkedList<UserInfo> userInfolist) {
this.userInfoList = userInfolist;
/*
System.out.print("UserList:");
for(UserInfo user: userInfolist){
System.out.println(user.getUsername());
}
*/
//为listview数据源准备ALL所有人选项
if(!userInfolist.getFirst().equals(Utils.ALL)){
UserInfo allUser = new UserInfo(Utils.ALL,"All.png");
userInfolist.addFirst(allUser);
}
//在线用户数量
int userCount = userInfolist.size()-1;
//本机用户不需要显示
for(UserInfo user : userInfolist){
if(user.getUsername().equals(userName)){
userInfolist.remove(user);
break;//注意缺少break会出bug,因为遍历中ArrayList不可变。使用Iterator的方式也可以顺利删除和遍历。
}
}
//设置在线用户列表
Platform.runLater(() -> {
//ListView清除焦点
userListView.getSelectionModel().clearSelection();
//数据源
ObservableList<UserInfo> users = FXCollections.observableList(userInfolist);
userListView.setItems(users);
//自定义ListView
userListView.setCellFactory((ListView<UserInfo> L) -> new UsersCell());
//设置在线用户人数
userCountLabel.setText(userCount + "");
});
/**
* userListView列表项点击事件监视器
*/
userListView.getSelectionModel().selectedItemProperty().addListener(
(ObservableValue<? extends UserInfo> ov, UserInfo old_val,
UserInfo new_val) -> {
//solve bug
if(new_val == null){
otherUserNameLabel.setText("Welcome to ChatRoom");
return;
}
otherUserName = new_val.getUsername();
if(otherUserName.equals(Utils.ALL)){
otherUserNameLabel.setText("Chat with everyone..");
}else {
//System.out.println(new_val.getUsername());
otherUserNameLabel.setText("Chat with " + otherUserName +":");
}
});
}