react-native-bluetooth-escpos-printer-mirfalahtech/ios/ZXingObjC-3.2.2/ZXingObjC/pdf417/encoder/ZXPDF417HighLevelEncoder.m

/*
 * Copyright 2006 Jeremias Maerki in part, and ZXing Authors in part
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#import "ZXByteArray.h"
#import "ZXCharacterSetECI.h"
#import "ZXErrors.h"
#import "ZXPDF417HighLevelEncoder.h"

/**
 * code for Text compaction
 */
const int ZX_PDF417_TEXT_COMPACTION = 0;

/**
 * code for Byte compaction
 */
const int ZX_PDF417_BYTE_COMPACTION = 1;

/**
 * code for Numeric compaction
 */
const int ZX_PDF417_NUMERIC_COMPACTION = 2;

/**
 * Text compaction submode Alpha
 */
const int ZX_PDF417_SUBMODE_ALPHA = 0;

/**
 * Text compaction submode Lower
 */
const int ZX_PDF417_SUBMODE_LOWER = 1;

/**
 * Text compaction submode Mixed
 */
const int ZX_PDF417_SUBMODE_MIXED = 2;

/**
 * Text compaction submode Punctuation
 */
const int ZX_PDF417_SUBMODE_PUNCTUATION = 3;

/**
 * mode latch to Text Compaction mode
 */
const int ZX_PDF417_LATCH_TO_TEXT = 900;

/**
 * mode latch to Byte Compaction mode (number of characters NOT a multiple of 6)
 */
const int ZX_PDF417_LATCH_TO_BYTE_PADDED = 901;

/**
 * mode latch to Numeric Compaction mode
 */
const int ZX_PDF417_LATCH_TO_NUMERIC = 902;

/**
 * mode shift to Byte Compaction mode
 */
const int ZX_PDF417_SHIFT_TO_BYTE = 913;

/**
 * mode latch to Byte Compaction mode (number of characters a multiple of 6)
 */
const int ZX_PDF417_LATCH_TO_BYTE = 924;

/**
 * identifier for a user defined Extended Channel Interpretation (ECI)
 */
const int ZX_PDF417_HIGH_LEVEL_ECI_USER_DEFINED = 925;

/**
 * identifier for a general purpose ECO format
 */
const int ZX_PDF417_HIGH_LEVEL_ECI_GENERAL_PURPOSE = 926;

/**
 * identifier for an ECI of a character set of code page
 */
const int ZX_PDF417_HIGH_LEVEL_ECI_CHARSET = 927;

/**
 * Raw code table for text compaction Mixed sub-mode
 */
const int8_t ZX_PDF417_TEXT_MIXED_RAW[] = {
  48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 38, 13, 9, 44, 58,
  35, 45, 46, 36, 47, 43, 37, 42, 61, 94, 0, 32, 0, 0, 0};

/**
 * Raw code table for text compaction: Punctuation sub-mode
 */
const int8_t ZX_PDF417_TEXT_PUNCTUATION_RAW[] = {
  59, 60, 62, 64, 91, 92, 93, 95, 96, 126, 33, 13, 9, 44, 58,
  10, 45, 46, 36, 47, 34, 124, 42, 40, 41, 63, 123, 125, 39, 0};

const int ZX_PDF417_MIXED_TABLE_LEN = 128;
unichar ZX_PDF417_MIXED_TABLE[ZX_PDF417_MIXED_TABLE_LEN];

const int ZX_PDF417_PUNCTUATION_LEN = 128;
unichar ZX_PDF417_PUNCTUATION[ZX_PDF417_PUNCTUATION_LEN];

const NSStringEncoding ZX_PDF417_DEFAULT_ENCODING = NSISOLatin1StringEncoding;

@implementation ZXPDF417HighLevelEncoder

+ (void)initialize {
  if ([self class] != [ZXPDF417HighLevelEncoder class]) return;

  //Construct inverse lookups
  for (int i = 0; i < ZX_PDF417_MIXED_TABLE_LEN; i++) {
    ZX_PDF417_MIXED_TABLE[i] = 0xFF;
  }
  for (int8_t i = 0; i < sizeof(ZX_PDF417_TEXT_MIXED_RAW) / sizeof(int8_t); i++) {
    int8_t b = ZX_PDF417_TEXT_MIXED_RAW[i];
    if (b > 0) {
      ZX_PDF417_MIXED_TABLE[b] = i;
    }
  }
  for (int i = 0; i < ZX_PDF417_PUNCTUATION_LEN; i++) {
    ZX_PDF417_PUNCTUATION[i] = 0xFF;
  }
  for (int8_t i = 0; i < sizeof(ZX_PDF417_TEXT_PUNCTUATION_RAW) / sizeof(int8_t); i++) {
    int8_t b = ZX_PDF417_TEXT_PUNCTUATION_RAW[i];
    if (b > 0) {
      ZX_PDF417_PUNCTUATION[b] = i;
    }
  }
}

+ (NSString *)encodeHighLevel:(NSString *)msg compaction:(ZXPDF417Compaction)compaction encoding:(NSStringEncoding)encoding error:(NSError **)error {
  //the codewords 0..928 are encoded as Unicode characters
  NSMutableString *sb = [NSMutableString stringWithCapacity:msg.length];

  if (encoding == 0) {
    encoding = ZX_PDF417_DEFAULT_ENCODING;
  } else if (ZX_PDF417_DEFAULT_ENCODING != encoding) {
    ZXCharacterSetECI *eci = [ZXCharacterSetECI characterSetECIByEncoding:encoding];
    if (![self encodingECI:eci.value sb:sb error:error]) {
      return nil;
    }
  }

  NSUInteger len = msg.length;
  int p = 0;
  int textSubMode = ZX_PDF417_SUBMODE_ALPHA;

  // User selected encoding mode
  ZXByteArray *bytes = nil; //Fill later and only if needed
  if (compaction == ZXPDF417CompactionText) {
    [self encodeText:msg startpos:p count:(int)len buffer:sb initialSubmode:textSubMode];
  } else if (compaction == ZXPDF417CompactionByte) {
    bytes = [self bytesForMessage:msg encoding:encoding];
    [self encodeBinary:bytes startpos:p count:(int)msg.length startmode:ZX_PDF417_BYTE_COMPACTION buffer:sb];
  } else if (compaction == ZXPDF417CompactionNumeric) {
    [sb appendFormat:@"%C", (unichar) ZX_PDF417_LATCH_TO_NUMERIC];
    [self encodeNumeric:msg startpos:p count:(int)len buffer:sb];
  } else {
    int encodingMode = ZX_PDF417_TEXT_COMPACTION; //Default mode, see 4.4.2.1
    while (p < len) {
      int n = [self determineConsecutiveDigitCount:msg startpos:p];
      if (n >= 13) {
        [sb appendFormat:@"%C", (unichar) ZX_PDF417_LATCH_TO_NUMERIC];
        encodingMode = ZX_PDF417_NUMERIC_COMPACTION;
        textSubMode = ZX_PDF417_SUBMODE_ALPHA; //Reset after latch
        [self encodeNumeric:msg startpos:p count:n buffer:sb];
        p += n;
      } else {
        int t = [self determineConsecutiveTextCount:msg startpos:p];
        if (t >= 5 || n == len) {
          if (encodingMode != ZX_PDF417_TEXT_COMPACTION) {
            [sb appendFormat:@"%C", (unichar) ZX_PDF417_LATCH_TO_TEXT];
            encodingMode = ZX_PDF417_TEXT_COMPACTION;
            textSubMode = ZX_PDF417_SUBMODE_ALPHA; //start with submode alpha after latch
          }
          textSubMode = [self encodeText:msg startpos:p count:t buffer:sb initialSubmode:textSubMode];
          p += t;
        } else {
          if (bytes == NULL) {
            bytes = [self bytesForMessage:msg encoding:encoding];
          }
          int b = [self determineConsecutiveBinaryCount:msg bytes:bytes startpos:p error:error];
          if (b == -1) {
            return nil;
          } else if (b == 0) {
            b = 1;
          }
          if (b == 1 && encodingMode == ZX_PDF417_TEXT_COMPACTION) {
            //Switch for one byte (instead of latch)
            [self encodeBinary:bytes startpos:p count:1 startmode:ZX_PDF417_TEXT_COMPACTION buffer:sb];
          } else {
            //Mode latch performed by encodeBinary
            [self encodeBinary:bytes startpos:p count:b startmode:encodingMode buffer:sb];
            encodingMode = ZX_PDF417_BYTE_COMPACTION;
            textSubMode = ZX_PDF417_SUBMODE_ALPHA; //Reset after latch
          }
          p += b;
        }
      }
    }
  }

  return sb;
}

/**
 * Encode parts of the message using Text Compaction as described in ISO/IEC 15438:2001(E),
 * chapter 4.4.2.
 *
 * @param msg            the message
 * @param startpos       the start position within the message
 * @param count          the number of characters to encode
 * @param sb             receives the encoded codewords
 * @param initialSubmode should normally be SUBMODE_ALPHA
 * @return the text submode in which this method ends
 */
+ (int)encodeText:(NSString *)msg startpos:(int)startpos count:(int)count buffer:(NSMutableString *)sb initialSubmode:(int)initialSubmode {
  NSMutableString *tmp = [NSMutableString stringWithCapacity:count];
  int submode = initialSubmode;
  int idx = 0;
  while (true) {
    unichar ch = [msg characterAtIndex:startpos + idx];
    switch (submode) {
      case ZX_PDF417_SUBMODE_ALPHA:
        if ([self isAlphaUpper:ch]) {
          if (ch == ' ') {
            [tmp appendFormat:@"%C", (unichar) 26]; //space
          } else {
            [tmp appendFormat:@"%C", (unichar) (ch - 65)];
          }
        } else {
          if ([self isAlphaLower:ch]) {
            submode = ZX_PDF417_SUBMODE_LOWER;
            [tmp appendFormat:@"%C", (unichar) 27]; //ll
            continue;
          } else if ([self isMixed:ch]) {
            submode = ZX_PDF417_SUBMODE_MIXED;
            [tmp appendFormat:@"%C", (unichar) 28]; //ml
            continue;
          } else {
            [tmp appendFormat:@"%C", (unichar) 29]; //ps
            [tmp appendFormat:@"%C", ZX_PDF417_PUNCTUATION[ch]];
            break;
          }
        }
        break;
      case ZX_PDF417_SUBMODE_LOWER:
        if ([self isAlphaLower:ch]) {
          if (ch == ' ') {
            [tmp appendFormat:@"%C", (unichar) 26]; //space
          } else {
            [tmp appendFormat:@"%C", (unichar) (ch - 97)];
          }
        } else {
          if ([self isAlphaUpper:ch]) {
            [tmp appendFormat:@"%C", (unichar) 27]; //as
            [tmp appendFormat:@"%C", (unichar) (ch - 65)];
            //space cannot happen here, it is also in "Lower"
            break;
          } else if ([self isMixed:ch]) {
            submode = ZX_PDF417_SUBMODE_MIXED;
            [tmp appendFormat:@"%C", (unichar) 28]; //ml
            continue;
          } else {
            [tmp appendFormat:@"%C", (unichar) 29]; //ps
            [tmp appendFormat:@"%C", ZX_PDF417_PUNCTUATION[ch]];
            break;
          }
        }
        break;
      case ZX_PDF417_SUBMODE_MIXED:
        if ([self isMixed:ch]) {
          [tmp appendFormat:@"%C", ZX_PDF417_MIXED_TABLE[ch]]; //as
        } else {
          if ([self isAlphaUpper:ch]) {
            submode = ZX_PDF417_SUBMODE_ALPHA;
            [tmp appendFormat:@"%C", (unichar) 28]; //al
            continue;
          } else if ([self isAlphaLower:ch]) {
            submode = ZX_PDF417_SUBMODE_LOWER;
            [tmp appendFormat:@"%C", (unichar) 27]; //ll
            continue;
          } else {
            if (startpos + idx + 1 < count) {
              char next = [msg characterAtIndex:startpos + idx + 1];
              if ([self isPunctuation:next]) {
                submode = ZX_PDF417_SUBMODE_PUNCTUATION;
                [tmp appendFormat:@"%C", (unichar) 25]; //pl
                continue;
              }
            }
            [tmp appendFormat:@"%C", (unichar) 29]; //ps
            [tmp appendFormat:@"%C", ZX_PDF417_PUNCTUATION[ch]];
          }
        }
        break;
      default: //ZX_PDF417_SUBMODE_PUNCTUATION
        if ([self isPunctuation:ch]) {
          [tmp appendFormat:@"%C", ZX_PDF417_PUNCTUATION[ch]];
        } else {
          submode = ZX_PDF417_SUBMODE_ALPHA;
          [tmp appendFormat:@"%C", (unichar) 29]; //al
          continue;
        }
    }
    idx++;
    if (idx >= count) {
      break;
    }
  }
  unichar h = 0;
  NSUInteger len = tmp.length;
  for (int i = 0; i < len; i++) {
    BOOL odd = (i % 2) != 0;
    if (odd) {
      h = (unichar) ((h * 30) + [tmp characterAtIndex:i]);
      [sb appendFormat:@"%C", h];
    } else {
      h = [tmp characterAtIndex:i];
    }
  }
  if ((len % 2) != 0) {
    [sb appendFormat:@"%C", (unichar) ((h * 30) + 29)]; //ps
  }
  return submode;
}

/**
 * Encode parts of the message using Byte Compaction as described in ISO/IEC 15438:2001(E),
 * chapter 4.4.3. The Unicode characters will be converted to binary using the cp437
 * codepage.
 *
 * @param bytes     the message converted to a byte array
 * @param startpos  the start position within the message
 * @param count     the number of bytes to encode
 * @param startmode the mode from which this method starts
 * @param sb        receives the encoded codewords
 */
+ (void)encodeBinary:(ZXByteArray *)bytes startpos:(int)startpos count:(int)count startmode:(int)startmode buffer:(NSMutableString *)sb {
  if (count == 1 && startmode == ZX_PDF417_TEXT_COMPACTION) {
    [sb appendFormat:@"%C", (unichar) ZX_PDF417_SHIFT_TO_BYTE];
  } else {
    BOOL sixpack = ((count % 6) == 0);
    if (sixpack) {
      [sb appendFormat:@"%C", (unichar) ZX_PDF417_LATCH_TO_BYTE];
    } else {
      [sb appendFormat:@"%C", (unichar) ZX_PDF417_LATCH_TO_BYTE_PADDED];
    }
  }

  int idx = startpos;
  // Encode sixpacks
  if (count >= 6) {
    const int charsLen = 5;
    unichar chars[charsLen];
    memset(chars, 0, charsLen * sizeof(unichar));
    while ((startpos + count - idx) >= 6) {
      long long t = 0;
      for (int i = 0; i < 6; i++) {
        t <<= 8;
        t += bytes.array[idx + i] & 0xff;
      }
      for (int i = 0; i < 5; i++) {
        chars[i] = (unichar) (t % 900);
        t /= 900;
      }
      for (int i = charsLen - 1; i >= 0; i--) {
        [sb appendFormat:@"%C", chars[i]];
      }
      idx += 6;
    }
  }
  //Encode rest (remaining n<5 bytes if any)
  for (int i = idx; i < startpos + count; i++) {
    int ch = bytes.array[i] & 0xff;
    [sb appendFormat:@"%C", (unichar)ch];
  }
}

+ (void)encodeNumeric:(NSString *)msg startpos:(int)startpos count:(int)count buffer:(NSMutableString *)sb {
  int idx = 0;
  NSMutableString *tmp = [NSMutableString stringWithCapacity:count / 3 + 1];
  NSDecimalNumber *num900 = [NSDecimalNumber decimalNumberWithDecimal:[[NSNumber numberWithInt:900] decimalValue]];
  NSDecimalNumber *num0 = [NSDecimalNumber decimalNumberWithDecimal:[[NSNumber numberWithInt:0] decimalValue]];
  while (idx < count) {
    [tmp setString:@""];
    int len = MIN(44, count - idx);
    NSString *part = [@"1" stringByAppendingString:[msg substringWithRange:NSMakeRange(startpos + idx, len)]];
    NSDecimalNumber *bigint = [NSDecimalNumber decimalNumberWithString:part];
    do {
      NSRoundingMode roundingMode = ((bigint.floatValue < 0) ^ (num900.floatValue < 0)) ? NSRoundUp : NSRoundDown;
      NSDecimalNumber *quotient = [bigint decimalNumberByDividingBy:num900
                                                       withBehavior:[NSDecimalNumberHandler decimalNumberHandlerWithRoundingMode:roundingMode
                                                                                                                           scale:0
                                                                                                                raiseOnExactness:NO
                                                                                                                 raiseOnOverflow:NO
                                                                                                                raiseOnUnderflow:NO
                                                                                                             raiseOnDivideByZero:NO]];

      NSDecimalNumber *subtractAmount = [quotient decimalNumberByMultiplyingBy:num900];
      NSDecimalNumber *remainder = [bigint decimalNumberBySubtracting:subtractAmount];

      [tmp appendFormat:@"%C", (unichar)[remainder longValue]];
      bigint = quotient;
    } while (![bigint isEqualToNumber:num0]);

    //Reverse temporary string
    for (int i = (int)tmp.length - 1; i >= 0; i--) {
      [sb appendFormat:@"%C", [tmp characterAtIndex:i]];
    }
    idx += len;
  }
}

+ (BOOL)isDigit:(unichar)ch {
  return ch >= '0' && ch <= '9';
}

+ (BOOL)isAlphaUpper:(unichar)ch {
  return ch == ' ' || (ch >= 'A' && ch <= 'Z');
}

+ (BOOL)isAlphaLower:(unichar)ch {
  return ch == ' ' || (ch >= 'a' && ch <= 'z');
}

+ (BOOL)isMixed:(unichar)ch {
  return ZX_PDF417_MIXED_TABLE[ch] != 0xFF;
}

+ (BOOL)isPunctuation:(unichar)ch {
  return ZX_PDF417_PUNCTUATION[ch] != 0xFF;
}

+ (BOOL)isText:(unichar)ch {
  return ch == '\t' || ch == '\n' || ch == '\r' || (ch >= 32 && ch <= 126);
}

/**
 * Determines the number of consecutive characters that are encodable using numeric compaction.
 *
 * @param msg      the message
 * @param startpos the start position within the message
 * @return the requested character count
 */
+ (int)determineConsecutiveDigitCount:(NSString *)msg startpos:(int)startpos {
  int count = 0;
  NSUInteger len = msg.length;
  int idx = startpos;
  if (idx < len) {
    char ch = [msg characterAtIndex:idx];
    while ([self isDigit:ch] && idx < len) {
      count++;
      idx++;
      if (idx < len) {
        ch = [msg characterAtIndex:idx];
      }
    }
  }
  return count;
}

/**
 * Determines the number of consecutive characters that are encodable using text compaction.
 *
 * @param msg      the message
 * @param startpos the start position within the message
 * @return the requested character count
 */
+ (int)determineConsecutiveTextCount:(NSString *)msg startpos:(int)startpos {
  NSUInteger len = msg.length;
  int idx = startpos;
  while (idx < len) {
    char ch = [msg characterAtIndex:idx];
    int numericCount = 0;
    while (numericCount < 13 && [self isDigit:ch] && idx < len) {
      numericCount++;
      idx++;
      if (idx < len) {
        ch = [msg characterAtIndex:idx];
      }
    }
    if (numericCount >= 13) {
      return idx - startpos - numericCount;
    }
    if (numericCount > 0) {
      //Heuristic: All text-encodable chars or digits are binary encodable
      continue;
    }
    ch = [msg characterAtIndex:idx];

    //Check if character is encodable
    if (![self isText:ch]) {
      break;
    }
    idx++;
  }
  return idx - startpos;
}

/**
 * Determines the number of consecutive characters that are encodable using binary compaction.
 *
 * @param msg      the message
 * @param bytes    the message converted to a byte array
 * @param startpos the start position within the message
 * @return the requested character count
 */
+ (int)determineConsecutiveBinaryCount:(NSString *)msg bytes:(ZXByteArray *)bytes startpos:(int)startpos error:(NSError **)error {
  NSUInteger len = msg.length;
  int idx = startpos;
  while (idx < len) {
    char ch = [msg characterAtIndex:idx];
    int numericCount = 0;

    while (numericCount < 13 && [self isDigit:ch]) {
      numericCount++;
      //textCount++;
      int i = idx + numericCount;
      if (i >= len) {
        break;
      }
      ch = [msg characterAtIndex:i];
    }
    if (numericCount >= 13) {
      return idx - startpos;
    }
    ch = [msg characterAtIndex:idx];

    //Check if character is encodable
    //Sun returns a ASCII 63 (?) for a character that cannot be mapped. Let's hope all
    //other VMs do the same
    if (bytes.array[idx] == 63 && ch != '?') {
      NSDictionary *userInfo = @{NSLocalizedDescriptionKey: [NSString stringWithFormat:@"Non-encodable character detected: %c (Unicode: %C)", ch, (unichar)ch]};

      if (error) *error = [[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:userInfo];
      return -1;
    }
    idx++;
  }
  return idx - startpos;
}

+ (BOOL)encodingECI:(int)eci sb:(NSMutableString *)sb error:(NSError **)error {
  if (eci >= 0 && eci < 900) {
    [sb appendFormat:@"%C", (unichar) ZX_PDF417_HIGH_LEVEL_ECI_CHARSET];
    [sb appendFormat:@"%C", (unichar) eci];
  } else if (eci < 810900) {
    [sb appendFormat:@"%C", (unichar) ZX_PDF417_HIGH_LEVEL_ECI_GENERAL_PURPOSE];
    [sb appendFormat:@"%C", (unichar) (eci / 900 - 1)];
    [sb appendFormat:@"%C", (unichar) (eci % 900)];
  } else if (eci < 811800) {
    [sb appendFormat:@"%C", (unichar) ZX_PDF417_HIGH_LEVEL_ECI_USER_DEFINED];
    [sb appendFormat:@"%C", (unichar) (810900 - eci)];
  } else {
    NSDictionary *userInfo = @{NSLocalizedDescriptionKey: [NSString stringWithFormat:@"ECI number not in valid range from 0..811799, but was %d", eci]};

    if (error) *error = [[NSError alloc] initWithDomain:ZXErrorDomain code:ZXWriterError userInfo:userInfo];
    return NO;
  }
  return YES;
}

+ (ZXByteArray *)bytesForMessage:(NSString *)msg encoding:(NSStringEncoding)encoding {
  NSData *data = [msg dataUsingEncoding:encoding];
  int8_t *bytes = (int8_t *)[data bytes];
  ZXByteArray *byteArray = [[ZXByteArray alloc] initWithLength:(unsigned int)[data length]];
  memcpy(byteArray.array, bytes, [data length] * sizeof(int8_t));
  return byteArray;
}

@end