001    /*
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements.  See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache License, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License.  You may obtain a copy of the License at
008     *
009     *     http://www.apache.org/licenses/LICENSE-2.0
010     *
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the License for the specific language governing permissions and
015     * limitations under the License.
016     */
017    package org.apache.commons.collections.primitives.adapters;
018    
019    import java.util.Collection;
020    import java.util.Iterator;
021    import java.util.List;
022    import java.util.ListIterator;
023    
024    import org.apache.commons.collections.primitives.ByteCollection;
025    import org.apache.commons.collections.primitives.ByteIterator;
026    import org.apache.commons.collections.primitives.ByteList;
027    import org.apache.commons.collections.primitives.ByteListIterator;
028    import org.apache.commons.collections.primitives.CharCollection;
029    import org.apache.commons.collections.primitives.CharIterator;
030    import org.apache.commons.collections.primitives.CharList;
031    import org.apache.commons.collections.primitives.CharListIterator;
032    import org.apache.commons.collections.primitives.DoubleCollection;
033    import org.apache.commons.collections.primitives.DoubleIterator;
034    import org.apache.commons.collections.primitives.DoubleList;
035    import org.apache.commons.collections.primitives.DoubleListIterator;
036    import org.apache.commons.collections.primitives.FloatCollection;
037    import org.apache.commons.collections.primitives.FloatIterator;
038    import org.apache.commons.collections.primitives.FloatList;
039    import org.apache.commons.collections.primitives.FloatListIterator;
040    import org.apache.commons.collections.primitives.IntCollection;
041    import org.apache.commons.collections.primitives.IntIterator;
042    import org.apache.commons.collections.primitives.IntList;
043    import org.apache.commons.collections.primitives.IntListIterator;
044    import org.apache.commons.collections.primitives.LongCollection;
045    import org.apache.commons.collections.primitives.LongIterator;
046    import org.apache.commons.collections.primitives.LongList;
047    import org.apache.commons.collections.primitives.LongListIterator;
048    import org.apache.commons.collections.primitives.ShortCollection;
049    import org.apache.commons.collections.primitives.ShortIterator;
050    import org.apache.commons.collections.primitives.ShortList;
051    import org.apache.commons.collections.primitives.ShortListIterator;
052    
053    /**
054     * Convenience methods for constructing adapters.
055     *  
056     * @since Commons Primitives 1.1
057     * @version $Revision: 480462 $ $Date: 2006-11-29 09:15:00 +0100 (Wed, 29 Nov 2006) $
058     * @author Rodney Waldhoff 
059     */
060    public final class Adapt {
061        public Adapt() {
062        }
063        
064        // to object based
065        //---------------------------------------------------------------
066    
067        public static final Collection toCollection(ByteCollection c) {
068            return ByteCollectionCollection.wrap(c);
069        }
070        
071        public static final Collection toCollection(CharCollection c) {
072            return CharCollectionCollection.wrap(c);
073        }
074        
075        public static final Collection toCollection(DoubleCollection c) {
076            return DoubleCollectionCollection.wrap(c);
077        }
078        
079        public static final Collection toCollection(FloatCollection c) {
080            return FloatCollectionCollection.wrap(c);
081        }
082        
083        public static final Collection toCollection(IntCollection c) {
084            return IntCollectionCollection.wrap(c);
085        }
086        
087        public static final Collection toCollection(LongCollection c) {
088            return LongCollectionCollection.wrap(c);
089        }
090        
091        public static final Collection toCollection(ShortCollection c) {
092            return ShortCollectionCollection.wrap(c);
093        }
094    
095        public static final List toList(ByteList c) {
096            return ByteListList.wrap(c);
097        }
098        
099        public static final List toList(CharList c) {
100            return CharListList.wrap(c);
101        }
102        
103        public static final List toList(DoubleList c) {
104            return DoubleListList.wrap(c);
105        }
106        
107        public static final List toList(FloatList c) {
108            return FloatListList.wrap(c);
109        }
110        
111        public static final List toList(IntList c) {
112            return IntListList.wrap(c);
113        }
114        
115        public static final List toList(LongList c) {
116            return LongListList.wrap(c);
117        }
118        
119        public static final List toList(ShortList c) {
120            return ShortListList.wrap(c);
121        }
122    
123        public static final Iterator toIterator(ByteIterator c) {
124            return ByteIteratorIterator.wrap(c);
125        }
126        
127        public static final Iterator toIterator(CharIterator c) {
128            return CharIteratorIterator.wrap(c);
129        }
130        
131        public static final Iterator toIterator(DoubleIterator c) {
132            return DoubleIteratorIterator.wrap(c);
133        }
134        
135        public static final Iterator toIterator(FloatIterator c) {
136            return FloatIteratorIterator.wrap(c);
137        }
138        
139        public static final Iterator toIterator(IntIterator c) {
140            return IntIteratorIterator.wrap(c);
141        }
142        
143        public static final Iterator toIterator(LongIterator c) {
144            return LongIteratorIterator.wrap(c);
145        }
146        
147        public static final Iterator toIterator(ShortIterator c) {
148            return ShortIteratorIterator.wrap(c);
149        }
150    
151        public static final ListIterator toListIterator(ByteListIterator c) {
152            return ByteListIteratorListIterator.wrap(c);
153        }
154        
155        public static final ListIterator toListIterator(CharListIterator c) {
156            return CharListIteratorListIterator.wrap(c);
157        }
158        
159        public static final ListIterator toListIterator(DoubleListIterator c) {
160            return DoubleListIteratorListIterator.wrap(c);
161        }
162        
163        public static final ListIterator toListIterator(FloatListIterator c) {
164            return FloatListIteratorListIterator.wrap(c);
165        }
166        
167        public static final ListIterator toListIterator(IntListIterator c) {
168            return IntListIteratorListIterator.wrap(c);
169        }
170        
171        public static final ListIterator toListIterator(LongListIterator c) {
172            return LongListIteratorListIterator.wrap(c);
173        }
174        
175        public static final ListIterator toListIterator(ShortListIterator c) {
176            return ShortListIteratorListIterator.wrap(c);
177        }
178    
179        // to byte based
180        //---------------------------------------------------------------
181        
182        public static final ByteCollection toByteCollection(Collection c) {
183            return CollectionByteCollection.wrap(c);
184        }
185    
186        public static final ByteList toByteList(List c) {
187            return ListByteList.wrap(c);
188        }
189    
190        public static final ByteIterator toByteIterator(Iterator c) {
191            return IteratorByteIterator.wrap(c);
192        }
193    
194        public static final ByteListIterator toByteListIterator(ListIterator c) {
195            return ListIteratorByteListIterator.wrap(c);
196        }
197    
198        // to char based
199        //---------------------------------------------------------------
200        
201        public static final CharCollection toCharCollection(Collection c) {
202            return CollectionCharCollection.wrap(c);
203        }
204    
205        public static final CharList toCharList(List c) {
206            return ListCharList.wrap(c);
207        }
208    
209        public static final CharIterator toCharIterator(Iterator c) {
210            return IteratorCharIterator.wrap(c);
211        }
212    
213        public static final CharListIterator toCharListIterator(ListIterator c) {
214            return ListIteratorCharListIterator.wrap(c);
215        }
216    
217        // to double based
218        //---------------------------------------------------------------
219        
220        public static final DoubleCollection toDoubleCollection(Collection c) {
221            return CollectionDoubleCollection.wrap(c);
222        }
223    
224        public static final DoubleList toDoubleList(List c) {
225            return ListDoubleList.wrap(c);
226        }
227    
228        public static final DoubleIterator toDoubleIterator(Iterator c) {
229            return IteratorDoubleIterator.wrap(c);
230        }
231    
232        public static final DoubleListIterator toDoubleListIterator(ListIterator c) {
233            return ListIteratorDoubleListIterator.wrap(c);
234        }
235        
236        // to float based
237        //---------------------------------------------------------------
238        
239        public static final FloatCollection toFloatCollection(Collection c) {
240            return CollectionFloatCollection.wrap(c);
241        }
242    
243        public static final FloatList toFloatList(List c) {
244            return ListFloatList.wrap(c);
245        }
246    
247        public static final FloatIterator toFloatIterator(Iterator c) {
248            return IteratorFloatIterator.wrap(c);
249        }
250    
251        public static final FloatListIterator toFloatListIterator(ListIterator c) {
252            return ListIteratorFloatListIterator.wrap(c);
253        }
254        
255        // to int based
256        //---------------------------------------------------------------
257        
258        public static final IntCollection toIntCollection(Collection c) {
259            return CollectionIntCollection.wrap(c);
260        }
261    
262        public static final IntList toIntList(List c) {
263            return ListIntList.wrap(c);
264        }
265    
266        public static final IntIterator toIntIterator(Iterator c) {
267            return IteratorIntIterator.wrap(c);
268        }
269    
270        public static final IntListIterator toIntListIterator(ListIterator c) {
271            return ListIteratorIntListIterator.wrap(c);
272        }
273        
274        // to long based
275        //---------------------------------------------------------------
276        
277        public static final LongCollection toLongCollection(Collection c) {
278            return CollectionLongCollection.wrap(c);
279        }
280    
281        public static final LongList toLongList(List c) {
282            return ListLongList.wrap(c);
283        }
284    
285        public static final LongIterator toLongIterator(Iterator c) {
286            return IteratorLongIterator.wrap(c);
287        }
288    
289        public static final LongListIterator toLongListIterator(ListIterator c) {
290            return ListIteratorLongListIterator.wrap(c);
291        }
292        
293        // to short based
294        //---------------------------------------------------------------
295        
296        public static final ShortCollection toShortCollection(Collection c) {
297            return CollectionShortCollection.wrap(c);
298        }
299    
300        public static final ShortList toShortList(List c) {
301            return ListShortList.wrap(c);
302        }
303    
304        public static final ShortIterator toShortIterator(Iterator c) {
305            return IteratorShortIterator.wrap(c);
306        }
307    
308        public static final ShortListIterator toShortListIterator(ListIterator c) {
309            return ListIteratorShortListIterator.wrap(c);
310        }
311    }