pszczyg

DecoratorLogger_5Parse

Jul 28th, 2021
936
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System.Collections.Generic;
  2. using System.Diagnostics;
  3. using System.IO;
  4. using Newtonsoft.Json;
  5. using Newtonsoft.Json.Linq;
  6.  
  7. namespace AOP
  8. {
  9.     public class CallerClass
  10.     {
  11.         public List<FunctionInvocationData> GetFunctions(string filePath)
  12.         {
  13.             var fileContain = File.ReadAllText(filePath); //use IFileSystemInteractor instead (see my previous blog posts)
  14.             var parser = new SimpleInvocationJsonParser(
  15.                 new ComplexInvocationJsonParser(
  16.                     new ObsoleteInvocationFileParser(
  17.                         new NullInvocationParser()))); //chaining three actual decorators and one NullObject
  18.             var functions = parser.Parse(fileContain);
  19.             return functions;
  20.         }
  21.     }
  22.  
  23.     public interface IInvocationFileParser
  24.     {
  25.         List<FunctionInvocationData> Parse(string fileContain);
  26.     }
  27.  
  28.     public class ComplexInvocationJsonParser : IInvocationFileParser
  29.     {
  30.         private readonly IInvocationFileParser _innerParser;
  31.         public ComplexInvocationJsonParser(IInvocationFileParser innerParser)
  32.         {
  33.             _innerParser = innerParser;
  34.         }
  35.  
  36.         public List<FunctionInvocationData> Parse(string fileContain)
  37.         {
  38.             try
  39.             {
  40.                 if (string.IsNullOrEmpty(fileContain))
  41.                 {
  42.                     return new List<FunctionInvocationData>();
  43.                 }
  44.  
  45.                 var functions = JsonConvert.DeserializeObject<List<FunctionInvocationData>>(fileContain);
  46.                 return functions; //deserialized correctly, return
  47.             }
  48.             catch
  49.             {
  50.                 return _innerParser.Parse(fileContain); //format invalid, try with another parser
  51.             }
  52.         }
  53.     }
  54.  
  55.     public class SimpleInvocationJsonParser : IInvocationFileParser
  56.     {
  57.         private readonly IInvocationFileParser _innerParser;
  58.         public SimpleInvocationJsonParser(IInvocationFileParser innerParser)
  59.         {
  60.             _innerParser = innerParser;
  61.         }
  62.  
  63.         public List<FunctionInvocationData> Parse(string fileContain)
  64.         {
  65.             try
  66.             {
  67.                 if (string.IsNullOrEmpty(fileContain))
  68.                 {
  69.                     return new List<FunctionInvocationData>();
  70.                 }
  71.                 using (var file = new StringReader(fileContain))
  72.                 {
  73.                     using (var reader = new JsonTextReader(file))
  74.                     {
  75.                         var jToken = JToken.ReadFrom(reader);
  76.                         var rawFunctions = (Dictionary<string, string>[])jToken.ToObject(typeof(Dictionary<string, string>[]));
  77.                         var functions = ToInvocationData(rawFunctions);
  78.                         return functions;
  79.                     }
  80.                 }
  81.             }
  82.             catch
  83.             {
  84.                 return _innerParser.Parse(fileContain);
  85.             }
  86.         }
  87.  
  88.         private List<FunctionInvocationData> ToInvocationData(Dictionary<string, string>[] rawFunctions)
  89.         {
  90.             var functions = new List<FunctionInvocationData>();
  91.  
  92.             (...) //do parsing from strings to custom objects
  93.  
  94.             return functions;
  95.         }
  96.     }
  97.  
  98.     public class ObsoleteInvocationFileParser : IInvocationFileParser
  99.     {
  100.  
  101.         private readonly IInvocationFileParser _innerParser;
  102.  
  103.         public ObsoleteInvocationFileParser(IInvocationFileParser innerParser)
  104.         {
  105.             _innerParser = innerParser;
  106.         }
  107.  
  108.  
  109.         public List<FunctionInvocationData> Parse(string fileContain)
  110.         {
  111.             if (string.IsNullOrEmpty(fileContain))
  112.             {
  113.                 return new List<FunctionInvocationData>();
  114.             }
  115.  
  116.             try
  117.             {
  118.                 (...) //magic related to obsolete way of storing functions in plain text
  119.                 return functions;
  120.             }
  121.             catch
  122.             {
  123.                 return _innerParser.Parse(fileContain);
  124.             }
  125.         }
  126.     }
  127.  
  128.     public class NullInvocationParser : IInvocationFileParser
  129.     {
  130.         public List<FunctionInvocationData> Parse(string fileContain)
  131.         {
  132.             return new List<FunctionInvocationData>();
  133.         }
  134.     }
  135.  
  136.  
  137.     [DebuggerDisplay("{FunctionName} | '{Parameters.Count}' params")]
  138.     public class FunctionInvocationData
  139.     {
  140.         public string FunctionName { get; }
  141.         public List<FunctionInvocationParam> Parameters { get; }
  142.  
  143.         public FunctionInvocationData(string functionName, List<FunctionInvocationParam> parameters = null)
  144.         {
  145.             FunctionName = functionName;
  146.             Parameters = parameters ?? new List<FunctionInvocationParam>();
  147.         }
  148.  
  149.         public void AddParam(string paramName)
  150.         {
  151.             Parameters.Add(new FunctionInvocationParam(paramName, string.Empty));
  152.         }
  153.  
  154.         public void AddParam(string paramName, string paramValue)
  155.         {
  156.             Parameters.Add(new FunctionInvocationParam(paramName, paramValue));
  157.         }
  158.  
  159.         public override string ToString()
  160.         {
  161.             return $"{FunctionName} with params: {string.Join(",", Parameters)}";
  162.         }
  163.     }
  164.  
  165.     [DebuggerDisplay("{Name}:{Value}")]
  166.     public class FunctionInvocationParam
  167.     {
  168.         public string Name { get; }
  169.         public string Value { get; }
  170.  
  171.         public FunctionInvocationParam(string name, string value)
  172.         {
  173.             Name = name;
  174.             Value = value;
  175.         }
  176.  
  177.         public override string ToString()
  178.         {
  179.             return $"{Name}={Value}";
  180.         }
  181.     }
  182. }
  183.  
RAW Paste Data