checkin for entire port source tree

port_src/output/zxing/oned/coda_bar_writer.rs

@@ -0,0 +1,170 @@
+/*
+ * Copyright 2011 ZXing authors
+ *
+ * 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.
+ */
+// package com::google::zxing::oned;
+
+/**
+ * This class renders CodaBar as {@code boolean[]}.
+ *
+ * @author dsbnatut@gmail.com (Kazuki Nishiura)
+ */
+
+ const START_END_CHARS: vec![Vec<char>; 4] = vec!['A', 'B', 'C', 'D', ]
+;
+
+ const ALT_START_END_CHARS: vec![Vec<char>; 4] = vec!['T', 'N', '*', 'E', ]
+;
+
+ const CHARS_WHICH_ARE_TEN_LENGTH_EACH_AFTER_DECODED: vec![Vec<char>; 4] = vec!['/', ':', '+', '.', ]
+;
+
+ const DEFAULT_GUARD: char = START_END_CHARS[0];
+pub struct CodaBarWriter {
+    super: OneDimensionalCodeWriter;
+}
+
+impl CodaBarWriter {
+
+    pub fn  get_supported_write_formats(&self) -> Collection<BarcodeFormat>  {
+        return Collections::singleton(BarcodeFormat::CODABAR);
+    }
+
+    pub fn  encode(&self,  contents: &String) -> Vec<bool>  {
+        if contents.length() < 2 {
+            // Can't have a start/end guard, so tentatively add default guards
+            contents = format!("{}{}{}", DEFAULT_GUARD, contents, DEFAULT_GUARD);
+        } else {
+            // Verify input and calculate decoded length.
+             let first_char: char = Character::to_upper_case(&contents.char_at(0));
+             let last_char: char = Character::to_upper_case(&contents.char_at(contents.length() - 1));
+             let starts_normal: bool = CodaBarReader::array_contains(&START_END_CHARS, first_char);
+             let ends_normal: bool = CodaBarReader::array_contains(&START_END_CHARS, last_char);
+             let starts_alt: bool = CodaBarReader::array_contains(&ALT_START_END_CHARS, first_char);
+             let ends_alt: bool = CodaBarReader::array_contains(&ALT_START_END_CHARS, last_char);
+            if starts_normal {
+                if !ends_normal {
+                    throw IllegalArgumentException::new(format!("Invalid start/end guards: {}", contents));
+                }
+            // else already has valid start/end
+            } else if starts_alt {
+                if !ends_alt {
+                    throw IllegalArgumentException::new(format!("Invalid start/end guards: {}", contents));
+                }
+            // else already has valid start/end
+            } else {
+                // Doesn't start with a guard
+                if ends_normal || ends_alt {
+                    throw IllegalArgumentException::new(format!("Invalid start/end guards: {}", contents));
+                }
+                // else doesn't end with guard either, so add a default
+                contents = format!("{}{}{}", DEFAULT_GUARD, contents, DEFAULT_GUARD);
+            }
+        }
+        // The start character and the end character are decoded to 10 length each.
+         let result_length: i32 = 20;
+         {
+             let mut i: i32 = 1;
+            while i < contents.length() - 1 {
+                {
+                    if Character::is_digit(&contents.char_at(i)) || contents.char_at(i) == '-' || contents.char_at(i) == '$' {
+                        result_length += 9;
+                    } else if CodaBarReader::array_contains(&CHARS_WHICH_ARE_TEN_LENGTH_EACH_AFTER_DECODED, &contents.char_at(i)) {
+                        result_length += 10;
+                    } else {
+                        throw IllegalArgumentException::new(format!("Cannot encode : '{}\'", contents.char_at(i)));
+                    }
+                }
+                i += 1;
+             }
+         }
+
+        // A blank is placed between each character.
+        result_length += contents.length() - 1;
+         let mut result: [bool; result_length] = [false; result_length];
+         let mut position: i32 = 0;
+         {
+             let mut index: i32 = 0;
+            while index < contents.length() {
+                {
+                     let mut c: char = Character::to_upper_case(&contents.char_at(index));
+                    if index == 0 || index == contents.length() - 1 {
+                        // The start/end chars are not in the CodaBarReader.ALPHABET.
+                        match c {
+                              'T' => 
+                                 {
+                                    c = 'A';
+                                    break;
+                                }
+                              'N' => 
+                                 {
+                                    c = 'B';
+                                    break;
+                                }
+                              '*' => 
+                                 {
+                                    c = 'C';
+                                    break;
+                                }
+                              'E' => 
+                                 {
+                                    c = 'D';
+                                    break;
+                                }
+                        }
+                    }
+                     let mut code: i32 = 0;
+                     {
+                         let mut i: i32 = 0;
+                        while i < CodaBarReader::ALPHABET::len() {
+                            {
+                                // Found any, because I checked above.
+                                if c == CodaBarReader::ALPHABET[i] {
+                                    code = CodaBarReader::CHARACTER_ENCODINGS[i];
+                                    break;
+                                }
+                            }
+                            i += 1;
+                         }
+                     }
+
+                     let mut color: bool = true;
+                     let mut counter: i32 = 0;
+                     let mut bit: i32 = 0;
+                    while bit < 7 {
+                        // A character consists of 7 digit.
+                        result[position] = color;
+                        position += 1;
+                        if ((code >> (6 - bit)) & 1) == 0 || counter == 1 {
+                            // Flip the color.
+                            color = !color;
+                            bit += 1;
+                            counter = 0;
+                        } else {
+                            counter += 1;
+                        }
+                    }
+                    if index < contents.length() - 1 {
+                        result[position] = false;
+                        position += 1;
+                    }
+                }
+                index += 1;
+             }
+         }
+
+        return result;
+    }
+}
+