codec/yang-data-codec-binfmt/src/main/java/org/opendaylight/yangtools/yang/data/codec/binfmt/AbstractMagnesiumDataOutput.java

   1 /*
   2  * Copyright (c) 2019 PANTHEON.tech, s.r.o. 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.yangtools.yang.data.codec.binfmt;
   9
  10 import static com.google.common.base.Preconditions.checkArgument;
  11
  12 import java.io.DataOutput;
  13 import java.io.IOException;
  14 import java.io.StringWriter;
  15 import java.math.BigDecimal;
  16 import java.math.BigInteger;
  17 import java.nio.charset.StandardCharsets;
  18 import java.util.ArrayDeque;
  19 import java.util.Deque;
  20 import java.util.HashMap;
  21 import java.util.List;
  22 import java.util.Map;
  23 import java.util.Map.Entry;
  24 import java.util.Optional;
  25 import java.util.Set;
  26 import javax.xml.transform.TransformerException;
  27 import javax.xml.transform.TransformerFactory;
  28 import javax.xml.transform.dom.DOMSource;
  29 import javax.xml.transform.stream.StreamResult;
  30 import org.eclipse.jdt.annotation.NonNull;
  31 import org.opendaylight.yangtools.rfc8528.data.api.MountPointIdentifier;
  32 import org.opendaylight.yangtools.yang.common.Empty;
  33 import org.opendaylight.yangtools.yang.common.QName;
  34 import org.opendaylight.yangtools.yang.common.QNameModule;
  35 import org.opendaylight.yangtools.yang.common.Revision;
  36 import org.opendaylight.yangtools.yang.common.Uint16;
  37 import org.opendaylight.yangtools.yang.common.Uint32;
  38 import org.opendaylight.yangtools.yang.common.Uint64;
  39 import org.opendaylight.yangtools.yang.common.Uint8;
  40 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  41 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
  42 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  43 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  44 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
  45 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  46 import org.slf4j.Logger;
  47 import org.slf4j.LoggerFactory;
  48
  49 /**
  50  * Abstract base class for NormalizedNodeDataOutput based on {@link MagnesiumNode}, {@link MagnesiumPathArgument} and
  51  * {@link MagnesiumValue}.
  52  */
  53 abstract class AbstractMagnesiumDataOutput extends AbstractNormalizedNodeDataOutput {
  54     private static final Logger LOG = LoggerFactory.getLogger(AbstractMagnesiumDataOutput.class);
  55
  56     // Marker for encoding state when we have entered startLeafNode() within a startMapEntry() and that leaf corresponds
  57     // to a key carried within NodeIdentifierWithPredicates.
  58     private static final Object KEY_LEAF_STATE = new Object();
  59     // Marker for nodes which have simple content and do not use END_NODE marker to terminate
  60     private static final Object NO_ENDNODE_STATE = new Object();
  61
  62     private static final TransformerFactory TF = TransformerFactory.newInstance();
  63
  64     /**
  65      * Stack tracking encoding state. In general we track the node identifier of the currently-open element, but there
  66      * are a few other circumstances where we push other objects. See {@link #KEY_LEAF_STATE} and
  67      * {@link #NO_ENDNODE_STATE}.
  68      */
  69     private final Deque<Object> stack = new ArrayDeque<>();
  70
  71     // Coding maps
  72     private final Map<AugmentationIdentifier, Integer> aidCodeMap = new HashMap<>();
  73     private final Map<QNameModule, Integer> moduleCodeMap = new HashMap<>();
  74     private final Map<String, Integer> stringCodeMap = new HashMap<>();
  75     private final Map<QName, Integer> qnameCodeMap = new HashMap<>();
  76
  77     AbstractMagnesiumDataOutput(final DataOutput output) {
  78         super(output);
  79     }
  80
  81     @Override
  82     public final void startLeafNode(final NodeIdentifier name) throws IOException {
  83         final Object current = stack.peek();
  84         if (current instanceof NodeIdentifierWithPredicates) {
  85             final QName qname = name.getNodeType();
  86             if (((NodeIdentifierWithPredicates) current).containsKey(qname)) {
  87                 writeQNameNode(MagnesiumNode.NODE_LEAF | MagnesiumNode.PREDICATE_ONE, qname);
  88                 stack.push(KEY_LEAF_STATE);
  89                 return;
  90             }
  91         }
  92
  93         startSimpleNode(MagnesiumNode.NODE_LEAF, name);
  94     }
  95
  96     @Override
  97     public final void startLeafSet(final NodeIdentifier name, final int childSizeHint) throws IOException {
  98         startQNameNode(MagnesiumNode.NODE_LEAFSET, name);
  99     }
 100
 101     @Override
 102     public final void startOrderedLeafSet(final NodeIdentifier name, final int childSizeHint) throws IOException {
 103         startQNameNode(MagnesiumNode.NODE_LEAFSET_ORDERED, name);
 104     }
 105
 106     @Override
 107     public final void startLeafSetEntryNode(final NodeWithValue<?> name) throws IOException {
 108         if (matchesParentQName(name.getNodeType())) {
 109             output.writeByte(MagnesiumNode.NODE_LEAFSET_ENTRY);
 110             stack.push(NO_ENDNODE_STATE);
 111         } else {
 112             startSimpleNode(MagnesiumNode.NODE_LEAFSET_ENTRY, name);
 113         }
 114     }
 115
 116     @Override
 117     public final void startContainerNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
 118         startQNameNode(MagnesiumNode.NODE_CONTAINER, name);
 119     }
 120
 121     @Override
 122     public final void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) throws IOException {
 123         startQNameNode(MagnesiumNode.NODE_LIST, name);
 124     }
 125
 126     @Override
 127     public final void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) throws IOException {
 128         startInheritedNode(MagnesiumNode.NODE_LIST_ENTRY, name);
 129     }
 130
 131     @Override
 132     public final void startMapNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
 133         startQNameNode(MagnesiumNode.NODE_MAP, name);
 134     }
 135
 136     @Override
 137     public final void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint)
 138             throws IOException {
 139         final int size = identifier.size();
 140         if (size == 1) {
 141             startInheritedNode((byte) (MagnesiumNode.NODE_MAP_ENTRY | MagnesiumNode.PREDICATE_ONE), identifier);
 142         } else if (size == 0) {
 143             startInheritedNode((byte) (MagnesiumNode.NODE_MAP_ENTRY | MagnesiumNode.PREDICATE_ZERO), identifier);
 144         } else if (size < 256) {
 145             startInheritedNode((byte) (MagnesiumNode.NODE_MAP_ENTRY | MagnesiumNode.PREDICATE_1B), identifier);
 146             output.writeByte(size);
 147         } else {
 148             startInheritedNode((byte) (MagnesiumNode.NODE_MAP_ENTRY | MagnesiumNode.PREDICATE_4B), identifier);
 149             output.writeInt(size);
 150         }
 151
 152         writePredicates(identifier);
 153     }
 154
 155     @Override
 156     public final void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
 157         startQNameNode(MagnesiumNode.NODE_MAP_ORDERED, name);
 158     }
 159
 160     @Override
 161     public final void startChoiceNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
 162         startQNameNode(MagnesiumNode.NODE_CHOICE, name);
 163     }
 164
 165     @Override
 166     public final void startAugmentationNode(final AugmentationIdentifier identifier) throws IOException {
 167         final Integer code = aidCodeMap.get(identifier);
 168         if (code == null) {
 169             aidCodeMap.put(identifier, aidCodeMap.size());
 170             output.writeByte(MagnesiumNode.NODE_AUGMENTATION | MagnesiumNode.ADDR_DEFINE);
 171             final Set<QName> qnames = identifier.getPossibleChildNames();
 172             output.writeInt(qnames.size());
 173             for (QName qname : qnames) {
 174                 writeQNameInternal(qname);
 175             }
 176         } else {
 177             writeNodeType(MagnesiumNode.NODE_AUGMENTATION, code);
 178         }
 179         stack.push(identifier);
 180     }
 181
 182     @Override
 183     public final boolean startAnyxmlNode(final NodeIdentifier name, final Class<?> objectModel) throws IOException {
 184         if (DOMSource.class.isAssignableFrom(objectModel)) {
 185             startSimpleNode(MagnesiumNode.NODE_ANYXML, name);
 186             return true;
 187         }
 188         return false;
 189     }
 190
 191     @Override
 192     public final void domSourceValue(final DOMSource value) throws IOException {
 193         final StringWriter writer = new StringWriter();
 194         try {
 195             TF.newTransformer().transform(value, new StreamResult(writer));
 196         } catch (TransformerException e) {
 197             throw new IOException("Error writing anyXml", e);
 198         }
 199         writeValue(writer.toString());
 200     }
 201
 202     @Override
 203     public final void endNode() throws IOException {
 204         if (stack.pop() instanceof PathArgument) {
 205             output.writeByte(MagnesiumNode.NODE_END);
 206         }
 207     }
 208
 209     @Override
 210     public final void scalarValue(final Object value) throws IOException {
 211         if (KEY_LEAF_STATE.equals(stack.peek())) {
 212             LOG.trace("Inside a map entry key leaf, not emitting value {}", value);
 213         } else {
 214             writeObject(value);
 215         }
 216     }
 217
 218     @Override
 219     final void writeQNameInternal(final QName qname) throws IOException {
 220         final Integer code = qnameCodeMap.get(qname);
 221         if (code == null) {
 222             output.writeByte(MagnesiumValue.QNAME);
 223             encodeQName(qname);
 224         } else {
 225             writeQNameRef(code);
 226         }
 227     }
 228
 229     @Override
 230     final void writePathArgumentInternal(final PathArgument pathArgument) throws IOException {
 231         if (pathArgument instanceof NodeIdentifier) {
 232             writeNodeIdentifier((NodeIdentifier) pathArgument);
 233         } else if (pathArgument instanceof NodeIdentifierWithPredicates) {
 234             writeNodeIdentifierWithPredicates((NodeIdentifierWithPredicates) pathArgument);
 235         } else if (pathArgument instanceof AugmentationIdentifier) {
 236             writeAugmentationIdentifier((AugmentationIdentifier) pathArgument);
 237         } else if (pathArgument instanceof NodeWithValue) {
 238             writeNodeWithValue((NodeWithValue<?>) pathArgument);
 239         } else if (pathArgument instanceof MountPointIdentifier) {
 240             writeMountPointIdentifier((MountPointIdentifier) pathArgument);
 241         } else {
 242             throw new IOException("Unhandled PathArgument " + pathArgument);
 243         }
 244     }
 245
 246     private void writeAugmentationIdentifier(final AugmentationIdentifier identifier) throws IOException {
 247         final Set<QName> qnames = identifier.getPossibleChildNames();
 248         final int size = qnames.size();
 249         if (size < 29) {
 250             output.writeByte(MagnesiumPathArgument.AUGMENTATION_IDENTIFIER
 251                 | size << MagnesiumPathArgument.AID_COUNT_SHIFT);
 252         } else if (size < 256) {
 253             output.writeByte(MagnesiumPathArgument.AUGMENTATION_IDENTIFIER | MagnesiumPathArgument.AID_COUNT_1B);
 254             output.writeByte(size);
 255         } else if (size < 65536) {
 256             output.writeByte(MagnesiumPathArgument.AUGMENTATION_IDENTIFIER | MagnesiumPathArgument.AID_COUNT_2B);
 257             output.writeShort(size);
 258         } else {
 259             output.writeByte(MagnesiumPathArgument.AUGMENTATION_IDENTIFIER | MagnesiumPathArgument.AID_COUNT_4B);
 260             output.writeInt(size);
 261         }
 262
 263         for (QName qname : qnames) {
 264             writeQNameInternal(qname);
 265         }
 266     }
 267
 268     private void writeNodeIdentifier(final NodeIdentifier identifier) throws IOException {
 269         writePathArgumentQName(identifier.getNodeType(), MagnesiumPathArgument.NODE_IDENTIFIER);
 270     }
 271
 272     private void writeMountPointIdentifier(final MountPointIdentifier identifier) throws IOException {
 273         writePathArgumentQName(identifier.getNodeType(), MagnesiumPathArgument.MOUNTPOINT_IDENTIFIER);
 274     }
 275
 276     private void writeNodeIdentifierWithPredicates(final NodeIdentifierWithPredicates identifier) throws IOException {
 277         final int size = identifier.size();
 278         if (size < 5) {
 279             writePathArgumentQName(identifier.getNodeType(),
 280                 (byte) (MagnesiumPathArgument.NODE_IDENTIFIER_WITH_PREDICATES
 281                         | size << MagnesiumPathArgument.SIZE_SHIFT));
 282         } else if (size < 256) {
 283             writePathArgumentQName(identifier.getNodeType(),
 284                 (byte) (MagnesiumPathArgument.NODE_IDENTIFIER_WITH_PREDICATES | MagnesiumPathArgument.SIZE_1B));
 285             output.writeByte(size);
 286         } else if (size < 65536) {
 287             writePathArgumentQName(identifier.getNodeType(),
 288                 (byte) (MagnesiumPathArgument.NODE_IDENTIFIER_WITH_PREDICATES | MagnesiumPathArgument.SIZE_2B));
 289             output.writeShort(size);
 290         } else {
 291             writePathArgumentQName(identifier.getNodeType(),
 292                 (byte) (MagnesiumPathArgument.NODE_IDENTIFIER_WITH_PREDICATES | MagnesiumPathArgument.SIZE_4B));
 293             output.writeInt(size);
 294         }
 295
 296         writePredicates(identifier);
 297     }
 298
 299     private void writePredicates(final NodeIdentifierWithPredicates identifier) throws IOException {
 300         for (Entry<QName, Object> e : identifier.entrySet()) {
 301             writeQNameInternal(e.getKey());
 302             writeObject(e.getValue());
 303         }
 304     }
 305
 306     private void writeNodeWithValue(final NodeWithValue<?> identifier) throws IOException {
 307         writePathArgumentQName(identifier.getNodeType(), MagnesiumPathArgument.NODE_WITH_VALUE);
 308         writeObject(identifier.getValue());
 309     }
 310
 311     private void writePathArgumentQName(final QName qname, final byte typeHeader) throws IOException {
 312         final Integer code = qnameCodeMap.get(qname);
 313         if (code != null) {
 314             final int val = code;
 315             if (val < 256) {
 316                 output.writeByte(typeHeader | MagnesiumPathArgument.QNAME_REF_1B);
 317                 output.writeByte(val);
 318             } else if (val < 65792) {
 319                 output.writeByte(typeHeader | MagnesiumPathArgument.QNAME_REF_2B);
 320                 output.writeShort(val - 256);
 321             } else {
 322                 output.writeByte(typeHeader | MagnesiumPathArgument.QNAME_REF_4B);
 323                 output.writeInt(val);
 324             }
 325         } else {
 326             // implied '| MagnesiumPathArgument.QNAME_DEF'
 327             output.writeByte(typeHeader);
 328             encodeQName(qname);
 329         }
 330     }
 331
 332     @Override
 333     final void writeYangInstanceIdentifierInternal(final YangInstanceIdentifier identifier) throws IOException {
 334         writeValue(identifier);
 335     }
 336
 337     private void writeObject(final @NonNull Object value) throws IOException {
 338         if (value instanceof String) {
 339             writeValue((String) value);
 340         } else if (value instanceof Boolean) {
 341             writeValue((Boolean) value);
 342         } else if (value instanceof Byte) {
 343             writeValue((Byte) value);
 344         } else if (value instanceof Short) {
 345             writeValue((Short) value);
 346         } else if (value instanceof Integer) {
 347             writeValue((Integer) value);
 348         } else if (value instanceof Long) {
 349             writeValue((Long) value);
 350         } else if (value instanceof Uint8) {
 351             writeValue((Uint8) value);
 352         } else if (value instanceof Uint16) {
 353             writeValue((Uint16) value);
 354         } else if (value instanceof Uint32) {
 355             writeValue((Uint32) value);
 356         } else if (value instanceof Uint64) {
 357             writeValue((Uint64) value);
 358         } else if (value instanceof QName) {
 359             writeQNameInternal((QName) value);
 360         } else if (value instanceof YangInstanceIdentifier) {
 361             writeValue((YangInstanceIdentifier) value);
 362         } else if (value instanceof byte[]) {
 363             writeValue((byte[]) value);
 364         } else if (value instanceof Empty) {
 365             output.writeByte(MagnesiumValue.EMPTY);
 366         } else if (value instanceof Set) {
 367             writeValue((Set<?>) value);
 368         } else if (value instanceof BigDecimal) {
 369             writeValue((BigDecimal) value);
 370         } else if (value instanceof BigInteger) {
 371             writeValue((BigInteger) value);
 372         } else {
 373             throw new IOException("Unhandled value type " + value.getClass());
 374         }
 375     }
 376
 377     private void writeValue(final boolean value) throws IOException {
 378         output.writeByte(value ? MagnesiumValue.BOOLEAN_TRUE : MagnesiumValue.BOOLEAN_FALSE);
 379     }
 380
 381     private void writeValue(final byte value) throws IOException {
 382         if (value != 0) {
 383             output.writeByte(MagnesiumValue.INT8);
 384             output.writeByte(value);
 385         } else {
 386             output.writeByte(MagnesiumValue.INT8_0);
 387         }
 388     }
 389
 390     private void writeValue(final short value) throws IOException {
 391         if (value != 0) {
 392             output.writeByte(MagnesiumValue.INT16);
 393             output.writeShort(value);
 394         } else {
 395             output.writeByte(MagnesiumValue.INT16_0);
 396         }
 397     }
 398
 399     private void writeValue(final int value) throws IOException {
 400         if ((value & 0xFFFF0000) != 0) {
 401             output.writeByte(MagnesiumValue.INT32);
 402             output.writeInt(value);
 403         } else if (value != 0) {
 404             output.writeByte(MagnesiumValue.INT32_2B);
 405             output.writeShort(value);
 406         } else {
 407             output.writeByte(MagnesiumValue.INT32_0);
 408         }
 409     }
 410
 411     private void writeValue(final long value) throws IOException {
 412         if ((value & 0xFFFFFFFF00000000L) != 0) {
 413             output.writeByte(MagnesiumValue.INT64);
 414             output.writeLong(value);
 415         } else if (value != 0) {
 416             output.writeByte(MagnesiumValue.INT64_4B);
 417             output.writeInt((int) value);
 418         } else {
 419             output.writeByte(MagnesiumValue.INT64_0);
 420         }
 421     }
 422
 423     private void writeValue(final Uint8 value) throws IOException {
 424         final byte b = value.byteValue();
 425         if (b != 0) {
 426             output.writeByte(MagnesiumValue.UINT8);
 427             output.writeByte(b);
 428         } else {
 429             output.writeByte(MagnesiumValue.UINT8_0);
 430         }
 431     }
 432
 433     private void writeValue(final Uint16 value) throws IOException {
 434         final short s = value.shortValue();
 435         if (s != 0) {
 436             output.writeByte(MagnesiumValue.UINT16);
 437             output.writeShort(s);
 438         } else {
 439             output.writeByte(MagnesiumValue.UINT16_0);
 440         }
 441     }
 442
 443     private void writeValue(final Uint32 value) throws IOException {
 444         final int i = value.intValue();
 445         if ((i & 0xFFFF0000) != 0) {
 446             output.writeByte(MagnesiumValue.UINT32);
 447             output.writeInt(i);
 448         } else if (i != 0) {
 449             output.writeByte(MagnesiumValue.UINT32_2B);
 450             output.writeShort(i);
 451         } else {
 452             output.writeByte(MagnesiumValue.UINT32_0);
 453         }
 454     }
 455
 456     private void writeValue(final Uint64 value) throws IOException {
 457         final long l = value.longValue();
 458         if ((l & 0xFFFFFFFF00000000L) != 0) {
 459             output.writeByte(MagnesiumValue.UINT64);
 460             output.writeLong(l);
 461         } else if (l != 0) {
 462             output.writeByte(MagnesiumValue.UINT64_4B);
 463             output.writeInt((int) l);
 464         } else {
 465             output.writeByte(MagnesiumValue.UINT64_0);
 466         }
 467     }
 468
 469     private void writeValue(final BigDecimal value) throws IOException {
 470         output.writeByte(MagnesiumValue.BIGDECIMAL);
 471         output.writeUTF(value.toString());
 472     }
 473
 474     abstract void writeValue(BigInteger value) throws IOException;
 475
 476     private void writeValue(final String value) throws IOException {
 477         if (value.isEmpty()) {
 478             output.writeByte(MagnesiumValue.STRING_EMPTY);
 479         } else if (value.length() <= Short.MAX_VALUE / 2) {
 480             output.writeByte(MagnesiumValue.STRING_UTF);
 481             output.writeUTF(value);
 482         } else if (value.length() <= 1048576) {
 483             final byte[] bytes = value.getBytes(StandardCharsets.UTF_8);
 484             if (bytes.length < 65536) {
 485                 output.writeByte(MagnesiumValue.STRING_2B);
 486                 output.writeShort(bytes.length);
 487             } else {
 488                 output.writeByte(MagnesiumValue.STRING_4B);
 489                 output.writeInt(bytes.length);
 490             }
 491             output.write(bytes);
 492         } else {
 493             output.writeByte(MagnesiumValue.STRING_CHARS);
 494             output.writeInt(value.length());
 495             output.writeChars(value);
 496         }
 497     }
 498
 499     private void writeValue(final byte[] value) throws IOException {
 500         if (value.length < 128) {
 501             output.writeByte(MagnesiumValue.BINARY_0 + value.length);
 502         } else if (value.length < 384) {
 503             output.writeByte(MagnesiumValue.BINARY_1B);
 504             output.writeByte(value.length - 128);
 505         } else if (value.length < 65920) {
 506             output.writeByte(MagnesiumValue.BINARY_2B);
 507             output.writeShort(value.length - 384);
 508         } else {
 509             output.writeByte(MagnesiumValue.BINARY_4B);
 510             output.writeInt(value.length);
 511         }
 512         output.write(value);
 513     }
 514
 515     private void writeValue(final YangInstanceIdentifier value) throws IOException {
 516         final List<PathArgument> args = value.getPathArguments();
 517         final int size = args.size();
 518         if (size > 31) {
 519             output.writeByte(MagnesiumValue.YIID);
 520             output.writeInt(size);
 521         } else {
 522             output.writeByte(MagnesiumValue.YIID_0 + size);
 523         }
 524         for (PathArgument arg : args) {
 525             writePathArgumentInternal(arg);
 526         }
 527     }
 528
 529     private void writeValue(final Set<?> value) throws IOException {
 530         final int size = value.size();
 531         if (size < 29) {
 532             output.writeByte(MagnesiumValue.BITS_0 + size);
 533         } else if (size < 285) {
 534             output.writeByte(MagnesiumValue.BITS_1B);
 535             output.writeByte(size - 29);
 536         } else if (size < 65821) {
 537             output.writeByte(MagnesiumValue.BITS_2B);
 538             output.writeShort(size - 285);
 539         } else {
 540             output.writeByte(MagnesiumValue.BITS_4B);
 541             output.writeInt(size);
 542         }
 543
 544         for (Object bit : value) {
 545             checkArgument(bit instanceof String, "Expected value type to be String but was %s", bit);
 546             encodeString((String) bit);
 547         }
 548     }
 549
 550     // Check if the proposed QName matches the parent. This is only effective if the parent is identified by
 551     // NodeIdentifier -- which is typically true
 552     private boolean matchesParentQName(final QName qname) {
 553         final Object current = stack.peek();
 554         return current instanceof NodeIdentifier && qname.equals(((NodeIdentifier) current).getNodeType());
 555     }
 556
 557     // Start an END_NODE-terminated node, which typically has a QName matching the parent. If that is the case we emit
 558     // a parent reference instead of an explicit QName reference -- saving at least one byte
 559     private void startInheritedNode(final byte type, final PathArgument name) throws IOException {
 560         final QName qname = name.getNodeType();
 561         if (matchesParentQName(qname)) {
 562             output.write(type);
 563         } else {
 564             writeQNameNode(type, qname);
 565         }
 566         stack.push(name);
 567     }
 568
 569     // Start an END_NODE-terminated node, which needs its QName encoded
 570     private void startQNameNode(final byte type, final PathArgument name) throws IOException {
 571         writeQNameNode(type, name.getNodeType());
 572         stack.push(name);
 573     }
 574
 575     // Start a simple node, which is not terminated through END_NODE and encode its QName
 576     private void startSimpleNode(final byte type, final PathArgument name) throws IOException {
 577         writeQNameNode(type, name.getNodeType());
 578         stack.push(NO_ENDNODE_STATE);
 579     }
 580
 581     // Encode a QName-based (i.e. NodeIdentifier*) node with a particular QName. This will either result in a QName
 582     // definition, or a reference, where this is encoded along with the node type.
 583     private void writeQNameNode(final int type, final @NonNull QName qname) throws IOException {
 584         final Integer code = qnameCodeMap.get(qname);
 585         if (code == null) {
 586             output.writeByte(type | MagnesiumNode.ADDR_DEFINE);
 587             encodeQName(qname);
 588         } else {
 589             writeNodeType(type, code);
 590         }
 591     }
 592
 593     // Write a node type + lookup
 594     private void writeNodeType(final int type, final int code) throws IOException {
 595         if (code <= 255) {
 596             output.writeByte(type | MagnesiumNode.ADDR_LOOKUP_1B);
 597             output.writeByte(code);
 598         } else {
 599             output.writeByte(type | MagnesiumNode.ADDR_LOOKUP_4B);
 600             output.writeInt(code);
 601         }
 602     }
 603
 604     // Encode a QName using lookup tables, resuling either in a reference to an existing entry, or emitting two
 605     // String values.
 606     private void encodeQName(final @NonNull QName qname) throws IOException {
 607         final Integer prev = qnameCodeMap.put(qname, qnameCodeMap.size());
 608         if (prev != null) {
 609             throw new IOException("Internal coding error: attempted to re-encode " + qname + "%s already encoded as "
 610                     + prev);
 611         }
 612
 613         final QNameModule module = qname.getModule();
 614         final Integer code = moduleCodeMap.get(module);
 615         if (code == null) {
 616             moduleCodeMap.put(module, moduleCodeMap.size());
 617             encodeString(module.getNamespace().toString());
 618             final Optional<Revision> rev = module.getRevision();
 619             if (rev.isPresent()) {
 620                 encodeString(rev.get().toString());
 621             } else {
 622                 output.writeByte(MagnesiumValue.STRING_EMPTY);
 623             }
 624         } else {
 625             writeModuleRef(code);
 626         }
 627         encodeString(qname.getLocalName());
 628     }
 629
 630     // Encode a String using lookup tables, resulting either in a reference to an existing entry, or emitting as
 631     // a literal value
 632     private void encodeString(final @NonNull String str) throws IOException {
 633         final Integer code = stringCodeMap.get(str);
 634         if (code != null) {
 635             writeRef(code);
 636         } else {
 637             stringCodeMap.put(str, stringCodeMap.size());
 638             writeValue(str);
 639         }
 640     }
 641
 642     // Write a QName with a lookup table reference. This is a combination of asserting the value is a QName plus
 643     // the effects of writeRef()
 644     private void writeQNameRef(final int code) throws IOException {
 645         final int val = code;
 646         if (val < 256) {
 647             output.writeByte(MagnesiumValue.QNAME_REF_1B);
 648             output.writeByte(val);
 649         } else if (val < 65792) {
 650             output.writeByte(MagnesiumValue.QNAME_REF_2B);
 651             output.writeShort(val - 256);
 652         } else {
 653             output.writeByte(MagnesiumValue.QNAME_REF_4B);
 654             output.writeInt(val);
 655         }
 656     }
 657
 658     // Write a lookup table reference, which table is being referenced is implied by the caller
 659     private void writeRef(final int code) throws IOException {
 660         final int val = code;
 661         if (val < 256) {
 662             output.writeByte(MagnesiumValue.STRING_REF_1B);
 663             output.writeByte(val);
 664         } else if (val < 65792) {
 665             output.writeByte(MagnesiumValue.STRING_REF_2B);
 666             output.writeShort(val - 256);
 667         } else {
 668             output.writeByte(MagnesiumValue.STRING_REF_4B);
 669             output.writeInt(val);
 670         }
 671     }
 672
 673     // Write a lookup module table reference, which table is being referenced is implied by the caller
 674     private void writeModuleRef(final int code) throws IOException {
 675         final int val = code;
 676         if (val < 256) {
 677             output.writeByte(MagnesiumValue.MODREF_1B);
 678             output.writeByte(val);
 679         } else if (val < 65792) {
 680             output.writeByte(MagnesiumValue.MODREF_2B);
 681             output.writeShort(val - 256);
 682         } else {
 683             output.writeByte(MagnesiumValue.MODREF_4B);
 684             output.writeInt(val);
 685         }
 686     }
 687 }