Coverage Report - org.apache.commons.collections.primitives.adapters.Adapt
 
Classes in this File Line Coverage Branch Coverage Complexity
Adapt
100%
58/58
N/A
N/A
1
 
 1   
 /*
 2   
  * Licensed to the Apache Software Foundation (ASF) under one or more
 3   
  * contributor license agreements.  See the NOTICE file distributed with
 4   
  * this work for additional information regarding copyright ownership.
 5   
  * The ASF licenses this file to You under the Apache License, Version 2.0
 6   
  * (the "License"); you may not use this file except in compliance with
 7   
  * the License.  You may obtain a copy of the License at
 8   
  *
 9   
  *     http://www.apache.org/licenses/LICENSE-2.0
 10   
  *
 11   
  * Unless required by applicable law or agreed to in writing, software
 12   
  * distributed under the License is distributed on an "AS IS" BASIS,
 13   
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 14   
  * See the License for the specific language governing permissions and
 15   
  * limitations under the License.
 16   
  */
 17   
 package org.apache.commons.collections.primitives.adapters;
 18   
 
 19   
 import java.util.Collection;
 20   
 import java.util.Iterator;
 21   
 import java.util.List;
 22   
 import java.util.ListIterator;
 23   
 
 24   
 import org.apache.commons.collections.primitives.ByteCollection;
 25   
 import org.apache.commons.collections.primitives.ByteIterator;
 26   
 import org.apache.commons.collections.primitives.ByteList;
 27   
 import org.apache.commons.collections.primitives.ByteListIterator;
 28   
 import org.apache.commons.collections.primitives.CharCollection;
 29   
 import org.apache.commons.collections.primitives.CharIterator;
 30   
 import org.apache.commons.collections.primitives.CharList;
 31   
 import org.apache.commons.collections.primitives.CharListIterator;
 32   
 import org.apache.commons.collections.primitives.DoubleCollection;
 33   
 import org.apache.commons.collections.primitives.DoubleIterator;
 34   
 import org.apache.commons.collections.primitives.DoubleList;
 35   
 import org.apache.commons.collections.primitives.DoubleListIterator;
 36   
 import org.apache.commons.collections.primitives.FloatCollection;
 37   
 import org.apache.commons.collections.primitives.FloatIterator;
 38   
 import org.apache.commons.collections.primitives.FloatList;
 39   
 import org.apache.commons.collections.primitives.FloatListIterator;
 40   
 import org.apache.commons.collections.primitives.IntCollection;
 41   
 import org.apache.commons.collections.primitives.IntIterator;
 42   
 import org.apache.commons.collections.primitives.IntList;
 43   
 import org.apache.commons.collections.primitives.IntListIterator;
 44   
 import org.apache.commons.collections.primitives.LongCollection;
 45   
 import org.apache.commons.collections.primitives.LongIterator;
 46   
 import org.apache.commons.collections.primitives.LongList;
 47   
 import org.apache.commons.collections.primitives.LongListIterator;
 48   
 import org.apache.commons.collections.primitives.ShortCollection;
 49   
 import org.apache.commons.collections.primitives.ShortIterator;
 50   
 import org.apache.commons.collections.primitives.ShortList;
 51   
 import org.apache.commons.collections.primitives.ShortListIterator;
 52   
 
 53   
 /**
 54   
  * Convenience methods for constructing adapters.
 55   
  *
 56   
  * @since Commons Primitives 1.1
 57   
  * @version $Revision: 480462 $ $Date: 2006-11-29 03:15:00 -0500 (Wed, 29 Nov 2006) $
 58   
  * @author Rodney Waldhoff
 59   
  */
 60   
 public final class Adapt {
 61  1 
     public Adapt() {
 62  1 
     }
 63   
 
 64   
     // to object based
 65   
     //---------------------------------------------------------------
 66   
 
 67   
     public static final Collection toCollection(ByteCollection c) {
 68  2 
         return ByteCollectionCollection.wrap(c);
 69   
     }
 70   
 
 71   
     public static final Collection toCollection(CharCollection c) {
 72  2 
         return CharCollectionCollection.wrap(c);
 73   
     }
 74   
 
 75   
     public static final Collection toCollection(DoubleCollection c) {
 76  2 
         return DoubleCollectionCollection.wrap(c);
 77   
     }
 78   
 
 79   
     public static final Collection toCollection(FloatCollection c) {
 80  2 
         return FloatCollectionCollection.wrap(c);
 81   
     }
 82   
 
 83   
     public static final Collection toCollection(IntCollection c) {
 84  2 
         return IntCollectionCollection.wrap(c);
 85   
     }
 86   
 
 87   
     public static final Collection toCollection(LongCollection c) {
 88  2 
         return LongCollectionCollection.wrap(c);
 89   
     }
 90   
 
 91   
     public static final Collection toCollection(ShortCollection c) {
 92  2 
         return ShortCollectionCollection.wrap(c);
 93   
     }
 94   
 
 95   
     public static final List toList(ByteList c) {
 96  2 
         return ByteListList.wrap(c);
 97   
     }
 98   
 
 99   
     public static final List toList(CharList c) {
 100  2 
         return CharListList.wrap(c);
 101   
     }
 102   
 
 103   
     public static final List toList(DoubleList c) {
 104  2 
         return DoubleListList.wrap(c);
 105   
     }
 106   
 
 107   
     public static final List toList(FloatList c) {
 108  2 
         return FloatListList.wrap(c);
 109   
     }
 110   
 
 111   
     public static final List toList(IntList c) {
 112  2 
         return IntListList.wrap(c);
 113   
     }
 114   
 
 115   
     public static final List toList(LongList c) {
 116  2 
         return LongListList.wrap(c);
 117   
     }
 118   
 
 119   
     public static final List toList(ShortList c) {
 120  2 
         return ShortListList.wrap(c);
 121   
     }
 122   
 
 123   
     public static final Iterator toIterator(ByteIterator c) {
 124  2 
         return ByteIteratorIterator.wrap(c);
 125   
     }
 126   
 
 127   
     public static final Iterator toIterator(CharIterator c) {
 128  2 
         return CharIteratorIterator.wrap(c);
 129   
     }
 130   
 
 131   
     public static final Iterator toIterator(DoubleIterator c) {
 132  2 
         return DoubleIteratorIterator.wrap(c);
 133   
     }
 134   
 
 135   
     public static final Iterator toIterator(FloatIterator c) {
 136  2 
         return FloatIteratorIterator.wrap(c);
 137   
     }
 138   
 
 139   
     public static final Iterator toIterator(IntIterator c) {
 140  2 
         return IntIteratorIterator.wrap(c);
 141   
     }
 142   
 
 143   
     public static final Iterator toIterator(LongIterator c) {
 144  2 
         return LongIteratorIterator.wrap(c);
 145   
     }
 146   
 
 147   
     public static final Iterator toIterator(ShortIterator c) {
 148  2 
         return ShortIteratorIterator.wrap(c);
 149   
     }
 150   
 
 151   
     public static final ListIterator toListIterator(ByteListIterator c) {
 152  2 
         return ByteListIteratorListIterator.wrap(c);
 153   
     }
 154   
 
 155   
     public static final ListIterator toListIterator(CharListIterator c) {
 156  2 
         return CharListIteratorListIterator.wrap(c);
 157   
     }
 158   
 
 159   
     public static final ListIterator toListIterator(DoubleListIterator c) {
 160  2 
         return DoubleListIteratorListIterator.wrap(c);
 161   
     }
 162   
 
 163   
     public static final ListIterator toListIterator(FloatListIterator c) {
 164  2 
         return FloatListIteratorListIterator.wrap(c);
 165   
     }
 166   
 
 167   
     public static final ListIterator toListIterator(IntListIterator c) {
 168  2 
         return IntListIteratorListIterator.wrap(c);
 169   
     }
 170   
 
 171   
     public static final ListIterator toListIterator(LongListIterator c) {
 172  2 
         return LongListIteratorListIterator.wrap(c);
 173   
     }
 174   
 
 175   
     public static final ListIterator toListIterator(ShortListIterator c) {
 176  2 
         return ShortListIteratorListIterator.wrap(c);
 177   
     }
 178   
 
 179   
     // to byte based
 180   
     //---------------------------------------------------------------
 181   
 
 182   
     public static final ByteCollection toByteCollection(Collection c) {
 183  2 
         return CollectionByteCollection.wrap(c);
 184   
     }
 185   
 
 186   
     public static final ByteList toByteList(List c) {
 187  2 
         return ListByteList.wrap(c);
 188   
     }
 189   
 
 190   
     public static final ByteIterator toByteIterator(Iterator c) {
 191  2 
         return IteratorByteIterator.wrap(c);
 192   
     }
 193   
 
 194   
     public static final ByteListIterator toByteListIterator(ListIterator c) {
 195  2 
         return ListIteratorByteListIterator.wrap(c);
 196   
     }
 197   
 
 198   
     // to char based
 199   
     //---------------------------------------------------------------
 200   
 
 201   
     public static final CharCollection toCharCollection(Collection c) {
 202  2 
         return CollectionCharCollection.wrap(c);
 203   
     }
 204   
 
 205   
     public static final CharList toCharList(List c) {
 206  2 
         return ListCharList.wrap(c);
 207   
     }
 208   
 
 209   
     public static final CharIterator toCharIterator(Iterator c) {
 210  2 
         return IteratorCharIterator.wrap(c);
 211   
     }
 212   
 
 213   
     public static final CharListIterator toCharListIterator(ListIterator c) {
 214  2 
         return ListIteratorCharListIterator.wrap(c);
 215   
     }
 216   
 
 217   
     // to double based
 218   
     //---------------------------------------------------------------
 219   
 
 220   
     public static final DoubleCollection toDoubleCollection(Collection c) {
 221  2 
         return CollectionDoubleCollection.wrap(c);
 222   
     }
 223   
 
 224   
     public static final DoubleList toDoubleList(List c) {
 225  2 
         return ListDoubleList.wrap(c);
 226   
     }
 227   
 
 228   
     public static final DoubleIterator toDoubleIterator(Iterator c) {
 229  2 
         return IteratorDoubleIterator.wrap(c);
 230   
     }
 231   
 
 232   
     public static final DoubleListIterator toDoubleListIterator(ListIterator c) {
 233  2 
         return ListIteratorDoubleListIterator.wrap(c);
 234   
     }
 235   
 
 236   
     // to float based
 237   
     //---------------------------------------------------------------
 238   
 
 239   
     public static final FloatCollection toFloatCollection(Collection c) {
 240  2 
         return CollectionFloatCollection.wrap(c);
 241   
     }
 242   
 
 243   
     public static final FloatList toFloatList(List c) {
 244  2 
         return ListFloatList.wrap(c);
 245   
     }
 246   
 
 247   
     public static final FloatIterator toFloatIterator(Iterator c) {
 248  2 
         return IteratorFloatIterator.wrap(c);
 249   
     }
 250   
 
 251   
     public static final FloatListIterator toFloatListIterator(ListIterator c) {
 252  2 
         return ListIteratorFloatListIterator.wrap(c);
 253   
     }
 254   
 
 255   
     // to int based
 256   
     //---------------------------------------------------------------
 257   
 
 258   
     public static final IntCollection toIntCollection(Collection c) {
 259  2 
         return CollectionIntCollection.wrap(c);
 260   
     }
 261   
 
 262   
     public static final IntList toIntList(List c) {
 263  2 
         return ListIntList.wrap(c);
 264   
     }
 265   
 
 266   
     public static final IntIterator toIntIterator(Iterator c) {
 267  2 
         return IteratorIntIterator.wrap(c);
 268   
     }
 269   
 
 270   
     public static final IntListIterator toIntListIterator(ListIterator c) {
 271  2 
         return ListIteratorIntListIterator.wrap(c);
 272   
     }
 273   
 
 274   
     // to long based
 275   
     //---------------------------------------------------------------
 276   
 
 277   
     public static final LongCollection toLongCollection(Collection c) {
 278  2 
         return CollectionLongCollection.wrap(c);
 279   
     }
 280   
 
 281   
     public static final LongList toLongList(List c) {
 282  2 
         return ListLongList.wrap(c);
 283   
     }
 284   
 
 285   
     public static final LongIterator toLongIterator(Iterator c) {
 286  2 
         return IteratorLongIterator.wrap(c);
 287   
     }
 288   
 
 289   
     public static final LongListIterator toLongListIterator(ListIterator c) {
 290  2 
         return ListIteratorLongListIterator.wrap(c);
 291   
     }
 292   
 
 293   
     // to short based
 294   
     //---------------------------------------------------------------
 295   
 
 296   
     public static final ShortCollection toShortCollection(Collection c) {
 297  2 
         return CollectionShortCollection.wrap(c);
 298   
     }
 299   
 
 300   
     public static final ShortList toShortList(List c) {
 301  2 
         return ListShortList.wrap(c);
 302   
     }
 303   
 
 304   
     public static final ShortIterator toShortIterator(Iterator c) {
 305  2 
         return IteratorShortIterator.wrap(c);
 306   
     }
 307   
 
 308   
     public static final ShortListIterator toShortListIterator(ListIterator c) {
 309  2 
         return ListIteratorShortListIterator.wrap(c);
 310   
     }
 311   
 }
Report generated by Cobertura 1.9.4.1 on 2/26/13 6:23 PM.