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     private NodeTable() {
 122         this.nodeTableIDString = null;
 123         this.nodeTableID = null;
 124         this.nodeTableType = null;
 125         this.nodeTableNode = null;
 126     }
 127
 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;
 135         } else {
 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());
 140         }
 141     }
 142
 143     /**
 144      * Copy constructor for NodeTable
 145      *
 146      * @param src NodeTable to copy from
 147      *
 148      */
 149     public NodeTable(NodeTable src) throws ConstructionException {
 150         if (src != null) {
 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
 155             // of it
 156             this.nodeTableID = src.getID();
 157             this.nodeTableNode = new Node(src.getNode());
 158         } else {
 159             throw
 160             new ConstructionException("Null incoming object to copy from");
 161         }
 162     }
 163
 164     /**
 165      * @return the nodeTableID
 166      */
 167     public Object getID() {
 168         return this.nodeTableID;
 169     }
 170
 171     /**
 172      * @return the nodeTableType
 173      */
 174     public String getType() {
 175         return this.nodeTableType;
 176     }
 177
 178     /**
 179      * @param type the nodeTableType to set
 180      *
 181      * Private setter for nodeConnectorType to be called by JAXB not by anyone
 182      * else, NodeConnector is immutable
 183      */
 184     private void setType(String type) {
 185         this.nodeTableType = type;
 186         if (this.nodeTableIDString != null) {
 187             this.fillmeFromString(type, this.nodeTableIDString);
 188         }
 189     }
 190
 191     /**
 192      * @return the nodeTableNode
 193      */
 194     public Node getNode() {
 195         return this.nodeTableNode;
 196     }
 197
 198     /**
 199      * @param nodeTableNode the nodeTableNode to set
 200      */
 201     public void setNodeTableNode(Node nodeTableNode) {
 202         this.nodeTableNode = nodeTableNode;
 203     }
 204
 205     /**
 206      * @return the nodeTableIDString
 207      */
 208     @XmlAttribute(name = "id")
 209     public String getNodeTableIDString() {
 210         return this.nodeTableIDString.toString();
 211     }
 212
 213     /**
 214      * @param nodeTableIDString the nodeTableIDString to set
 215      */
 216     @SuppressWarnings("unused")
 217     private void setNodeTableIDString(String IDStr) {
 218         this.nodeTableIDString = IDStr;
 219         if (this.nodeTableType != null) {
 220             this.fillmeFromString(this.nodeTableType, IDStr);
 221         }
 222     }
 223
 224     /**
 225      * fill the current object from the string parameters passed, will
 226      * be only used by JAXB
 227      *
 228      * @param typeStr string representing the type of the Node
 229      * @param IDStr String representation of the ID
 230      */
 231     private void fillmeFromString(String typeStr, String IDStr) {
 232         if (typeStr == null) {
 233             return;
 234         }
 235
 236         if (IDStr == null) {
 237             return;
 238         }
 239
 240         this.nodeTableType = typeStr;
 241         this.nodeTableID = (byte) Byte.parseByte(IDStr);
 242     }
 243
 244     @Override
 245     public int hashCode() {
 246         final int prime = 31;
 247         int result = 1;
 248         result = prime * result
 249                 + ((nodeTableID == null) ? 0 : nodeTableID.hashCode());
 250         result = prime
 251                 * result
 252                 + ((nodeTableNode == null) ? 0 : nodeTableNode
 253                         .hashCode());
 254         result = prime
 255                 * result
 256                 + ((nodeTableType == null) ? 0 : nodeTableType
 257                         .hashCode());
 258         return result;
 259     }
 260
 261     @Override
 262     public boolean equals(Object obj) {
 263         if (this == obj)
 264             return true;
 265         if (obj == null)
 266             return false;
 267         if (getClass() != obj.getClass())
 268             return false;
 269         NodeTable other = (NodeTable) obj;
 270         if (nodeTableID == null) {
 271             if (other.nodeTableID != null)
 272                 return false;
 273         } else if (!nodeTableID.equals(other.nodeTableID))
 274             return false;
 275         if (nodeTableNode == null) {
 276             if (other.nodeTableNode != null)
 277                 return false;
 278         } else if (!nodeTableNode.equals(other.nodeTableNode))
 279             return false;
 280         if (nodeTableType == null) {
 281             if (other.nodeTableType != null)
 282                 return false;
 283         } else if (!nodeTableType.equals(other.nodeTableType))
 284             return false;
 285         return true;
 286     }
 287
 288     @Override
 289     public String toString() {
 290         return this.getNodeTableIdAsString() + "@" + this.nodeTableNode;
 291     }
 292
 293     public String getNodeTableIdAsString() {
 294         return this.nodeTableType.toString() + "|"
 295                 + this.nodeTableID.toString();
 296     }
 297
 298 }