1 /*
   2  * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
   3  */
   4 /*
   5  * Licensed to the Apache Software Foundation (ASF) under one or more
   6  * contributor license agreements.  See the NOTICE file distributed with
   7  * this work for additional information regarding copyright ownership.
   8  * The ASF licenses this file to You under the Apache License, Version 2.0
   9  * (the "License"); you may not use this file except in compliance with
  10  * the License.  You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20 
  21 package com.sun.org.apache.xerces.internal.impl.xs.util;
  22 
  23 import com.sun.org.apache.xerces.internal.xs.StringList;
  24 import java.lang.reflect.Array;
  25 import java.util.AbstractList;
  26 import java.util.List;
  27 
  28 /**
  29  * Containts a list of Object's.
  30  *
  31  * @xerces.internal
  32  *
  33  * @author Sandy Gao, IBM
  34  *
  35  * @LastModified: Oct 2017
  36  */
  37 @SuppressWarnings("unchecked") // method <T>toArray(T[])
  38 public final class StringListImpl extends AbstractList<String> implements StringList {
  39 
  40     /**
  41      * An immutable empty list.
  42      */
  43     public static final StringListImpl EMPTY_LIST = new StringListImpl(new String[0], 0);
  44 
  45     // The array to hold all data
  46     private final String[] fArray;
  47     // Number of elements in this list
  48     private final int fLength;
  49 
  50     // REVISIT: this is temp solution. In general we need to use this class
  51     //          instead of the Vector.
  52     private final List<String> fVector;
  53 
  54     public StringListImpl(List<String> v) {
  55         fVector = v;
  56         fLength = (v == null) ? 0 : v.size();
  57         fArray = null;
  58     }
  59 
  60     /**
  61      * Construct an XSObjectList implementation
  62      *
  63      * @param array     the data array
  64      * @param length    the number of elements
  65      */
  66     public StringListImpl(String[] array, int length) {
  67         fArray = array;
  68         fLength = length;
  69         fVector = null;
  70     }
  71 
  72     /**
  73      * The number of <code>Objects</code> in the list. The range of valid
  74      * child node indices is 0 to <code>length-1</code> inclusive.
  75      */
  76     public int getLength() {
  77         return fLength;
  78     }
  79 
  80     /**
  81      *  Checks if the <code>GenericString</code> <code>item</code> is a member
  82      * of this list.
  83      * @param item  <code>GenericString</code> whose presence in this list is
  84      *   to be tested.
  85      * @return  True if this list contains the <code>GenericString</code>
  86      *   <code>item</code>.
  87      */
  88     public boolean contains(String item) {
  89         if (fVector != null) {
  90             return fVector.contains(item);
  91         }
  92         if (item == null) {
  93             for (int i = 0; i < fLength; i++) {
  94                 if (fArray[i] == null)
  95                     return true;
  96             }
  97         }
  98         else {
  99             for (int i = 0; i < fLength; i++) {
 100                 if (item.equals(fArray[i]))
 101                     return true;
 102             }
 103         }
 104         return false;
 105     }
 106 
 107     public String item(int index) {
 108         if (index < 0 || index >= fLength) {
 109             return null;
 110         }
 111         if (fVector != null) {
 112             return fVector.get(index);
 113         }
 114         return fArray[index];
 115     }
 116 
 117     /*
 118      * List methods
 119      */
 120 
 121     public String get(int index) {
 122         if (index >= 0 && index < fLength) {
 123             if (fVector != null) {
 124                 return fVector.get(index);
 125             }
 126             return fArray[index];
 127         }
 128         throw new IndexOutOfBoundsException("Index: " + index);
 129     }
 130 
 131     public int size() {
 132         return getLength();
 133     }
 134 
 135     public Object[] toArray() {
 136         if (fVector != null) {
 137             return fVector.toArray();
 138         }
 139         Object[] a = new Object[fLength];
 140         toArray0(a);
 141         return a;
 142     }
 143 
 144     public Object[] toArray(Object[] a) {
 145         if (fVector != null) {
 146             return fVector.toArray(a);
 147         }
 148         if (a.length < fLength) {
 149             Class<?> arrayClass = a.getClass();
 150             Class<?> componentType = arrayClass.getComponentType();
 151             a = (Object[]) Array.newInstance(componentType, fLength);
 152         }
 153         toArray0(a);
 154         if (a.length > fLength) {
 155             a[fLength] = null;
 156         }
 157         return a;
 158     }
 159 
 160     private void toArray0(Object[] a) {
 161         if (fLength > 0) {
 162             System.arraycopy(fArray, 0, a, 0, fLength);
 163         }
 164     }
 165 
 166 } // class StringListImpl