Coverage Report

Coverage Report - org.apache.commons.collections.primitives.adapters.AbstractBooleanCollectionCollection

Classes in this File

Line Coverage

Branch Coverage

Complexity

AbstractBooleanCollectionCollection

92%

25/27

100%

8/8

1.267

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.apache.commons.collections.primitives.adapters;
 
 import java.lang.reflect.Array;
 import java.util.Collection;
 import java.util.Iterator;
 
 import org.apache.commons.collections.primitives.BooleanCollection;
 
 /**
  * @since Commons Primitives 1.1
  * @version $Revision: 480462 $ $Date: 2006-11-29 03:15:00 -0500 (Wed, 29 Nov 2006) $
  */
 abstract class AbstractBooleanCollectionCollection implements Collection {
     
     public boolean add(Object element) {
         return getBooleanCollection().add(((Boolean)element).booleanValue());
     }
 
     public boolean addAll(Collection c) {
         return getBooleanCollection()
                 .addAll(CollectionBooleanCollection.wrap(c));
     }
         
     public void clear() {
         getBooleanCollection().clear();
     }
 
     public boolean contains(Object element) {
         return getBooleanCollection()
                 .contains(((Boolean)element).booleanValue());
     }
    
     
     public boolean containsAll(Collection c) {
         return getBooleanCollection().containsAll(CollectionBooleanCollection.wrap(c));
     }        
         
     public String toString() {
         return getBooleanCollection().toString();
     }
     
     public boolean isEmpty() {
         return getBooleanCollection().isEmpty();
     }
     
     /**
      * {@link BooleanIteratorIterator#wrap wraps} the
      * {@link org.apache.commons.collections.primitives.BooleanIterator
      * BooleanIterator} returned by my underlying
      * {@link org.apache.commons.collections.primitives.BooleanCollection
      * BooleanCollection}, if any.
      */
     public Iterator iterator() {
         return BooleanIteratorIterator.wrap(getBooleanCollection().iterator());
     }
      
     public boolean remove(Object element) {
         return getBooleanCollection().removeElement(
                 ((Boolean)element).booleanValue());
     }
     
     public boolean removeAll(Collection c) {
         return getBooleanCollection()
                 .removeAll(CollectionBooleanCollection.wrap(c));
     }
     
     public boolean retainAll(Collection c) {
         return getBooleanCollection().
                 retainAll(CollectionBooleanCollection.wrap(c));
     }
     
     public int size() {
         return getBooleanCollection().size();
     }
     
     public Object[] toArray() {
         boolean[] a = getBooleanCollection().toArray();
         Object[] A = new Object[a.length];
         for(int i=0;i<a.length;i++) {
             A[i] = new Boolean(a[i]);
         }
         return A;
     }
     
     public Object[] toArray(Object[] A) {
         boolean[] a = getBooleanCollection().toArray();
         if(A.length < a.length) {
             A = (Object[])(Array.newInstance(A.getClass().getComponentType(), a.length));
         }
         for(int i=0;i<a.length;i++) {
             A[i] = new Boolean(a[i]);
         }
         if(A.length > a.length) {
             A[a.length] = null;
         }
 
         return A;
     }
 
     protected abstract BooleanCollection getBooleanCollection();
 }

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.lang.reflect.Array;
20		import java.util.Collection;
21		import java.util.Iterator;
22
23		import org.apache.commons.collections.primitives.BooleanCollection;
24
25		/**
26		* @since Commons Primitives 1.1
27		* @version $Revision: 480462 $ $Date: 2006-11-29 03:15:00 -0500 (Wed, 29 Nov 2006) $
28		*/
29	457	abstract class AbstractBooleanCollectionCollection implements Collection {
30
31		public boolean add(Object element) {
32	64	return getBooleanCollection().add(((Boolean)element).booleanValue());
33		}
34
35		public boolean addAll(Collection c) {
36	262	return getBooleanCollection()
37		.addAll(CollectionBooleanCollection.wrap(c));
38		}
39
40		public void clear() {
41	4	getBooleanCollection().clear();
42	4	}
43
44		public boolean contains(Object element) {
45	306	return getBooleanCollection()
46		.contains(((Boolean)element).booleanValue());
47		}
48
49
50		public boolean containsAll(Collection c) {
51	14	return getBooleanCollection().containsAll(CollectionBooleanCollection.wrap(c));
52		}
53
54		public String toString() {
55	4	return getBooleanCollection().toString();
56		}
57
58		public boolean isEmpty() {
59	882	return getBooleanCollection().isEmpty();
60		}
61
62		/**
63		* {@link BooleanIteratorIterator#wrap wraps} the
64		* {@link org.apache.commons.collections.primitives.BooleanIterator
65		* BooleanIterator} returned by my underlying
66		* {@link org.apache.commons.collections.primitives.BooleanCollection
67		* BooleanCollection}, if any.
68		*/
69		public Iterator iterator() {
70	2663	return BooleanIteratorIterator.wrap(getBooleanCollection().iterator());
71		}
72
73		public boolean remove(Object element) {
74	102	return getBooleanCollection().removeElement(
75		((Boolean)element).booleanValue());
76		}
77
78		public boolean removeAll(Collection c) {
79	0	return getBooleanCollection()
80		.removeAll(CollectionBooleanCollection.wrap(c));
81		}
82
83		public boolean retainAll(Collection c) {
84	0	return getBooleanCollection().
85		retainAll(CollectionBooleanCollection.wrap(c));
86		}
87
88		public int size() {
89	2047	return getBooleanCollection().size();
90		}
91
92		public Object[] toArray() {
93	884	boolean[] a = getBooleanCollection().toArray();
94	884	Object[] A = new Object[a.length];
95	14417	for(int i=0;i<a.length;i++) {
96	13533	A[i] = new Boolean(a[i]);
97		}
98	884	return A;
99		}
100
101		public Object[] toArray(Object[] A) {
102	10	boolean[] a = getBooleanCollection().toArray();
103	10	if(A.length < a.length) {
104	6	A = (Object[])(Array.newInstance(A.getClass().getComponentType(), a.length));
105		}
106	72	for(int i=0;i<a.length;i++) {
107	66	A[i] = new Boolean(a[i]);
108		}
109	6	if(A.length > a.length) {
110	2	A[a.length] = null;
111		}
112
113	6	return A;
114		}
115
116		protected abstract BooleanCollection getBooleanCollection();
117		}