deserialize()

in gremlin-javascript/src/main/javascript/gremlin-javascript/lib/structure/io/binary/internals/EdgeSerializer.js [89:211]

• 109 lines of code
• 20 McCabe index (conditional complexity)

  deserialize(buffer, fullyQualifiedFormat = true) {
    let len = 0;
    let cursor = buffer;

    try {
      if (buffer === undefined || buffer === null || !(buffer instanceof Buffer)) {
        throw new Error('buffer is missing');
      }
      if (buffer.length < 1) {
        throw new Error('buffer is empty');
      }

      if (fullyQualifiedFormat) {
        const type_code = cursor.readUInt8();
        len++;
        if (type_code !== this.ioc.DataType.EDGE) {
          throw new Error('unexpected {type_code}');
        }
        cursor = cursor.slice(1);

        if (cursor.length < 1) {
          throw new Error('{value_flag} is missing');
        }
        const value_flag = cursor.readUInt8();
        len++;
        if (value_flag === 1) {
          return { v: null, len };
        }
        if (value_flag !== 0) {
          throw new Error('unexpected {value_flag}');
        }
        cursor = cursor.slice(1);
      }

      let id, id_len;
      try {
        ({ v: id, len: id_len } = this.ioc.anySerializer.deserialize(cursor));
        len += id_len;
      } catch (err) {
        err.message = '{id}: ' + err.message;
        throw err;
      }
      cursor = cursor.slice(id_len);

      let label, label_len;
      try {
        ({ v: label, len: label_len } = this.ioc.stringSerializer.deserialize(cursor, false));
        len += label_len;
      } catch (err) {
        err.message = '{label}: ' + err.message;
        throw err;
      }
      cursor = cursor.slice(label_len);

      let inVId, inVId_len;
      try {
        ({ v: inVId, len: inVId_len } = this.ioc.anySerializer.deserialize(cursor));
        len += inVId_len;
      } catch (err) {
        err.message = '{inVId}: ' + err.message;
        throw err;
      }
      cursor = cursor.slice(inVId_len);

      let inVLabel, inVLabel_len;
      try {
        ({ v: inVLabel, len: inVLabel_len } = this.ioc.stringSerializer.deserialize(cursor, false));
        len += inVLabel_len;
      } catch (err) {
        err.message = '{inVLabel}: ' + err.message;
        throw err;
      }
      cursor = cursor.slice(inVLabel_len);

      let outVId, outVId_len;
      try {
        ({ v: outVId, len: outVId_len } = this.ioc.anySerializer.deserialize(cursor));
        len += outVId_len;
      } catch (err) {
        err.message = '{outVId}: ' + err.message;
        throw err;
      }
      cursor = cursor.slice(outVId_len);

      let outVLabel, outVLabel_len;
      try {
        ({ v: outVLabel, len: outVLabel_len } = this.ioc.stringSerializer.deserialize(cursor, false));
        len += outVLabel_len;
      } catch (err) {
        err.message = '{outVLabel}: ' + err.message;
        throw err;
      }
      cursor = cursor.slice(outVLabel_len);

      let parent_len;
      try {
        ({ len: parent_len } = this.ioc.anySerializer.deserialize(cursor));
        len += parent_len;
      } catch (err) {
        err.message = '{parent}: ' + err.message;
        throw err;
      }
      cursor = cursor.slice(parent_len);

      let properties, properties_len;
      try {
        ({ v: properties, len: properties_len } = this.ioc.anySerializer.deserialize(cursor));
        len += properties_len;
      } catch (err) {
        err.message = '{properties}: ' + err.message;
        throw err;
      }
      cursor = cursor.slice(properties_len);

      // null properties are deserialized into empty lists
      const edge_props = properties ? properties : [];

      const v = new Edge(id, new Vertex(outVId, outVLabel, null), label, new Vertex(inVId, inVLabel, null), edge_props);
      return { v, len };
    } catch (err) {
      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
    }
  }