2 * Copyright (c) 2016 Pantheon Technologies s.r.o. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.mdsal.model.ietf.util;
10 import static com.google.common.base.Preconditions.checkArgument;
12 import com.google.common.annotations.Beta;
13 import java.util.Arrays;
14 import java.util.UUID;
15 import org.eclipse.jdt.annotation.NonNull;
16 import org.opendaylight.mdsal.binding.spec.reflect.StringValueObjectFactory;
19 * Abstract utility class for dealing with MAC addresses as defined in the ietf-yang-types model. This class is
20 * used by revision-specific classes.
22 * @param <M> mac-address type
23 * @param <P> phys-address type
26 public abstract class AbstractIetfYangUtil<M, P, H, Q, U> {
27 private static final int MAC_BYTE_LENGTH = 6;
28 private static final char[] HEX_CHARS = "0123456789abcdef".toCharArray();
29 private static final byte @NonNull[] EMPTY_BYTES = new byte[0];
30 private static final byte @NonNull[] HEX_VALUES;
33 final byte[] b = new byte['f' + 1];
34 Arrays.fill(b, (byte)-1);
36 for (char c = '0'; c <= '9'; ++c) {
37 b[c] = (byte)(c - '0');
39 for (char c = 'A'; c <= 'F'; ++c) {
40 b[c] = (byte)(c - 'A' + 10);
42 for (char c = 'a'; c <= 'f'; ++c) {
43 b[c] = (byte)(c - 'a' + 10);
49 private final StringValueObjectFactory<M> macFactory;
50 private final StringValueObjectFactory<P> physFactory;
51 private final StringValueObjectFactory<H> hexFactory;
52 private final StringValueObjectFactory<Q> quadFactory;
53 private final StringValueObjectFactory<U> uuidFactory;
55 protected AbstractIetfYangUtil(final Class<M> macClass, final Class<P> physClass, final Class<H> hexClass,
56 final Class<Q> quadClass, final Class<U> uuidClass) {
57 this.macFactory = StringValueObjectFactory.create(macClass, "00:00:00:00:00:00");
58 this.physFactory = StringValueObjectFactory.create(physClass, "00:00");
59 this.hexFactory = StringValueObjectFactory.create(hexClass, "00");
60 this.quadFactory = StringValueObjectFactory.create(quadClass, "0.0.0.0");
61 this.uuidFactory = StringValueObjectFactory.create(uuidClass, "f81d4fae-7dec-11d0-a765-00a0c91e6bf6");
65 * Convert the value of a MacAddress into the canonical representation.
67 * @param macAddress Input MAC address
68 * @return A MacAddress containing the canonical representation.
69 * @throws NullPointerException if macAddress is null
71 public final @NonNull M canonizeMacAddress(final @NonNull M macAddress) {
72 final char[] input = getValue(macAddress).toCharArray();
73 return ensureLowerCase(input) ? macFactory.newInstance(String.valueOf(input)) : macAddress;
77 * Create a MacAddress object holding the canonical representation of the 6 bytes
78 * passed in as argument.
79 * @param bytes 6-byte input array
80 * @return MacAddress with canonical string derived from input bytes
81 * @throws NullPointerException if bytes is null
82 * @throws IllegalArgumentException if length of input is not 6 bytes
84 public final @NonNull M macAddressFor(final byte @NonNull[] bytes) {
85 checkArgument(bytes.length == MAC_BYTE_LENGTH, "MAC address should have 6 bytes, not %s",
87 return macFactory.newInstance(bytesToString(bytes, 17));
90 public final byte @NonNull[] macAddressBytes(final @NonNull M macAddress) {
91 return stringToBytes(getValue(macAddress), MAC_BYTE_LENGTH);
95 * Convert the value of a PhysAddress into the canonical representation.
97 * @param physAddress Input MAC address
98 * @return A PhysAddress containing the canonical representation.
99 * @throws NullPointerException if physAddress is null
101 public final @NonNull P canonizePhysAddress(final @NonNull P physAddress) {
102 final char[] input = getPhysValue(physAddress).toCharArray();
103 return ensureLowerCase(input) ? physFactory.newInstance(String.valueOf(input)) : physAddress;
107 * Create a PhysAddress object holding the canonical representation of the bytes passed in as argument.
109 * @param bytes input array
110 * @return PhysAddress with canonical string derived from input bytes
111 * @throws NullPointerException if bytes is null
112 * @throws IllegalArgumentException if length of input is not at least 1 byte
114 public final @NonNull P physAddressFor(final byte @NonNull[] bytes) {
115 checkArgument(bytes.length > 0, "Physical address should have at least one byte");
116 return physFactory.newInstance(bytesToString(bytes, bytes.length * 3 - 1));
119 public final byte @NonNull[] physAddressBytes(final @NonNull P physAddress) {
120 final String str = getPhysValue(physAddress);
121 return str.isEmpty() ? EMPTY_BYTES : stringToBytes(str, str.length() / 3 + 1);
125 public final byte @NonNull[] bytesFor(final @NonNull M macAddress) {
126 return macAddressBytes(macAddress);
129 public final @NonNull H hexStringFor(final byte @NonNull[] bytes) {
130 checkArgument(bytes.length > 0, "Hex string should have at least one byte");
131 return hexFactory.newInstance(bytesToString(bytes, bytes.length * 3 - 1));
134 public final byte @NonNull[] hexStringBytes(final @NonNull H hexString) {
135 final String str = getHexValue(hexString);
136 return stringToBytes(str, str.length() / 3 + 1);
139 public final @NonNull Q dottedQuadFor(final byte @NonNull[] bytes) {
140 checkArgument(bytes.length == 4, "Dotted-quad should have 4 bytes");
141 return quadFactory.newInstance(AbstractIetfInetUtil.addressStringV4(bytes));
144 public final @NonNull Q dottedQuadFor(final int bits) {
145 return quadFactory.newInstance(Ipv4Utils.addressString(bits));
148 public final int dottedQuadBits(final @NonNull Q dottedQuad) {
149 final String str = getQuadValue(dottedQuad);
150 return Ipv4Utils.addressBits(str, str.length());
153 public final byte @NonNull[] dottedQuadBytes(final @NonNull Q dottedQuad) {
154 final String str = getQuadValue(dottedQuad);
155 return Ipv4Utils.addressBytes(str, str.length());
158 public final @NonNull U uuidFor(final @NonNull UUID uuid) {
159 return uuidFactory.newInstance(uuid.toString());
162 protected abstract String getValue(M macAddress);
164 protected abstract String getPhysValue(P physAddress);
166 protected abstract String getHexValue(H hexString);
168 protected abstract String getQuadValue(Q dottedQuad);
170 static byte hexValue(final char ch) {
173 // Performance optimization: access the array and rely on the VM for catching
174 // illegal access (which boils down to illegal character, which should never happen.
175 value = HEX_VALUES[ch];
176 } catch (IndexOutOfBoundsException e) {
181 throw new IllegalArgumentException("Invalid character '" + ch + "' encountered");
188 * Make sure an array of characters does not include capital letters. This method assumes input conforms to
189 * MAC address format, e.g. it is composed of 6 groups of hexadecimal digits separated by colons. Behavior is
190 * undefined if the input does not meet this criteria.
192 * @param chars Input characters, may not be null
193 * @return True if the array has been modified
194 * @throws NullPointerException if input is null
196 private static boolean ensureLowerCase(final char @NonNull[] chars) {
199 for (int i = 0; i < chars.length; ++i) {
200 final char c = chars[i];
201 if (c >= 'A' && c <= 'F') {
202 chars[i] = Character.toLowerCase(c);
211 * Convert an array of 6 bytes into canonical MAC address representation, that is 6 groups of two hexadecimal
212 * lower-case digits each, separated by colons.
214 * @param bytes Input bytes, may not be null
215 * @param charHint Hint at how many characters are needed
216 * @return Canonical MAC address string
217 * @throws NullPointerException if input is null
218 * @throws IllegalArgumentException if length of input is not 6 bytes
220 private static @NonNull String bytesToString(final byte @NonNull[] bytes, final int charHint) {
221 final StringBuilder sb = new StringBuilder(charHint);
222 appendHexByte(sb, bytes[0]);
223 for (int i = 1; i < bytes.length; ++i) {
224 appendHexByte(sb.append(':'), bytes[i]);
227 return sb.toString();
230 private static void appendHexByte(final StringBuilder sb, final byte byteVal) {
231 final int intVal = Byte.toUnsignedInt(byteVal);
232 sb.append(HEX_CHARS[intVal >>> 4]).append(HEX_CHARS[intVal & 15]);
235 private static byte @NonNull[] stringToBytes(final String str, final int length) {
236 final byte[] ret = new byte[length];
237 for (int i = 0, base = 0; i < length; ++i, base += 3) {
238 ret[i] = (byte) (hexValue(str.charAt(base)) << 4 | hexValue(str.charAt(base + 1)));