opendaylight/sal/api/src/main/java/org/opendaylight/controller/sal/core/NodeTable.java

   1 /*
   2  * Copyright (c) 2013 Big Switch Networks, Inc.  All rights reserved.
   3  *
   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
   7  */
   8 package org.opendaylight.controller.sal.core;
   9
  10 import java.io.Serializable;
  11 import java.util.Set;
  12 import java.util.UUID;
  13 import java.util.concurrent.ConcurrentHashMap;
  14
  15 import javax.xml.bind.annotation.XmlAccessType;
  16 import javax.xml.bind.annotation.XmlAccessorType;
  17 import javax.xml.bind.annotation.XmlAttribute;
  18 import javax.xml.bind.annotation.XmlElement;
  19 import javax.xml.bind.annotation.XmlRootElement;
  20
  21 @XmlRootElement
  22 @XmlAccessorType(XmlAccessType.NONE)
  23 public class NodeTable implements Serializable {
  24
  25     private static final long serialVersionUID = 1L;
  26     public static final Short SPECIALNODETABLEID = (short) 0;
  27
  28     /**
  29      * Enum-like static class created with the purpose of identifing
  30      * multiple type of nodes in the SDN network. The type is
  31      * necessary to figure out to later on correctly use the
  32      * nodeTableID. Using a static class instead of an Enum so we can add
  33      * dynamically new types without changing anything in the
  34      * surround.
  35      */
  36     public static final class NodeTableIDType {
  37         private static final ConcurrentHashMap<String, Class<? extends Object>> compatibleType =
  38                 new ConcurrentHashMap<String, Class<? extends Object>>();
  39         /**
  40          * These are in compliance with the compatibility types in 'Node'
  41          */
  42         public static String OPENFLOW = "OF";
  43         public static String PCEP = "PE";
  44         public static String ONEPK = "PK";
  45         public static String PRODUCTION = "PR";
  46
  47         // Pre-populated types, just here for convenience and ease of
  48         // unit-testing, but certainly those could live also outside.
  49         // Currently we allow these 4. It can be changed later.
  50         static {
  51             compatibleType.put(OPENFLOW, Byte.class);
  52             compatibleType.put(PCEP, UUID.class);
  53             compatibleType.put(ONEPK, String.class);
  54             compatibleType.put(PRODUCTION, String.class);
  55         }
  56
  57         /**
  58          * Return the type of the class expected for the
  59          * NodeTableID, it's used for validity check in the constructor
  60          *
  61          * @param type, the type of the NodeTable for which we
  62          * want to retrieve the compatible class to be used as ID.
  63          *
  64          * @return The Class which is supposed to instantiate the ID
  65          * for the NodeTableID
  66          */
  67         public static Class<?> getClassType(String type) {
  68             return compatibleType.get(type);
  69         }
  70
  71         /**
  72          * Returns all the registered nodeTableIDTypes currently available
  73          *
  74          * @return The current registered NodeTableIDTypes
  75          */
  76         public static Set<String> values() {
  77             return compatibleType.keySet();
  78         }
  79
  80         /**
  81          * Register a new ID for which NodeTable can be created
  82          *
  83          * @param type, the new type being registered
  84          * @param compatibleID, the type of class to be accepted as ID
  85          *
  86          * @return true if registered, false otherwise
  87          */
  88         public static boolean registerIDType(String type,
  89                 Class<? extends Object> compatibleID) {
  90             if (compatibleType.get(type) != null) {
  91                 return false;
  92             }  else {
  93                 compatibleType.put(type, compatibleID);
  94                 return true;
  95             }
  96         }
  97
  98         /**
  99          * UNRegister a new ID for which Node can be created
 100          *
 101          * @param type, the type being UN-registered
 102          *
 103          */
 104         public static void unRegisterIDType(String type) {
 105             compatibleType.remove(type);
 106         }
 107     }
 108
 109     // Elements that constitute the NodeTable
 110     private Object nodeTableID;
 111     private String nodeTableType;
 112     @XmlElement(name = "node")
 113     private Node nodeTableNode;
 114
 115     // Helper field for JAXB
 116     private String nodeTableIDString;
 117
 118     /**
 119      * Private constructor used for JAXB mapping
 120      */
 121     @SuppressWarnings("unused")
 122     private NodeTable() {
 123         this.nodeTableIDString = null;
 124         this.nodeTableID = null;
 125         this.nodeTableType = null;
 126         this.nodeTableNode = null;
 127     }
 128
 129     public NodeTable(String nodeTableType, Object id, Node node) throws ConstructionException {
 130         if (NodeTableIDType.getClassType(nodeTableType) != null &&
 131                 NodeTableIDType.getClassType(nodeTableType).isInstance(id) &&
 132                 node.getType().equals(nodeTableType)) {
 133             this.nodeTableType = nodeTableType;
 134             this.nodeTableID = id;
 135             this.nodeTableNode = node;
 136         } else {
 137             throw new ConstructionException("Type of incoming object:"
 138                     + id.getClass() + " not compatible with expected type:"
 139                     + NodeTableIDType.getClassType(nodeTableType)
 140                     + " or Node type incompatible:" + node.getType());
 141         }
 142     }
 143
 144     /**
 145      * Copy constructor for NodeTable
 146      *
 147      * @param src NodeTable to copy from
 148      *
 149      */
 150     public NodeTable(NodeTable src) throws ConstructionException {
 151         if (src != null) {
 152             this.nodeTableType = src.getType();
 153             // Here we can reference the object because that is
 154             // supposed to be an immutable identifier as well like a
 155             // UUID/Integer and so on, hence no need to create a copy
 156             // of it
 157             this.nodeTableID = src.getID();
 158             this.nodeTableNode = new Node(src.getNode());
 159         } else {
 160             throw
 161             new ConstructionException("Null incoming object to copy from");
 162         }
 163     }
 164
 165     /**
 166      * @return the nodeTableID
 167      */
 168     public Object getID() {
 169         return this.nodeTableID;
 170     }
 171
 172     /**
 173      * @return the nodeTableType
 174      */
 175     public String getType() {
 176         return this.nodeTableType;
 177     }
 178
 179     /**
 180      * @param type the nodeTableType to set
 181      *
 182      * Private setter for nodeConnectorType to be called by JAXB not by anyone
 183      * else, NodeConnector is immutable
 184      */
 185     private void setType(String type) {
 186         this.nodeTableType = type;
 187         if (this.nodeTableIDString != null) {
 188             this.fillmeFromString(type, this.nodeTableIDString);
 189         }
 190     }
 191
 192     /**
 193      * @return the nodeTableNode
 194      */
 195     public Node getNode() {
 196         return this.nodeTableNode;
 197     }
 198
 199     /**
 200      * @param nodeTableNode the nodeTableNode to set
 201      */
 202     public void setNodeTableNode(Node nodeTableNode) {
 203         this.nodeTableNode = nodeTableNode;
 204     }
 205
 206     /**
 207      * @return the nodeTableIDString
 208      */
 209     @XmlElement(name = "id")
 210     public String getNodeTableIDString() {
 211         return this.nodeTableIDString != null? this.nodeTableIDString : nodeTableID.toString();
 212     }
 213
 214     /**
 215      * @param nodeTableIDString the nodeTableIDString to set
 216      */
 217     @SuppressWarnings("unused")
 218     private void setNodeTableIDString(String IDStr) {
 219         this.nodeTableIDString = IDStr;
 220         if (this.nodeTableType != null) {
 221             this.fillmeFromString(this.nodeTableType, IDStr);
 222         }
 223     }
 224
 225     /**
 226      * fill the current object from the string parameters passed, will
 227      * be only used by JAXB
 228      *
 229      * @param typeStr string representing the type of the Node
 230      * @param IDStr String representation of the ID
 231      */
 232     private void fillmeFromString(String typeStr, String IDStr) {
 233         if (typeStr == null) {
 234             return;
 235         }
 236
 237         if (IDStr == null) {
 238             return;
 239         }
 240
 241         this.nodeTableType = typeStr;
 242         this.nodeTableID = (byte) Byte.parseByte(IDStr);
 243     }
 244
 245     @Override
 246     public int hashCode() {
 247         final int prime = 31;
 248         int result = 1;
 249         result = prime * result
 250                 + ((nodeTableID == null) ? 0 : nodeTableID.hashCode());
 251         result = prime
 252                 * result
 253                 + ((nodeTableNode == null) ? 0 : nodeTableNode
 254                         .hashCode());
 255         result = prime
 256                 * result
 257                 + ((nodeTableType == null) ? 0 : nodeTableType
 258                         .hashCode());
 259         return result;
 260     }
 261
 262     @Override
 263     public boolean equals(Object obj) {
 264         if (this == obj)
 265             return true;
 266         if (obj == null)
 267             return false;
 268         if (getClass() != obj.getClass())
 269             return false;
 270         NodeTable other = (NodeTable) obj;
 271         if (nodeTableID == null) {
 272             if (other.nodeTableID != null)
 273                 return false;
 274         } else if (!nodeTableID.equals(other.nodeTableID))
 275             return false;
 276         if (nodeTableNode == null) {
 277             if (other.nodeTableNode != null)
 278                 return false;
 279         } else if (!nodeTableNode.equals(other.nodeTableNode))
 280             return false;
 281         if (nodeTableType == null) {
 282             if (other.nodeTableType != null)
 283                 return false;
 284         } else if (!nodeTableType.equals(other.nodeTableType))
 285             return false;
 286         return true;
 287     }
 288
 289     @Override
 290     public String toString() {
 291         return this.getNodeTableIdAsString() + "@" + this.nodeTableNode;
 292     }
 293
 294     public String getNodeTableIdAsString() {
 295         return this.nodeTableType.toString() + "|"
 296                 + this.nodeTableID.toString();
 297     }
 298
 299 }