1 // Protocol Buffers - Google's data interchange format 2 // Copyright 2008 Google Inc. All rights reserved. 3 // https://developers.google.com/protocol-buffers/ 4 // 5 // Redistribution and use in source and binary forms, with or without 6 // modification, are permitted provided that the following conditions are 7 // met: 8 // 9 // * Redistributions of source code must retain the above copyright 10 // notice, this list of conditions and the following disclaimer. 11 // * Redistributions in binary form must reproduce the above 12 // copyright notice, this list of conditions and the following disclaimer 13 // in the documentation and/or other materials provided with the 14 // distribution. 15 // * Neither the name of Google Inc. nor the names of its 16 // contributors may be used to endorse or promote products derived from 17 // this software without specific prior written permission. 18 // 19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31 package com.google.protobuf; 32 33 import java.util.AbstractList; 34 import java.util.Collection; 35 import java.util.Collections; 36 import java.util.Iterator; 37 import java.util.List; 38 import java.util.ListIterator; 39 import java.util.RandomAccess; 40 41 /** 42 * An implementation of {@link LazyStringList} that wraps another 43 * {@link LazyStringList} such that it cannot be modified via the wrapper. 44 * 45 * @author jonp@google.com (Jon Perlow) 46 */ 47 public class UnmodifiableLazyStringList extends AbstractList<String> 48 implements LazyStringList, RandomAccess { 49 50 private final LazyStringList list; 51 UnmodifiableLazyStringList(LazyStringList list)52 public UnmodifiableLazyStringList(LazyStringList list) { 53 this.list = list; 54 } 55 56 @Override get(int index)57 public String get(int index) { 58 return list.get(index); 59 } 60 61 @Override size()62 public int size() { 63 return list.size(); 64 } 65 66 //@Override (Java 1.6 override semantics, but we must support 1.5) getByteString(int index)67 public ByteString getByteString(int index) { 68 return list.getByteString(index); 69 } 70 71 //@Override (Java 1.6 override semantics, but we must support 1.5) add(ByteString element)72 public void add(ByteString element) { 73 throw new UnsupportedOperationException(); 74 } 75 76 //@Override (Java 1.6 override semantics, but we must support 1.5) set(int index, ByteString element)77 public void set(int index, ByteString element) { 78 throw new UnsupportedOperationException(); 79 } 80 81 //@Override (Java 1.6 override semantics, but we must support 1.5) addAllByteString(Collection<? extends ByteString> element)82 public boolean addAllByteString(Collection<? extends ByteString> element) { 83 throw new UnsupportedOperationException(); 84 } 85 86 //@Override (Java 1.6 override semantics, but we must support 1.5) getByteArray(int index)87 public byte[] getByteArray(int index) { 88 return list.getByteArray(index); 89 } 90 91 //@Override (Java 1.6 override semantics, but we must support 1.5) add(byte[] element)92 public void add(byte[] element) { 93 throw new UnsupportedOperationException(); 94 } 95 96 //@Override (Java 1.6 override semantics, but we must support 1.5) set(int index, byte[] element)97 public void set(int index, byte[] element) { 98 throw new UnsupportedOperationException(); 99 } 100 101 //@Override (Java 1.6 override semantics, but we must support 1.5) addAllByteArray(Collection<byte[]> element)102 public boolean addAllByteArray(Collection<byte[]> element) { 103 throw new UnsupportedOperationException(); 104 } 105 106 @Override listIterator(final int index)107 public ListIterator<String> listIterator(final int index) { 108 return new ListIterator<String>() { 109 ListIterator<String> iter = list.listIterator(index); 110 111 //@Override (Java 1.6 override semantics, but we must support 1.5) 112 public boolean hasNext() { 113 return iter.hasNext(); 114 } 115 116 //@Override (Java 1.6 override semantics, but we must support 1.5) 117 public String next() { 118 return iter.next(); 119 } 120 121 //@Override (Java 1.6 override semantics, but we must support 1.5) 122 public boolean hasPrevious() { 123 return iter.hasPrevious(); 124 } 125 126 //@Override (Java 1.6 override semantics, but we must support 1.5) 127 public String previous() { 128 return iter.previous(); 129 } 130 131 //@Override (Java 1.6 override semantics, but we must support 1.5) 132 public int nextIndex() { 133 return iter.nextIndex(); 134 } 135 136 //@Override (Java 1.6 override semantics, but we must support 1.5) 137 public int previousIndex() { 138 return iter.previousIndex(); 139 } 140 141 //@Override (Java 1.6 override semantics, but we must support 1.5) 142 public void remove() { 143 throw new UnsupportedOperationException(); 144 } 145 146 //@Override (Java 1.6 override semantics, but we must support 1.5) 147 public void set(String o) { 148 throw new UnsupportedOperationException(); 149 } 150 151 //@Override (Java 1.6 override semantics, but we must support 1.5) 152 public void add(String o) { 153 throw new UnsupportedOperationException(); 154 } 155 }; 156 } 157 158 @Override iterator()159 public Iterator<String> iterator() { 160 return new Iterator<String>() { 161 Iterator<String> iter = list.iterator(); 162 163 //@Override (Java 1.6 override semantics, but we must support 1.5) 164 public boolean hasNext() { 165 return iter.hasNext(); 166 } 167 168 //@Override (Java 1.6 override semantics, but we must support 1.5) 169 public String next() { 170 return iter.next(); 171 } 172 173 //@Override (Java 1.6 override semantics, but we must support 1.5) 174 public void remove() { 175 throw new UnsupportedOperationException(); 176 } 177 }; 178 } 179 180 //@Override (Java 1.6 override semantics, but we must support 1.5) 181 public List<?> getUnderlyingElements() { 182 // The returned value is already unmodifiable. 183 return list.getUnderlyingElements(); 184 } 185 186 //@Override (Java 1.6 override semantics, but we must support 1.5) 187 public void mergeFrom(LazyStringList other) { 188 throw new UnsupportedOperationException(); 189 } 190 191 //@Override (Java 1.6 override semantics, but we must support 1.5) 192 public List<byte[]> asByteArrayList() { 193 return Collections.unmodifiableList(list.asByteArrayList()); 194 } 195 196 //@Override (Java 1.6 override semantics, but we must support 1.5) 197 public List<ByteString> asByteStringList() { 198 return Collections.unmodifiableList(list.asByteStringList()); 199 } 200 201 //@Override (Java 1.6 override semantics, but we must support 1.5) 202 public LazyStringList getUnmodifiableView() { 203 return this; 204 } 205 } 206