pcep/api/src/main/java/org/opendaylight/protocol/pcep/object/CompositeErrorObject.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  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.protocol.pcep.object;
   9
  10 import java.util.ArrayList;
  11 import java.util.Collections;
  12 import java.util.List;
  13
  14 import org.opendaylight.protocol.pcep.PCEPObject;
  15
  16 /**
  17  * Structure that combines set of related objects.
  18  *
  19  * @see <a href="http://tools.ietf.org/html/rfc5440#section-6.7">Error (PCErr)
  20  *      Message</a> - &lt;error&gt;
  21  */
  22 public class CompositeErrorObject {
  23
  24         private List<PCEPRequestParameterObject> requestParameters;
  25
  26         private final List<PCEPErrorObject> errors;
  27
  28         public CompositeErrorObject(final PCEPRequestParameterObject requestParameter, final PCEPErrorObject error) {
  29                 this(new ArrayList<PCEPRequestParameterObject>() {
  30                         private static final long serialVersionUID = -3974192068960284132L;
  31
  32                         {
  33                                 if (requestParameter != null)
  34                                         this.add(requestParameter);
  35                         }
  36                 }, new ArrayList<PCEPErrorObject>() {
  37                         private static final long serialVersionUID = -3976331879683713909L;
  38
  39                         {
  40                                 if (error != null)
  41                                         this.add(error);
  42                         }
  43                 });
  44         }
  45
  46         /**
  47          * Constructs basic composite object only with mandatory objects.
  48          *
  49          * @param errors
  50          *            List<PCEPErrorObject>. Can't be null or empty.
  51          */
  52         public CompositeErrorObject(List<PCEPErrorObject> errors) {
  53                 this(null, errors);
  54         }
  55
  56         /**
  57          * Constructs composite object with optional objects.
  58          *
  59          * @param requestParameters
  60          *            List<PCEPRequestParameterObject>
  61          * @param errors
  62          *            List<PCEPErrorObject>. Can't be null or empty.
  63          */
  64         public CompositeErrorObject(List<PCEPRequestParameterObject> requestParameters, List<PCEPErrorObject> errors) {
  65
  66                 if (errors == null || errors.isEmpty())
  67                         throw new IllegalArgumentException("Error Object is mandatory.");
  68                 this.errors = errors;
  69                 if (requestParameters != null)
  70                         this.requestParameters = requestParameters;
  71                 else
  72                         this.requestParameters = Collections.emptyList();
  73         }
  74
  75         /**
  76          * Gets list of all objects, which are in appropriate order.
  77          *
  78          * @return List<PCEPObject>. Can't be null or empty.
  79          */
  80         public List<PCEPObject> getCompositeAsList() {
  81                 final List<PCEPObject> list = new ArrayList<PCEPObject>();
  82                 if (this.requestParameters != null && !this.requestParameters.isEmpty())
  83                         list.addAll(this.requestParameters);
  84                 list.addAll(this.errors);
  85                 return list;
  86         }
  87
  88         /**
  89          * Creates this object from a list of PCEPObjects.
  90          *
  91          * @param objects
  92          *            List<PCEPObject> list of PCEPObjects from whose this object
  93          *            should be created.
  94          * @return CompositeErrorObject
  95          */
  96         public static CompositeErrorObject getCompositeFromList(List<PCEPObject> objects) {
  97                 if (objects == null || objects.isEmpty())
  98                         throw new IllegalArgumentException("List cannot be null or empty.");
  99
 100                 final List<PCEPRequestParameterObject> requestParameters = new ArrayList<PCEPRequestParameterObject>();
 101                 final List<PCEPErrorObject> errors = new ArrayList<PCEPErrorObject>();
 102
 103                 int state = 1;
 104                 while (!objects.isEmpty()) {
 105                         final PCEPObject obj = objects.get(0);
 106                         switch (state) {
 107                                 case 1:
 108                                         state = 2;
 109                                         if (obj instanceof PCEPRequestParameterObject) {
 110                                                 requestParameters.add((PCEPRequestParameterObject) obj);
 111                                                 state = 1;
 112                                                 break;
 113                                         }
 114                                 case 2:
 115                                         state = 3;
 116                                         if (obj instanceof PCEPErrorObject) {
 117                                                 errors.add((PCEPErrorObject) obj);
 118                                                 state = 2;
 119                                                 break;
 120                                         }
 121                         }
 122
 123                         if (state == 3) {
 124                                 break;
 125                         }
 126
 127                         objects.remove(obj);
 128                 }
 129
 130                 if (errors.isEmpty())
 131                         throw new IllegalArgumentException("Atleast one PCEPErrorObject is mandatory.");
 132
 133                 return new CompositeErrorObject(requestParameters, errors);
 134         }
 135
 136         /**
 137          * Gets list of {@link PCEPRequestParameterObject}.
 138          *
 139          * @return List<PCEPRequestParameterObject>. Can't be null, but may be
 140          *         empty.
 141          */
 142         public List<PCEPRequestParameterObject> getRequestParameters() {
 143                 return this.requestParameters;
 144         }
 145
 146         /**
 147          * Gets list of {@link PCEPErrorObject}
 148          *
 149          * @return List<PCEPErrorObject>. Can't be null or empty.
 150          */
 151         public List<PCEPErrorObject> getErrors() {
 152                 return this.errors;
 153         }
 154
 155         @Override
 156         public int hashCode() {
 157                 final int prime = 31;
 158                 int result = 1;
 159                 result = prime * result + ((this.errors == null) ? 0 : this.errors.hashCode());
 160                 result = prime * result + ((this.requestParameters == null) ? 0 : this.requestParameters.hashCode());
 161                 return result;
 162         }
 163
 164         @Override
 165         public boolean equals(Object obj) {
 166                 if (this == obj)
 167                         return true;
 168                 if (obj == null)
 169                         return false;
 170                 if (this.getClass() != obj.getClass())
 171                         return false;
 172                 final CompositeErrorObject other = (CompositeErrorObject) obj;
 173                 if (this.errors == null) {
 174                         if (other.errors != null)
 175                                 return false;
 176                 } else if (!this.errors.equals(other.errors))
 177                         return false;
 178                 if (this.requestParameters == null) {
 179                         if (other.requestParameters != null)
 180                                 return false;
 181                 } else if (!this.requestParameters.equals(other.requestParameters))
 182                         return false;
 183                 return true;
 184         }
 185
 186         @Override
 187         public String toString() {
 188                 final StringBuilder builder = new StringBuilder();
 189                 builder.append("CompositeErrorObject [requestParameters=");
 190                 builder.append(this.requestParameters);
 191                 builder.append(", errors=");
 192                 builder.append(this.errors);
 193                 builder.append("]");
 194                 return builder.toString();
 195         }
 196 }