encode method

List<bool> encode(String contents)

Implementation

List<bool> encode(String contents) {
  memoizedCost = List.generate(4, (index) => List.filled(contents.length, 0));
  minPath =
      List.generate(4, (index) => List.filled(contents.length, Latch.NONE));

  encodeCharset(contents, Charset.NONE, 0);

  final patterns = <List<int>>[];
  final checkSum = [0];
  final checkWeight = [1];
  final length = contents.length;
  Charset charset = Charset.NONE;
  for (int i = 0; i < length; i++) {
    final latch = minPath![charset.index][i];
    switch (latch) {
      case Latch.A:
        charset = Charset.A;
        addPattern(
          patterns,
          i == 0 ? Code128Writer._CODE_START_A : Code128Writer._CODE_CODE_A,
          checkSum,
          checkWeight,
          i,
        );
        break;
      case Latch.B:
        charset = Charset.B;
        addPattern(
          patterns,
          i == 0 ? Code128Writer._CODE_START_B : Code128Writer._CODE_CODE_B,
          checkSum,
          checkWeight,
          i,
        );
        break;
      case Latch.C:
        charset = Charset.C;
        addPattern(
          patterns,
          i == 0 ? Code128Writer._CODE_START_C : Code128Writer._CODE_CODE_C,
          checkSum,
          checkWeight,
          i,
        );
        break;
      case Latch.SHIFT:
        addPattern(patterns, codeShift, checkSum, checkWeight, i);
        break;
      default:
        break;
    }
    if (charset == Charset.C) {
      if (contents.codeUnitAt(i) == Code128Writer._ESCAPE_FNC_1) {
        addPattern(
          patterns,
          Code128Writer._CODE_FNC_1,
          checkSum,
          checkWeight,
          i,
        );
      } else {
        addPattern(
          patterns,
          int.parse(contents.substring(i, i + 2)),
          checkSum,
          checkWeight,
          i,
        );

        //the algorithm never leads to a single trailing digit in character set C
        assert(i + 1 < length);

        if (i + 1 < length) {
          i++;
        }
      }
    } else {
      // charset A or B
      int patternIndex;
      switch (contents.codeUnitAt(i)) {
        case Code128Writer._ESCAPE_FNC_1:
          patternIndex = Code128Writer._CODE_FNC_1;
          break;
        case Code128Writer._ESCAPE_FNC_2:
          patternIndex = Code128Writer._CODE_FNC_2;
          break;
        case Code128Writer._ESCAPE_FNC_3:
          patternIndex = Code128Writer._CODE_FNC_3;
          break;
        case Code128Writer._ESCAPE_FNC_4:
          if (charset == Charset.A && latch != Latch.SHIFT ||
              charset == Charset.B && latch == Latch.SHIFT) {
            patternIndex = Code128Writer._CODE_FNC_4_A;
          } else {
            patternIndex = Code128Writer._CODE_FNC_4_B;
          }
          break;
        default:
          patternIndex = contents.codeUnitAt(i) - 32 /*' '*/;
      }
      if ((charset == Charset.A && latch != Latch.SHIFT ||
              charset == Charset.B && latch == Latch.SHIFT) &&
          patternIndex < 0) {
        patternIndex += 96 /*'`'*/;
      }
      addPattern(patterns, patternIndex, checkSum, checkWeight, i);
    }
  }
  memoizedCost = null;
  minPath = null;
  return Code128Writer.produceResult(patterns, checkSum[0]);
}