Coverage Report - org.apache.shiro.util.CollectionUtils
 
Classes in this File Line Coverage Branch Coverage Complexity
CollectionUtils
77%
14/18
66%
16/24
2.375
 
 1   
 /*
 2   
  * Licensed to the Apache Software Foundation (ASF) under one
 3   
  * or more contributor license agreements.  See the NOTICE file
 4   
  * distributed with this work for additional information
 5   
  * regarding copyright ownership.  The ASF licenses this file
 6   
  * to you under the Apache License, Version 2.0 (the
 7   
  * "License"); you may not use this file except in compliance
 8   
  * with the License.  You may obtain a copy of the License at
 9   
  *
 10   
  *     http://www.apache.org/licenses/LICENSE-2.0
 11   
  *
 12   
  * Unless required by applicable law or agreed to in writing,
 13   
  * software distributed under the License is distributed on an
 14   
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 15   
  * KIND, either express or implied.  See the License for the
 16   
  * specific language governing permissions and limitations
 17   
  * under the License.
 18   
  */
 19   
 package org.apache.shiro.util;
 20   
 
 21   
 import org.apache.shiro.subject.PrincipalCollection;
 22   
 
 23   
 import java.util.*;
 24   
 
 25   
 /**
 26   
  * Static helper class for use dealing with Collections.
 27   
  *
 28   
  * @since 0.9
 29   
  */
 30  0 
 public class CollectionUtils {
 31   
 
 32   
     //TODO - complete JavaDoc
 33   
 
 34   
     public static <E> Set<E> asSet(E... elements) {
 35  408 
         if (elements == null || elements.length == 0) {
 36  2 
             return Collections.emptySet();
 37   
         }
 38  406 
         LinkedHashSet<E> set = new LinkedHashSet<E>(elements.length * 4 / 3 + 1);
 39  406 
         Collections.addAll(set, elements);
 40  406 
         return set;
 41   
     }
 42   
 
 43   
     /**
 44   
      * Returns {@code true} if the specified {@code Collection} is {@code null} or {@link Collection#isEmpty empty},
 45   
      * {@code false} otherwise.
 46   
      *
 47   
      * @param c the collection to check
 48   
      * @return {@code true} if the specified {@code Collection} is {@code null} or {@link Collection#isEmpty empty},
 49   
      *         {@code false} otherwise.
 50   
      * @since 1.0
 51   
      */
 52   
     public static boolean isEmpty(Collection c) {
 53  846 
         return c == null || c.isEmpty();
 54   
     }
 55   
 
 56   
     /**
 57   
      * Returns {@code true} if the specified {@code Map} is {@code null} or {@link Map#isEmpty empty},
 58   
      * {@code false} otherwise.
 59   
      *
 60   
      * @param m the {@code Map} to check
 61   
      * @return {@code true} if the specified {@code Map} is {@code null} or {@link Map#isEmpty empty},
 62   
      *         {@code false} otherwise.
 63   
      * @since 1.0
 64   
      */
 65   
     public static boolean isEmpty(Map m) {
 66  732 
         return m == null || m.isEmpty();
 67   
     }
 68   
 
 69   
     /**
 70   
      * Returns the size of the specified collection or {@code 0} if the collection is {@code null}.
 71   
      *
 72   
      * @param c the collection to check
 73   
      * @return the size of the specified collection or {@code 0} if the collection is {@code null}.
 74   
      * @since 1.2
 75   
      */
 76   
     public static int size(Collection c) {
 77  0 
         return c != null ? c.size() : 0;
 78   
     }
 79   
 
 80   
     /**
 81   
      * Returns the size of the specified map or {@code 0} if the map is {@code null}.
 82   
      *
 83   
      * @param m the map to check
 84   
      * @return the size of the specified map or {@code 0} if the map is {@code null}.
 85   
      * @since 1.2
 86   
      */
 87   
     public static int size(Map m) {
 88  0 
         return m != null ? m.size() : 0;
 89   
     }
 90   
 
 91   
 
 92   
     /**
 93   
      * Returns {@code true} if the specified {@code PrincipalCollection} is {@code null} or
 94   
      * {@link PrincipalCollection#isEmpty empty}, {@code false} otherwise.
 95   
      *
 96   
      * @param principals the principals to check.
 97   
      * @return {@code true} if the specified {@code PrincipalCollection} is {@code null} or
 98   
      *         {@link PrincipalCollection#isEmpty empty}, {@code false} otherwise.
 99   
      * @since 1.0
 100   
      */
 101   
     public static boolean isEmpty(PrincipalCollection principals) {
 102  1086 
         return principals == null || principals.isEmpty();
 103   
     }
 104   
 
 105   
     public static <E> List<E> asList(E... elements) {
 106  224 
         if (elements == null || elements.length == 0) {
 107  0 
             return Collections.emptyList();
 108   
         }
 109   
         // Avoid integer overflow when a large array is passed in
 110  224 
         int capacity = computeListCapacity(elements.length);
 111  224 
         ArrayList<E> list = new ArrayList<E>(capacity);
 112  224 
         Collections.addAll(list, elements);
 113  224 
         return list;
 114   
     }
 115   
 
 116   
     /*public static <E> Deque<E> asDeque(E... elements) {
 117   
         if (elements == null || elements.length == 0) {
 118   
             return new ArrayDeque<E>();
 119   
         }
 120   
         // Avoid integer overflow when a large array is passed in
 121   
         int capacity = computeListCapacity(elements.length);
 122   
         ArrayDeque<E> deque = new ArrayDeque<E>(capacity);
 123   
         Collections.addAll(deque, elements);
 124   
         return deque;
 125   
     }*/
 126   
 
 127   
     static int computeListCapacity(int arraySize) {
 128  224 
         return (int) Math.min(5L + arraySize + (arraySize / 10), Integer.MAX_VALUE);
 129   
     }
 130   
 }
Report generated by Cobertura 1.9.4.1 on 7/5/16 10:56 AM.