d8144572a4de24d3e45309bfdec55f3dbf45cd00
[idea/community.git] / platform / util / src / com / intellij / util / CommonProcessors.java
1 /*
2  * Copyright 2000-2009 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.util;
17
18 import gnu.trove.THashSet;
19 import gnu.trove.TObjectHashingStrategy;
20 import org.jetbrains.annotations.NotNull;
21
22 import java.util.ArrayList;
23 import java.util.Collection;
24 import java.util.HashSet;
25 import java.util.Set;
26
27 /**
28  * @author max
29  */
30 public class CommonProcessors {
31   public static class CollectProcessor<T> implements Processor<T> {
32     private final Collection<T> myCollection;
33
34     public CollectProcessor(Collection<T> collection) {
35       myCollection = collection;
36     }
37
38     public CollectProcessor() {
39       myCollection = new ArrayList<T>();
40     }
41
42     public boolean process(T t) {
43       myCollection.add(t);
44       return true;
45     }
46
47     public T[] toArray(T[] a) {
48       return myCollection.toArray(a);
49     }
50
51     public Collection<T> getResults() {
52       return myCollection;
53     }
54   }
55
56   @NotNull
57   public static <T> Processor<T> notNullProcessor(@NotNull final Processor<T> processor) {
58     return new Processor<T>() {
59       public boolean process(@NotNull T t) {
60         return processor.process(t);
61       }
62     };
63   }
64
65
66   public static class CollectUniquesProcessor<T> implements Processor<T> {
67     private final Set<T> myCollection;
68
69     public CollectUniquesProcessor() {
70       myCollection = new HashSet<T>();
71     }
72
73     public boolean process(T t) {
74       myCollection.add(t);
75       return true;
76     }
77
78     public T[] toArray(T[] a) {
79       return myCollection.toArray(a);
80     }
81
82     public Collection<T> getResults() {
83       return myCollection;
84     }
85   }
86   public static class UniqueProcessor<T> implements Processor<T> {
87     private final Set<T> processed;
88     private final Processor<T> myDelegate;
89
90     public UniqueProcessor(Processor<T> delegate) {
91       this(delegate, TObjectHashingStrategy.CANONICAL);
92     }
93     public UniqueProcessor(Processor<T> delegate, TObjectHashingStrategy<T> strategy) {
94       myDelegate = delegate;
95       processed = new THashSet<T>(strategy);
96     }
97
98     public boolean process(T t) {
99       synchronized (processed) {
100         if (!processed.add(t)) {
101           return true;
102         }
103       }
104       return myDelegate.process(t);
105     }
106   }
107
108   public static class FindFirstProcessor<T> implements Processor<T> {
109     private T myValue = null;
110
111     public boolean isFound() {
112       return myValue != null;
113     }
114
115     public T getFoundValue() {
116       return myValue;
117     }
118
119     public boolean process(T t) {
120       myValue = t;
121       return false;
122     }
123   }
124
125   private static final Processor FALSE = new Processor<Object>() {
126     public boolean process(Object t) {
127       return false;
128     }
129   };
130
131   @SuppressWarnings({"unchecked"})
132   public static <T> Processor<T> alwaysFalse() {
133     return FALSE;
134   }
135 }