pcep/spi/src/main/java/org/opendaylight/protocol/pcep/spi/AbstractObjectWithSubobjectsParser.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.spi;
   9
  10 import java.util.List;
  11 import java.util.Map;
  12 import java.util.Map.Entry;
  13
  14 import org.opendaylight.protocol.pcep.PCEPDeserializerException;
  15 import org.opendaylight.protocol.util.ByteArray;
  16 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev130820.CSubobject;
  17 import org.slf4j.Logger;
  18 import org.slf4j.LoggerFactory;
  19
  20 import com.google.common.base.Preconditions;
  21 import com.google.common.collect.Lists;
  22 import com.google.common.collect.Maps;
  23
  24 public abstract class AbstractObjectWithSubobjectsParser<BUILDER> implements ObjectParser, ObjectSerializer {
  25
  26         private static final Logger logger = LoggerFactory.getLogger(AbstractObjectWithSubobjectsParser.class);
  27
  28         private static final int SUB_TYPE_FLAG_F_LENGTH = 1;
  29         private static final int SUB_LENGTH_F_LENGTH = 1;
  30         private static final int SUB_HEADER_LENGTH = SUB_TYPE_FLAG_F_LENGTH + SUB_LENGTH_F_LENGTH;
  31
  32         public static final int TYPE_FLAG_F_OFFSET = 0;
  33         public static final int LENGTH_F_OFFSET = TYPE_FLAG_F_OFFSET + SUB_TYPE_FLAG_F_LENGTH;
  34         public static final int SO_CONTENTS_OFFSET = LENGTH_F_OFFSET + SUB_LENGTH_F_LENGTH;
  35
  36         protected static final int PADDED_TO = 4;
  37
  38         private final SubobjectHandlerRegistry subobjReg;
  39
  40         protected AbstractObjectWithSubobjectsParser(final SubobjectHandlerRegistry subobjReg) {
  41                 this.subobjReg = Preconditions.checkNotNull(subobjReg);
  42         }
  43
  44         protected final void parseSubobjects(final BUILDER builder, final byte[] bytes) throws PCEPDeserializerException {
  45                 if (bytes == null) {
  46                         throw new IllegalArgumentException("Byte array is mandatory.");
  47                 }
  48
  49                 boolean loose_flag = false;
  50                 int type;
  51
  52                 final Map<CSubobject, Boolean> subs = Maps.newHashMap();
  53
  54                 byte[] soContentsBytes;
  55                 int length;
  56                 int offset = 0;
  57
  58                 while (offset < bytes.length) {
  59
  60                         loose_flag = ((bytes[offset + TYPE_FLAG_F_OFFSET] & (1 << 7)) != 0) ? true : false;
  61                         length = ByteArray.bytesToInt(ByteArray.subByte(bytes, offset + LENGTH_F_OFFSET, SUB_LENGTH_F_LENGTH));
  62
  63                         type = (bytes[offset + TYPE_FLAG_F_OFFSET] & 0xff) & ~(1 << 7);
  64
  65                         if (length > bytes.length - offset) {
  66                                 throw new PCEPDeserializerException("Wrong length specified. Passed: " + length + "; Expected: <= "
  67                                                 + (bytes.length - offset));
  68                         }
  69
  70                         soContentsBytes = new byte[length - SO_CONTENTS_OFFSET];
  71                         System.arraycopy(bytes, offset + SO_CONTENTS_OFFSET, soContentsBytes, 0, length - SO_CONTENTS_OFFSET);
  72
  73                         logger.debug("Attempt to parse subobject from bytes: {}", ByteArray.bytesToHexString(soContentsBytes));
  74                         final CSubobject subObj = this.subobjReg.getSubobjectParser(type).parseSubobject(soContentsBytes);
  75                         logger.debug("Subobject was parsed. {}", subObj);
  76
  77                         subs.put(subObj, loose_flag);
  78
  79                         offset += length;
  80                 }
  81                 // addSubobject(builder, subs);
  82         }
  83
  84         protected final byte[] serializeSubobject(final Map<CSubobject, Boolean> subobjects) {
  85
  86                 final List<byte[]> result = Lists.newArrayList();
  87
  88                 int finalLength = 0;
  89
  90                 for (final Entry<CSubobject, Boolean> entry : subobjects.entrySet()) {
  91
  92                         final CSubobject subobject = entry.getKey();
  93
  94                         final SubobjectSerializer serializer = this.subobjReg.getSubobjectSerializer(subobject);
  95
  96                         final byte[] valueBytes = serializer.serializeSubobject(subobject);
  97
  98                         final byte[] bytes = new byte[SUB_HEADER_LENGTH + valueBytes.length];
  99
 100                         final byte typeBytes = (byte) (ByteArray.cutBytes(ByteArray.intToBytes(serializer.getType()), (Integer.SIZE / 8) - 1)[0] | (entry.getValue() ? 1 << 7
 101                                         : 0));
 102                         final byte lengthBytes = ByteArray.cutBytes(ByteArray.intToBytes(valueBytes.length), (Integer.SIZE / 8) - 1)[0];
 103
 104                         bytes[0] = typeBytes;
 105                         bytes[1] = lengthBytes;
 106                         System.arraycopy(valueBytes, 0, bytes, SUB_HEADER_LENGTH, valueBytes.length);
 107
 108                         finalLength += bytes.length;
 109                         result.add(bytes);
 110                 }
 111
 112                 final byte[] resultBytes = new byte[finalLength];
 113                 int byteOffset = 0;
 114                 for (final byte[] b : result) {
 115                         System.arraycopy(b, 0, resultBytes, byteOffset, b.length);
 116                         byteOffset += b.length;
 117                 }
 118                 return resultBytes;
 119         }
 120
 121         // public abstract void addSubobject(final BUILDER builder, final Map<CSubobject, Boolean> subobjects);
 122
 123 }