pcep/impl/src/main/java/org/opendaylight/protocol/pcep/impl/object/PCEPRequestParameterObjectParser.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
   9 package org.opendaylight.protocol.pcep.impl.object;
  10
  11 import java.util.Arrays;
  12 import java.util.BitSet;
  13
  14 import org.opendaylight.protocol.pcep.PCEPDeserializerException;
  15 import org.opendaylight.protocol.pcep.PCEPObject;
  16 import org.opendaylight.protocol.pcep.impl.PCEPObjectParser;
  17 import org.opendaylight.protocol.pcep.impl.PCEPTlvParser;
  18 import org.opendaylight.protocol.pcep.object.PCEPRequestParameterObject;
  19 import org.opendaylight.protocol.util.ByteArray;
  20
  21 /**
  22  * Parser for {@link org.opendaylight.protocol.pcep.object.PCEPRequestParameterObject
  23  * PCEPRequestParameterObject}
  24  */
  25
  26 public class PCEPRequestParameterObjectParser implements PCEPObjectParser {
  27
  28         /*
  29          * lengths of fields in bytes
  30          */
  31         public static final int FLAGS_PRI_MF_LENGTH = 4; //multi-field
  32         public static final int RID_F_LENGTH = 4;
  33
  34         /*
  35          * lengths of subfields inside multi-field in bits
  36          */
  37         public static final int FLAGS_SF_LENGTH = 29;
  38         public static final int PRI_SF_LENGTH = 3;
  39
  40         /*
  41          * offsets of field in bytes
  42          */
  43
  44         public static final int FLAGS_PRI_MF_OFFSET = 0;
  45         public static final int RID_F_OFFSET = FLAGS_PRI_MF_OFFSET + FLAGS_PRI_MF_LENGTH;
  46         public static final int TLVS_OFFSET = RID_F_OFFSET + RID_F_LENGTH;
  47
  48         /*
  49          * offsets of subfields inside multi-field in bits
  50          */
  51
  52         public static final int FLAGS_SF_OFFSET = 0;
  53         public static final int PRI_SF_OFFSET = FLAGS_SF_OFFSET + FLAGS_SF_LENGTH;
  54
  55         /*
  56          * flags offsets inside flags sub-field in bits
  57          */
  58
  59         private static final int O_FLAG_OFFSET = 26;
  60         private static final int B_FLAG_OFFSET = 27;
  61         private static final int R_FLAG_OFFSET = 28;
  62
  63         /*
  64          * GCO extension flags offsets inside flags sub-field in bits
  65          */
  66         private static final int M_FLAG_OFFSET = 21;
  67         private static final int D_FLAG_OFFSET = 22;
  68
  69         /*
  70          * OF extension flags offsets inside flags sub.field in bits
  71          */
  72
  73         private static int S_FLAG_OFFSET = 24; //Supply OF on response
  74
  75         /*
  76          * RFC6006 flags
  77          */
  78         private static int F_FLAG_OFFSET = 18;
  79
  80         private static int N_FLAG_OFFSET = 19;
  81
  82         private static int E_FLAG_OFFSET = 20;
  83
  84         @Override
  85         public PCEPObject parse(byte[] bytes, boolean processed, boolean ignored) throws PCEPDeserializerException {
  86                 if (bytes == null || bytes.length == 0)
  87                         throw new IllegalArgumentException("Array of bytes is mandatory. Can't be null or empty.");
  88
  89                 if (bytes.length < TLVS_OFFSET)
  90                         throw new PCEPDeserializerException("Wrong length of array of bytes. Passed: " + bytes.length + "; Expected: >=" + TLVS_OFFSET + ".");
  91
  92                 final BitSet flags = ByteArray.bytesToBitSet(Arrays.copyOfRange(bytes, FLAGS_PRI_MF_OFFSET, FLAGS_PRI_MF_OFFSET + FLAGS_PRI_MF_LENGTH));
  93                 short priority = 0;
  94                 priority |= flags.get(PRI_SF_OFFSET + 2) ? 1 : 0;
  95                 priority |= (flags.get(PRI_SF_OFFSET + 1) ? 1 : 0) << 1;
  96                 priority |= (flags.get(PRI_SF_OFFSET) ? 1 : 0) << 2;
  97
  98                 return new PCEPRequestParameterObject(flags.get(O_FLAG_OFFSET), flags.get(B_FLAG_OFFSET), flags.get(R_FLAG_OFFSET), flags.get(M_FLAG_OFFSET),
  99                                 flags.get(D_FLAG_OFFSET), flags.get(S_FLAG_OFFSET), flags.get(F_FLAG_OFFSET), flags.get(N_FLAG_OFFSET), flags.get(E_FLAG_OFFSET), priority,
 100                                 ByteArray.bytesToLong(Arrays.copyOfRange(bytes, RID_F_OFFSET, RID_F_OFFSET + RID_F_LENGTH)), PCEPTlvParser.parse(ByteArray.cutBytes(bytes,
 101                                                 TLVS_OFFSET)), processed, ignored);
 102         }
 103
 104         @Override
 105         public byte[] put(PCEPObject obj) {
 106                 if (!(obj instanceof PCEPRequestParameterObject))
 107                         throw new IllegalArgumentException("Wrong instance of PCEPObject. Passed " + obj.getClass() + ". Needed PCEPRequestParameterObject.");
 108
 109                 final PCEPRequestParameterObject rPObj = (PCEPRequestParameterObject) obj;
 110
 111                 final BitSet flags_priority = new BitSet(FLAGS_PRI_MF_LENGTH * Byte.SIZE);
 112
 113                 flags_priority.set(R_FLAG_OFFSET, rPObj.isReoptimized());
 114                 flags_priority.set(B_FLAG_OFFSET, rPObj.isBidirectional());
 115                 flags_priority.set(O_FLAG_OFFSET, rPObj.isLoose());
 116                 flags_priority.set(M_FLAG_OFFSET, rPObj.isMakeBeforeBreak());
 117                 flags_priority.set(D_FLAG_OFFSET, rPObj.isReportRequestOrder());
 118                 flags_priority.set(S_FLAG_OFFSET, rPObj.isSuplyOFOnResponse());
 119                 flags_priority.set(F_FLAG_OFFSET, rPObj.isFragmentation());
 120                 flags_priority.set(N_FLAG_OFFSET, rPObj.isP2mp());
 121                 flags_priority.set(E_FLAG_OFFSET, rPObj.isEroCompression());
 122
 123                 flags_priority.set(PRI_SF_OFFSET, (rPObj.getPriority() & 1 << 2) != 0);
 124                 flags_priority.set(PRI_SF_OFFSET + 1, (rPObj.getPriority() & 1 << 1) != 0);
 125                 flags_priority.set(PRI_SF_OFFSET + 2, (rPObj.getPriority() & 1) != 0);
 126
 127                 final byte[] tlvs = PCEPTlvParser.put(rPObj.getTlvs());
 128                 final byte[] retBytes = new byte[TLVS_OFFSET + tlvs.length];
 129                 ByteArray.copyWhole(tlvs, retBytes, TLVS_OFFSET);
 130                 ByteArray.copyWhole(ByteArray.bitSetToBytes(flags_priority, FLAGS_PRI_MF_LENGTH), retBytes, FLAGS_PRI_MF_OFFSET);
 131                 ByteArray.copyWhole(ByteArray.subByte(ByteArray.longToBytes(rPObj.getRequestID()), (Long.SIZE / Byte.SIZE) - RID_F_LENGTH, RID_F_LENGTH), retBytes,
 132                                 RID_F_OFFSET);
 133
 134                 return retBytes;
 135         }
 136
 137 }