Add PdfFont#appendDecodedCodesToGlyphsList methods to get success status of decoding to glyph line

DEVSIX-5102

Autoported commit.
Original commit hash: [ded92fc11]

Author: yulian-gaponenko

itext/itext.kernel/itext/kernel/font/PdfFont.cs

@@ -159,18 +159,37 @@ public virtual bool ContainsGlyph(int unicode) {
         public abstract String Decode(PdfString content);
 
         /// <summary>
-        /// Decodes a given
-        /// <see cref="iText.Kernel.Pdf.PdfString"/>
-        /// containing encoded string (e.g. from content stream) into a
+        /// Decodes sequence of character codes (e.g. from content stream) into a
         /// <see cref="iText.IO.Font.Otf.GlyphLine"/>
         /// </summary>
-        /// <param name="content">the encoded string</param>
+        /// <param name="characterCodes">
+        /// the string which is interpreted as a sequence of character codes. Note, that
+        /// <see cref="iText.Kernel.Pdf.PdfString"/>
+        /// acts as a storage for char code values specific to given font, therefore
+        /// individual character codes must not be interpreted as code units of the UTF-16 encoding
+        /// </param>
         /// <returns>
         /// the
         /// <see cref="iText.IO.Font.Otf.GlyphLine"/>
         /// containing the glyphs encoded by the passed string
         /// </returns>
-        public abstract GlyphLine DecodeIntoGlyphLine(PdfString content);
+        public abstract GlyphLine DecodeIntoGlyphLine(PdfString characterCodes);
+
+        /// <summary>
+        /// Decodes sequence of character codes (e.g. from content stream) to sequence of glyphs
+        /// and appends them to the passed list.
+        /// </summary>
+        /// <param name="list">the list to the end of which decoded glyphs are to be added</param>
+        /// <param name="characterCodes">
+        /// the string which is interpreted as a sequence of character codes. Note, that
+        /// <see cref="iText.Kernel.Pdf.PdfString"/>
+        /// acts as a storage for char code values specific to given font, therefore
+        /// individual character codes must not be interpreted as code units of the UTF-16 encoding
+        /// </param>
+        /// <returns>true if all codes where successfully decoded, false otherwise</returns>
+        public virtual bool AppendDecodedCodesToGlyphsList(IList<Glyph> list, PdfString characterCodes) {
+            return false;
+        }
 
         public abstract float GetContentWidth(PdfString content);
 

itext/itext.kernel/itext/kernel/font/PdfSimpleFont.cs

@@ -43,6 +43,7 @@ source product.
 */
 using System;
 using System.Collections.Generic;
+using Common.Logging;
 using iText.IO.Font;
 using iText.IO.Font.Cmap;
 using iText.IO.Font.Constants;
@@ -171,6 +172,17 @@ public virtual FontEncoding GetFontEncoding() {
             return fontEncoding;
         }
 
+        /// <summary>Get the mapping of character codes to unicode values based on /ToUnicode entry of font dictionary.
+        ///     </summary>
+        /// <returns>
+        /// the
+        /// <see cref="iText.IO.Font.Cmap.CMapToUnicode"/>
+        /// built based on /ToUnicode, or null if /ToUnicode is not available
+        /// </returns>
+        public virtual CMapToUnicode GetToUnicode() {
+            return toUnicode;
+        }
+
         public override byte[] ConvertToBytes(String text) {
             byte[] bytes = fontEncoding.ConvertToBytes(text);
             foreach (byte b in bytes) {
@@ -256,35 +268,51 @@ public override String Decode(PdfString content) {
 
         /// <summary><inheritDoc/></summary>
         public override GlyphLine DecodeIntoGlyphLine(PdfString content) {
-            byte[] contentBytes = content.GetValueBytes();
-            IList<Glyph> glyphs = new List<Glyph>(contentBytes.Length);
+            IList<Glyph> glyphs = new List<Glyph>(content.GetValue().Length);
+            AppendDecodedCodesToGlyphsList(glyphs, content);
+            return new GlyphLine(glyphs);
+        }
+
+        /// <summary><inheritDoc/></summary>
+        public override bool AppendDecodedCodesToGlyphsList(IList<Glyph> list, PdfString characterCodes) {
+            bool allCodesDecoded = true;
+            FontEncoding enc = GetFontEncoding();
+            byte[] contentBytes = characterCodes.GetValueBytes();
             foreach (byte b in contentBytes) {
                 int code = b & 0xff;
                 Glyph glyph = null;
-                if (toUnicode != null && toUnicode.Lookup(code) != null && (glyph = fontProgram.GetGlyphByCode(code)) != null
-                    ) {
-                    if (!JavaUtil.ArraysEquals(toUnicode.Lookup(code), glyph.GetChars())) {
+                CMapToUnicode toUnicodeCMap = GetToUnicode();
+                if (toUnicodeCMap != null && toUnicodeCMap.Lookup(code) != null && (glyph = GetFontProgram().GetGlyphByCode
+                    (code)) != null) {
+                    if (!JavaUtil.ArraysEquals(toUnicodeCMap.Lookup(code), glyph.GetChars())) {
                         // Copy the glyph because the original one may be reused (e.g. standard Helvetica font program)
                         glyph = new Glyph(glyph);
-                        glyph.SetChars(toUnicode.Lookup(code));
+                        glyph.SetChars(toUnicodeCMap.Lookup(code));
                     }
                 }
                 else {
-                    int uni = fontEncoding.GetUnicode(code);
+                    int uni = enc.GetUnicode(code);
                     if (uni > -1) {
                         glyph = GetGlyph(uni);
                     }
                     else {
-                        if (fontEncoding.GetBaseEncoding() == null) {
-                            glyph = fontProgram.GetGlyphByCode(code);
+                        if (enc.GetBaseEncoding() == null) {
+                            glyph = GetFontProgram().GetGlyphByCode(code);
                         }
                     }
                 }
                 if (glyph != null) {
-                    glyphs.Add(glyph);
+                    list.Add(glyph);
+                }
+                else {
+                    ILog logger = LogManager.GetLogger(this.GetType());
+                    if (logger.IsWarnEnabled) {
+                        logger.Warn(MessageFormatUtil.Format(iText.IO.LogMessageConstant.COULD_NOT_FIND_GLYPH_WITH_CODE, code));
+                    }
+                    allCodesDecoded = false;
                 }
             }
-            return new GlyphLine(glyphs);
+            return allCodesDecoded;
         }
 
         public override float GetContentWidth(PdfString content) {

itext/itext.kernel/itext/kernel/font/PdfType0Font.cs

@@ -55,6 +55,9 @@ source product.
 
 namespace iText.Kernel.Font {
     public class PdfType0Font : PdfFont {
+        /// <summary>The code length shall not be greater than 4.</summary>
+        private const int MAX_CID_CODE_LENGTH = 4;
+
         private static readonly byte[] rotbits = new byte[] { (byte)0x80, (byte)0x40, (byte)0x20, (byte)0x10, (byte
             )0x08, (byte)0x04, (byte)0x02, (byte)0x01 };
 
@@ -533,52 +536,63 @@ public override String Decode(PdfString content) {
         }
 
         /// <summary><inheritDoc/></summary>
-        public override GlyphLine DecodeIntoGlyphLine(PdfString content) {
-            //A sequence of one or more bytes shall be extracted from the string and matched against the codespace
-            //ranges in the CMap. That is, the first byte shall be matched against 1-byte codespace ranges; if no match is
-            //found, a second byte shall be extracted, and the 2-byte code shall be matched against 2-byte codespace
-            //ranges. This process continues for successively longer codes until a match is found or all codespace ranges
-            //have been tested. There will be at most one match because codespace ranges shall not overlap.
-            String cids = content.GetValue();
+        public override GlyphLine DecodeIntoGlyphLine(PdfString characterCodes) {
             IList<Glyph> glyphs = new List<Glyph>();
-            for (int i = 0; i < cids.Length; i++) {
-                //The code length shall not be greater than 4.
+            AppendDecodedCodesToGlyphsList(glyphs, characterCodes);
+            return new GlyphLine(glyphs);
+        }
+
+        /// <summary><inheritDoc/></summary>
+        public override bool AppendDecodedCodesToGlyphsList(IList<Glyph> list, PdfString characterCodes) {
+            bool allCodesDecoded = true;
+            String charCodesSequence = characterCodes.GetValue();
+            // A sequence of one or more bytes shall be extracted from the string and matched against the codespace
+            // ranges in the CMap. That is, the first byte shall be matched against 1-byte codespace ranges; if no match is
+            // found, a second byte shall be extracted, and the 2-byte code shall be matched against 2-byte codespace
+            // ranges. This process continues for successively longer codes until a match is found or all codespace ranges
+            // have been tested. There will be at most one match because codespace ranges shall not overlap.
+            for (int i = 0; i < charCodesSequence.Length; i++) {
                 int code = 0;
                 Glyph glyph = null;
                 int codeSpaceMatchedLength = 1;
-                for (int codeLength = 1; codeLength <= 4 && i + codeLength <= cids.Length; codeLength++) {
-                    code = (code << 8) + cids[i + codeLength - 1];
-                    if (!cmapEncoding.ContainsCodeInCodeSpaceRange(code, codeLength)) {
+                for (int codeLength = 1; codeLength <= MAX_CID_CODE_LENGTH && i + codeLength <= charCodesSequence.Length; 
+                    codeLength++) {
+                    code = (code << 8) + charCodesSequence[i + codeLength - 1];
+                    if (!GetCmap().ContainsCodeInCodeSpaceRange(code, codeLength)) {
                         continue;
                     }
                     else {
                         codeSpaceMatchedLength = codeLength;
                     }
-                    int glyphCode = cmapEncoding.GetCidCode(code);
-                    glyph = fontProgram.GetGlyphByCode(glyphCode);
+                    int glyphCode = GetCmap().GetCidCode(code);
+                    glyph = GetFontProgram().GetGlyphByCode(glyphCode);
                     if (glyph != null) {
                         i += codeLength - 1;
                         break;
                     }
                 }
                 if (glyph == null) {
-                    StringBuilder failedCodes = new StringBuilder();
-                    for (int codeLength = 1; codeLength <= 4 && i + codeLength <= cids.Length; codeLength++) {
-                        failedCodes.Append((int)cids[i + codeLength - 1]).Append(" ");
-                    }
                     ILog logger = LogManager.GetLogger(typeof(iText.Kernel.Font.PdfType0Font));
-                    logger.Warn(MessageFormatUtil.Format(iText.IO.LogMessageConstant.COULD_NOT_FIND_GLYPH_WITH_CODE, failedCodes
-                        .ToString()));
+                    if (logger.IsWarnEnabled) {
+                        StringBuilder failedCodes = new StringBuilder();
+                        for (int codeLength = 1; codeLength <= MAX_CID_CODE_LENGTH && i + codeLength <= charCodesSequence.Length; 
+                            codeLength++) {
+                            failedCodes.Append((int)charCodesSequence[i + codeLength - 1]).Append(" ");
+                        }
+                        logger.Warn(MessageFormatUtil.Format(iText.IO.LogMessageConstant.COULD_NOT_FIND_GLYPH_WITH_CODE, failedCodes
+                            .ToString()));
+                    }
                     i += codeSpaceMatchedLength - 1;
                 }
                 if (glyph != null && glyph.GetChars() != null) {
-                    glyphs.Add(glyph);
+                    list.Add(glyph);
                 }
                 else {
-                    glyphs.Add(new Glyph(0, fontProgram.GetGlyphByCode(0).GetWidth(), -1));
+                    list.Add(new Glyph(0, GetFontProgram().GetGlyphByCode(0).GetWidth(), -1));
+                    allCodesDecoded = false;
                 }
             }
-            return new GlyphLine(glyphs);
+            return allCodesDecoded;
         }
 
         public override float GetContentWidth(PdfString content) {

itext/itext.kernel/itext/kernel/font/PdfType3Font.cs

@@ -388,9 +388,9 @@ private void AddGlyphsFromCharProcs(PdfDictionary charProcsDic, int[] widths) {
                 return;
             }
             IDictionary<int, int?> unicodeToCode = null;
-            if (toUnicode != null) {
+            if (GetToUnicode() != null) {
                 try {
-                    unicodeToCode = toUnicode.CreateReverseMapping();
+                    unicodeToCode = GetToUnicode().CreateReverseMapping();
                 }
                 catch (Exception) {
                 }

port-hash

@@ -1 +1 @@
-79e8eb90e75984beab3aa95b2aebeb8bd30e54da
+ded92fc117a2041b90240ff26a2d1795c7763630