View Javadoc
1   /*
2    * Copyright 2015 The Netty Project
3    *
4    * The Netty Project licenses this file to you under the Apache License,
5    * version 2.0 (the "License"); you may not use this file except in compliance
6    * with the License. You may obtain a copy of the License at:
7    *
8    *   http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13   * License for the specific language governing permissions and limitations
14   * under the License.
15   */
16  package io.netty.handler.codec;
17  
18  import java.util.AbstractCollection;
19  import java.util.AbstractList;
20  import java.util.Collection;
21  import java.util.Iterator;
22  import java.util.List;
23  import java.util.Map.Entry;
24  import java.util.Set;
25  
26  import static io.netty.util.internal.ObjectUtil.checkNotNull;
27  
28  /**
29   * Provides utility methods related to {@link Headers}.
30   */
31  public final class HeadersUtils {
32  
33      private HeadersUtils() {
34      }
35  
36      /**
37       * {@link Headers#get(Object)} and convert each element of {@link List} to a {@link String}.
38       * @param name the name of the header to retrieve
39       * @return a {@link List} of header values or an empty {@link List} if no values are found.
40       */
41      public static <K, V> List<String> getAllAsString(Headers<K, V, ?> headers, K name) {
42          final List<V> allNames = headers.getAll(name);
43          return new AbstractList<String>() {
44              @Override
45              public String get(int index) {
46                  V value = allNames.get(index);
47                  return value != null ? value.toString() : null;
48              }
49  
50              @Override
51              public int size() {
52                  return allNames.size();
53              }
54          };
55      }
56  
57      /**
58       * {@link Headers#get(Object)} and convert the result to a {@link String}.
59       * @param headers the headers to get the {@code name} from
60       * @param name the name of the header to retrieve
61       * @return the first header value if the header is found. {@code null} if there's no such entry.
62       */
63      public static <K, V> String getAsString(Headers<K, V, ?> headers, K name) {
64          V orig = headers.get(name);
65          return orig != null ? orig.toString() : null;
66      }
67  
68      /**
69       * {@link Headers#iterator()} which converts each {@link Entry}'s key and value to a {@link String}.
70       */
71      public static Iterator<Entry<String, String>> iteratorAsString(
72              Iterable<Entry<CharSequence, CharSequence>> headers) {
73          return new StringEntryIterator(headers.iterator());
74      }
75  
76      /**
77       * Helper for implementing toString for {@link DefaultHeaders} and wrappers such as DefaultHttpHeaders.
78       * @param headersClass the class of headers
79       * @param headersIt the iterator on the actual headers
80       * @param size the size of the iterator
81       * @return a String representation of the headers
82       */
83      public static <K, V> String toString(Class<?> headersClass, Iterator<Entry<K, V>> headersIt, int size) {
84          String simpleName = headersClass.getSimpleName();
85          if (size == 0) {
86              return simpleName + "[]";
87          } else {
88              // original capacity assumes 20 chars per headers
89              StringBuilder sb = new StringBuilder(simpleName.length() + 2 + size * 20)
90                      .append(simpleName)
91                      .append('[');
92              while (headersIt.hasNext()) {
93                  Entry<?, ?> header = headersIt.next();
94                  sb.append(header.getKey()).append(": ").append(header.getValue()).append(", ");
95              }
96              sb.setLength(sb.length() - 2);
97              return sb.append(']').toString();
98          }
99      }
100 
101     /**
102      * {@link Headers#names()} and convert each element of {@link Set} to a {@link String}.
103      * @param headers the headers to get the names from
104      * @return a {@link Set} of header values or an empty {@link Set} if no values are found.
105      */
106     public static Set<String> namesAsString(Headers<CharSequence, CharSequence, ?> headers) {
107         return new CharSequenceDelegatingStringSet(headers.names());
108     }
109 
110     private static final class StringEntryIterator implements Iterator<Entry<String, String>> {
111         private final Iterator<Entry<CharSequence, CharSequence>> iter;
112 
113         StringEntryIterator(Iterator<Entry<CharSequence, CharSequence>> iter) {
114             this.iter = iter;
115         }
116 
117         @Override
118         public boolean hasNext() {
119             return iter.hasNext();
120         }
121 
122         @Override
123         public Entry<String, String> next() {
124             return new StringEntry(iter.next());
125         }
126 
127         @Override
128         public void remove() {
129             iter.remove();
130         }
131     }
132 
133     private static final class StringEntry implements Entry<String, String> {
134         private final Entry<CharSequence, CharSequence> entry;
135         private String name;
136         private String value;
137 
138         StringEntry(Entry<CharSequence, CharSequence> entry) {
139             this.entry = entry;
140         }
141 
142         @Override
143         public String getKey() {
144             if (name == null) {
145                 name = entry.getKey().toString();
146             }
147             return name;
148         }
149 
150         @Override
151         public String getValue() {
152             if (value == null && entry.getValue() != null) {
153                 value = entry.getValue().toString();
154             }
155             return value;
156         }
157 
158         @Override
159         public String setValue(String value) {
160             String old = getValue();
161             entry.setValue(value);
162             return old;
163         }
164 
165         @Override
166         public String toString() {
167             return entry.toString();
168         }
169     }
170 
171     private static final class StringIterator<T> implements Iterator<String> {
172         private final Iterator<T> iter;
173 
174         StringIterator(Iterator<T> iter) {
175             this.iter = iter;
176         }
177 
178         @Override
179         public boolean hasNext() {
180             return iter.hasNext();
181         }
182 
183         @Override
184         public String next() {
185             T next = iter.next();
186             return next != null ? next.toString() : null;
187         }
188 
189         @Override
190         public void remove() {
191             iter.remove();
192         }
193     }
194 
195     private static final class CharSequenceDelegatingStringSet extends DelegatingStringSet<CharSequence> {
196         CharSequenceDelegatingStringSet(Set<CharSequence> allNames) {
197             super(allNames);
198         }
199 
200         @Override
201         public boolean add(String e) {
202             return allNames.add(e);
203         }
204 
205         @Override
206         public boolean addAll(Collection<? extends String> c) {
207             return allNames.addAll(c);
208         }
209     }
210 
211     private abstract static class DelegatingStringSet<T> extends AbstractCollection<String> implements Set<String> {
212         protected final Set<T> allNames;
213 
214         DelegatingStringSet(Set<T> allNames) {
215             this.allNames = checkNotNull(allNames, "allNames");
216         }
217 
218         @Override
219         public int size() {
220             return allNames.size();
221         }
222 
223         @Override
224         public boolean isEmpty() {
225             return allNames.isEmpty();
226         }
227 
228         @Override
229         public boolean contains(Object o) {
230             return allNames.contains(o.toString());
231         }
232 
233         @Override
234         public Iterator<String> iterator() {
235             return new StringIterator<T>(allNames.iterator());
236         }
237 
238         @Override
239         public boolean remove(Object o) {
240             return allNames.remove(o);
241         }
242 
243         @Override
244         public void clear() {
245             allNames.clear();
246         }
247     }
248 }