2 * Copyright (c) 2013 Big Switch Networks, Inc. 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.controller.sal.core;
10 import java.io.Serializable;
12 import java.util.UUID;
13 import java.util.concurrent.ConcurrentHashMap;
15 import javax.xml.bind.annotation.XmlAccessType;
16 import javax.xml.bind.annotation.XmlAccessorType;
17 import javax.xml.bind.annotation.XmlElement;
18 import javax.xml.bind.annotation.XmlRootElement;
21 @XmlAccessorType(XmlAccessType.NONE)
22 public class NodeTable implements Serializable {
24 private static final long serialVersionUID = 1L;
25 public static final Short SPECIALNODETABLEID = (short) 0;
28 * Enum-like static class created with the purpose of identifing
29 * multiple type of nodes in the SDN network. The type is
30 * necessary to figure out to later on correctly use the
31 * nodeTableID. Using a static class instead of an Enum so we can add
32 * dynamically new types without changing anything in the
35 public static final class NodeTableIDType {
36 private static final ConcurrentHashMap<String, Class<? extends Object>> compatibleType =
37 new ConcurrentHashMap<String, Class<? extends Object>>();
39 * These are in compliance with the compatibility types in 'Node'
41 public static String OPENFLOW = "OF";
42 public static String PCEP = "PE";
43 public static String ONEPK = "PK";
44 public static String PRODUCTION = "PR";
46 // Pre-populated types, just here for convenience and ease of
47 // unit-testing, but certainly those could live also outside.
48 // Currently we allow these 4. It can be changed later.
50 compatibleType.put(OPENFLOW, Byte.class);
51 compatibleType.put(PCEP, UUID.class);
52 compatibleType.put(ONEPK, String.class);
53 compatibleType.put(PRODUCTION, String.class);
57 * Return the type of the class expected for the
58 * NodeTableID, it's used for validity check in the constructor
60 * @param type, the type of the NodeTable for which we
61 * want to retrieve the compatible class to be used as ID.
63 * @return The Class which is supposed to instantiate the ID
66 public static Class<?> getClassType(String type) {
67 return compatibleType.get(type);
71 * Returns all the registered nodeTableIDTypes currently available
73 * @return The current registered NodeTableIDTypes
75 public static Set<String> values() {
76 return compatibleType.keySet();
80 * Register a new ID for which NodeTable can be created
82 * @param type, the new type being registered
83 * @param compatibleID, the type of class to be accepted as ID
85 * @return true if registered, false otherwise
87 public static boolean registerIDType(String type,
88 Class<? extends Object> compatibleID) {
89 if (compatibleType.get(type) != null) {
92 compatibleType.put(type, compatibleID);
98 * UNRegister a new ID for which Node can be created
100 * @param type, the type being UN-registered
103 public static void unRegisterIDType(String type) {
104 compatibleType.remove(type);
108 // Elements that constitute the NodeTable
109 private Object nodeTableID;
110 private String nodeTableType;
111 @XmlElement(name = "node")
112 private Node nodeTableNode;
114 // Helper field for JAXB
115 private String nodeTableIDString;
118 * Private constructor used for JAXB mapping
120 @SuppressWarnings("unused")
121 private NodeTable() {
122 this.nodeTableIDString = null;
123 this.nodeTableID = null;
124 this.nodeTableType = null;
125 this.nodeTableNode = null;
128 public NodeTable(String nodeTableType, Object id, Node node) throws ConstructionException {
129 if (NodeTableIDType.getClassType(nodeTableType) != null &&
130 NodeTableIDType.getClassType(nodeTableType).isInstance(id) &&
131 node.getType().equals(nodeTableType)) {
132 this.nodeTableType = nodeTableType;
133 this.nodeTableID = id;
134 this.nodeTableNode = node;
136 throw new ConstructionException("Type of incoming object:"
137 + id.getClass() + " not compatible with expected type:"
138 + NodeTableIDType.getClassType(nodeTableType)
139 + " or Node type incompatible:" + node.getType());
144 * Copy constructor for NodeTable
146 * @param src NodeTable to copy from
149 public NodeTable(NodeTable src) throws ConstructionException {
151 this.nodeTableType = src.getType();
152 // Here we can reference the object because that is
153 // supposed to be an immutable identifier as well like a
154 // UUID/Integer and so on, hence no need to create a copy
156 this.nodeTableID = src.getID();
157 this.nodeTableNode = new Node(src.getNode());
160 new ConstructionException("Null incoming object to copy from");
165 * @return the nodeTableID
167 public Object getID() {
168 return this.nodeTableID;
172 * @return the nodeTableType
174 public String getType() {
175 return this.nodeTableType;
179 * Private setter for nodeConnectorType to be called by JAXB not by anyone
180 * else, NodeConnector is immutable
182 * @param type the nodeTableType to set
184 @SuppressWarnings("unused")
185 private void setType(String type) {
186 this.nodeTableType = type;
187 if (this.nodeTableIDString != null) {
188 this.fillmeFromString(type, this.nodeTableIDString);
193 * @return the nodeTableNode
195 public Node getNode() {
196 return this.nodeTableNode;
200 * @param nodeTableNode the nodeTableNode to set
202 public void setNodeTableNode(Node nodeTableNode) {
203 this.nodeTableNode = nodeTableNode;
207 * @return the nodeTableIDString
209 @XmlElement(name = "id")
210 public String getNodeTableIDString() {
211 return this.nodeTableIDString != null? this.nodeTableIDString : nodeTableID.toString();
215 * @param nodeTableIDString the nodeTableIDString to set
217 @SuppressWarnings("unused")
218 private void setNodeTableIDString(String IDStr) {
219 this.nodeTableIDString = IDStr;
220 if (this.nodeTableType != null) {
221 this.fillmeFromString(this.nodeTableType, IDStr);
226 * fill the current object from the string parameters passed, will
227 * be only used by JAXB
229 * @param typeStr string representing the type of the Node
230 * @param IDStr String representation of the ID
232 private void fillmeFromString(String typeStr, String IDStr) {
233 if (typeStr == null) {
241 this.nodeTableType = typeStr;
242 this.nodeTableID = (byte) Byte.parseByte(IDStr);
246 public int hashCode() {
247 final int prime = 31;
249 result = prime * result
250 + ((nodeTableID == null) ? 0 : nodeTableID.hashCode());
253 + ((nodeTableNode == null) ? 0 : nodeTableNode
257 + ((nodeTableType == null) ? 0 : nodeTableType
263 public boolean equals(Object obj) {
268 if (getClass() != obj.getClass())
270 NodeTable other = (NodeTable) obj;
271 if (nodeTableID == null) {
272 if (other.nodeTableID != null)
274 } else if (!nodeTableID.equals(other.nodeTableID))
276 if (nodeTableNode == null) {
277 if (other.nodeTableNode != null)
279 } else if (!nodeTableNode.equals(other.nodeTableNode))
281 if (nodeTableType == null) {
282 if (other.nodeTableType != null)
284 } else if (!nodeTableType.equals(other.nodeTableType))
290 public String toString() {
291 return this.getNodeTableIdAsString() + "@" + this.nodeTableNode;
294 public String getNodeTableIdAsString() {
295 return this.nodeTableType + "|"
296 + this.nodeTableID.toString();