use tryget rather than lambdas for union type

avoid the allocations caused by lambda expressions for performance reasons.

src/UglyToad.PdfPig.Core/Union.cs

@@ -19,6 +19,16 @@ namespace UglyToad.PdfPig.Core
         /// </summary>
         public abstract TResult Match<TResult>(Func<A, TResult> first, Func<B, TResult> second);
 
+        /// <summary>
+        /// Get the item if it is of the specific type.
+        /// </summary>
+        public abstract bool TryGetFirst(out A a);
+
+        /// <summary>
+        /// Get the item if it is of the specific type.
+        /// </summary>
+        public abstract bool TryGetSecond(out B b);
+
         private Union() { }
 
         /// <summary>
@@ -69,6 +79,20 @@ namespace UglyToad.PdfPig.Core
                 return first(Item);
             }
 
+            /// <inheritdoc />
+            public override bool TryGetFirst(out A a)
+            {
+                a = Item;
+                return true;
+            }
+
+            /// <inheritdoc />
+            public override bool TryGetSecond(out B b)
+            {
+                b = default(B);
+                return false;
+            }
+
             /// <inheritdoc />
             public override string ToString()
             {
@@ -108,6 +132,20 @@ namespace UglyToad.PdfPig.Core
                 return second(Item);
             }
 
+            /// <inheritdoc />
+            public override bool TryGetFirst(out A a)
+            {
+                a = default(A);
+                return false;
+            }
+
+            /// <inheritdoc />
+            public override bool TryGetSecond(out B b)
+            {
+                b = Item;
+                return true;
+            }
+
             /// <inheritdoc />
             public override string ToString()
             {

src/UglyToad.PdfPig.Fonts/CompactFontFormat/CompactFontFormatFont.cs

@@ -48,21 +48,26 @@
             var defaultWidthX = GetDefaultWidthX(characterName);
             var nominalWidthX = GetNominalWidthX(characterName);
 
-            var result = CharStrings.Match(x => throw new NotImplementedException("Type 1 CharStrings in a CFF font are currently unsupported."),
+            if (CharStrings.TryGetFirst(out var _))
-                x =>
+            {
-                {
+                throw new NotImplementedException("Type 1 CharStrings in a CFF font are currently unsupported.");
-                    var glyph = x.Generate(characterName, (double)defaultWidthX, (double)nominalWidthX);
+            }
-                    var rectangle = glyph.Path.GetBoundingRectangle();
-                    if (rectangle.HasValue)
-                    {
-                        return rectangle;
-                    }
 
-                    var defaultBoundingBox = TopDictionary.FontBoundingBox;
+            if (!CharStrings.TryGetSecond(out var type2CharStrings))
-                    return new PdfRectangle(0, 0, glyph.Width.GetValueOrDefault(), defaultBoundingBox.Height);
+            {
-                });
+                return null;
+            }
+
+            var glyph = type2CharStrings.Generate(characterName, (double)defaultWidthX, (double)nominalWidthX);
+            var rectangle = glyph.Path.GetBoundingRectangle();
+            if (rectangle.HasValue)
+            {
+                return rectangle;
+            }
+
+            var defaultBoundingBox = TopDictionary.FontBoundingBox;
+            return new PdfRectangle(0, 0, glyph.Width.GetValueOrDefault(), defaultBoundingBox.Height);
 
-            return result;
         }
 
         /// <summary>
@@ -88,8 +93,8 @@
         public IReadOnlyList<CompactFontFormatPrivateDictionary> PrivateDictionaries { get; }
         public ICompactFontFormatFdSelect FdSelect { get; }
 
-        public CompactFontFormatCidFont(CompactFontFormatTopLevelDictionary topDictionary, CompactFontFormatPrivateDictionary privateDictionary, 
+        public CompactFontFormatCidFont(CompactFontFormatTopLevelDictionary topDictionary, CompactFontFormatPrivateDictionary privateDictionary,
-            ICompactFontFormatCharset charset, 
+            ICompactFontFormatCharset charset,
             Union<Type1CharStrings, Type2CharStrings> charStrings,
             IReadOnlyList<CompactFontFormatTopLevelDictionary> fontDictionaries,
             IReadOnlyList<CompactFontFormatPrivateDictionary> privateDictionaries,

src/UglyToad.PdfPig.Fonts/CompactFontFormat/CompactFontFormatFontCollection.cs

@@ -2,7 +2,6 @@
 {
     using System;
     using System.Collections.Generic;
-    using System.Linq;
     using Core;
 
     /// <summary>
@@ -21,6 +20,11 @@
         /// </summary>
         public IReadOnlyDictionary<string, CompactFontFormatFont> Fonts { get; }
 
+        /// <summary>
+        /// The first font contained in the collection.
+        /// </summary>
+        public CompactFontFormatFont FirstFont { get; }
+
         /// <summary>
         /// Create a new <see cref="CompactFontFormatFontCollection"/>.
         /// </summary>
@@ -30,6 +34,11 @@
         {
             Header = header;
             Fonts = fontSet ?? throw new ArgumentNullException(nameof(fontSet));
+            foreach (var pair in fontSet)
+            {
+                FirstFont = pair.Value;
+                break;
+            }
         }
 
         /// <summary>
@@ -50,7 +59,7 @@
         /// </summary>
         public PdfRectangle? GetCharacterBoundingBox(string characterName)
         {
-            return Fonts.First().Value.GetCharacterBoundingBox(characterName);
+            return FirstFont.GetCharacterBoundingBox(characterName);
         }
 
         /// <summary>
@@ -58,7 +67,7 @@
         /// </summary>
         public string GetCharacterName(int characterCode)
         {
-            var font = Fonts.First().Value;
+            var font = FirstFont;
 
             if (font.Encoding != null)
             {

src/UglyToad.PdfPig.Fonts/Type1/CharStrings/Commands/Arithmetic/CallSubrCommand.cs

@@ -23,8 +23,14 @@
 
             foreach (var command in subroutine.Commands)
             {
-                command.Match(x => context.Stack.Push(x),
+                if (command.TryGetFirst(out var num))
-                    x => x.Run(context));
+                {
+                    context.Stack.Push(num);
+                }
+                else if (command.TryGetSecond(out var lazyCommand))
+                {
+                    lazyCommand.Run(context);
+                }
             }
         }
     }

src/UglyToad.PdfPig.Fonts/Type1/CharStrings/Type1CharStrings.cs

@@ -92,8 +92,14 @@
 
             foreach (var command in sequence.Commands)
             {
-                command.Match(x => context.Stack.Push(x),
+                if (command.TryGetFirst(out var num))
-                    x => x.Run(context));
+                {
+                    context.Stack.Push(num);
+                }
+                else if (command.TryGetSecond(out var lazyCommand))
+                {
+                    lazyCommand.Run(context);
+                }
             }
 
             return context.Path;

src/UglyToad.PdfPig/Content/PageContent.cs

@@ -54,10 +54,14 @@
         {
             foreach (var image in images)
             {
-                var result = image.Match<IPdfImage>(x => XObjectFactory.ReadImage(x, pdfScanner, filterProvider, resourceStore),
+                if (image.TryGetFirst(out var xObjectContentRecord))
-                    x => x);
+                {
-
+                    yield return XObjectFactory.ReadImage(xObjectContentRecord, pdfScanner, filterProvider, resourceStore);
-                yield return result;
+                }
+                else if (image.TryGetSecond(out var inlineImage))
+                {
+                    yield return inlineImage;
+                }
             }
         }
 

src/UglyToad.PdfPig/PdfFonts/CidFonts/PdfCidCompactFontFormatFont.cs

@@ -71,7 +71,7 @@
                 throw new NotSupportedException("Multiple fonts in a CFF");
             }
 #endif
-            return fontCollection.Fonts.First().Value;
+            return fontCollection.FirstFont;
         }
     }
 }

src/UglyToad.PdfPig/PdfFonts/Parser/Handlers/Type1FontHandler.cs

@@ -1,6 +1,5 @@
 namespace UglyToad.PdfPig.PdfFonts.Parser.Handlers
 {
-    using System.Linq;
     using Cmap;
     using Core;
     using Filters;
@@ -101,21 +100,25 @@
                 }
             }
 
-            Encoding fromFont = font?.Match(x => x.Encoding != null ? new BuiltInEncoding(x.Encoding) : default(Encoding), x =>
+
+            var fromFont = default(Encoding);
+            if (font != null)
             {
-                if (x.Fonts != null && x.Fonts.Count > 0)
+                if (font.TryGetFirst(out var t1Font))
                 {
-                    return x.Fonts.First().Value.Encoding;
+                    fromFont = t1Font.Encoding != null ? new BuiltInEncoding(t1Font.Encoding) : default(Encoding);
                 }
+                else if (font.TryGetSecond(out var cffFont))
+                {
+                    fromFont = cffFont.FirstFont?.Encoding;
+                }
+            }
 
-                return default(Encoding);
+            var encoding = encodingReader.Read(dictionary, descriptor, fromFont);
-            });
 
-            Encoding encoding = encodingReader.Read(dictionary, descriptor, fromFont);
+            if (encoding == null && font != null && font.TryGetFirst(out var t1FontReplacment))
-
-            if (encoding == null)
             {
-                font?.Match(x => encoding = new BuiltInEncoding(x.Encoding), _ => { });
+                encoding = new BuiltInEncoding(t1FontReplacment.Encoding);
             }
 
             return new Type1FontSimple(name, firstCharacter, lastCharacter, widths, descriptor, encoding, toUnicodeCMap, font);

src/UglyToad.PdfPig/PdfFonts/Simple/Type1FontSimple.cs

@@ -1,7 +1,6 @@
 namespace UglyToad.PdfPig.PdfFonts.Simple
 {
     using System.Collections.Generic;
-    using System.Linq;
     using Cmap;
     using Composite;
     using Core;
@@ -17,6 +16,8 @@
     /// </summary>
     internal class Type1FontSimple : IFont
     {
+        private static readonly TransformationMatrix DefaultTransformationMatrix = TransformationMatrix.FromValues(0.001, 0, 0, 0.001, 0, 0);
+
         private readonly Dictionary<int, CharacterBoundingBox> cachedBoundingBoxes = new Dictionary<int, CharacterBoundingBox>();
 
         private readonly int firstChar;
@@ -52,8 +53,19 @@
             this.fontProgram = fontProgram;
             this.toUnicodeCMap = new ToUnicodeCMap(toUnicodeCMap);
 
-            var matrix = TransformationMatrix.FromValues(0.001, 0, 0, 0.001, 0, 0);
+            var matrix = DefaultTransformationMatrix;
-            fontProgram?.Match(x => matrix = x.FontMatrix, x => { matrix = x.GetFirstTransformationMatrix(); });
+
+            if (fontProgram != null)
+            {
+                if (fontProgram.TryGetFirst(out var t1Font))
+                {
+                    matrix = t1Font.FontMatrix;
+                }
+                else if (fontProgram.TryGetSecond(out var cffFont))
+                {
+                    matrix = cffFont.GetFirstTransformationMatrix();
+                }
+            }
 
             fontMatrix = matrix;
 
@@ -90,10 +102,11 @@
                     }
 
                     var containsEncoding = false;
-                    var capturedValue = default(string);
+                    if (fontProgram.TryGetFirst(out var t1Font))
-                    fontProgram.Match(x => { containsEncoding = x.Encoding.TryGetValue(characterCode, out capturedValue); },
+                    {
-                        _ => {});
+                        containsEncoding = t1Font.Encoding.TryGetValue(characterCode, out value);
-                    value = capturedValue;
+                    }
+
                     return containsEncoding;
                 }
             }
@@ -163,14 +176,15 @@
                 return new PdfRectangle(0, 0, widths[characterCode - firstChar], 0);
             }
 
-            var rect = fontProgram.Match(x =>
+            PdfRectangle? rect = null;
-                {
+            if (fontProgram.TryGetFirst(out var t1Font))
-                    var name = encoding.GetName(characterCode);
+            {
-                    return x.GetCharacterBoundingBox(name);
+                 var name = encoding.GetName(characterCode);
-                },
+                    rect = t1Font.GetCharacterBoundingBox(name);
-                x =>
+            }
-                {
+            else if (fontProgram.TryGetSecond(out var cffFont))
-                    var first = x.Fonts.First().Value;
+            {
+                    var first = cffFont.FirstFont;
                     string characterName;
                     if (encoding != null)
                     {
@@ -178,11 +192,12 @@
                     }
                     else
                     {
-                        characterName = x.GetCharacterName(characterCode);
+                        characterName = cffFont.GetCharacterName(characterCode);
                     }
 
-                    return first.GetCharacterBoundingBox(characterName);
+                    rect = first.GetCharacterBoundingBox(characterName);
-                });
+            }
+
 
             if (!rect.HasValue)
             {