Ledger Nano X - The secure hardware wallet
SHARE
TWEET

Untitled

a guest Apr 3rd, 2020 227 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using System.IO;
  3. using System.Collections.Generic;
  4. using System.Text;
  5.  
  6. namespace _2
  7. {
  8.     public class TagList
  9.     {
  10.         public String list;
  11.         public String filePath;
  12.        
  13.  
  14.         public TagList(String path = null) { filePath = path; }
  15.  
  16.         public String Open(String tagName, int level, String value = null)
  17.         {
  18.             String shift = new String('\t', level);
  19.             list += String.Format("\n{0}<{1}>", shift, tagName);
  20.             if (!(value is null))
  21.                 Value(value, level);
  22.             return list;
  23.         }
  24.         public String Close(String tagName, int level)
  25.         {
  26.             String shift = new String('\t', level);
  27.             list += String.Format("\n{0}</{1}>", shift, tagName);
  28.             return list;
  29.         }
  30.  
  31.         public String Insert(String tagName, int level, String value, bool newLine = false)
  32.         {
  33.             String shift = new String('\t', level);
  34.             String enter = newLine ? "\n" : "";
  35.             list += String.Format("{0}{1}<{2}>{3}</{2}>{0}", enter, shift, tagName, value);
  36.             return list;
  37.         }
  38.  
  39.         public String Value(String value, int level = 0)
  40.         {
  41.             String shift = new String('\t', level);
  42.             list += '\n' + shift + value;
  43.             return list;
  44.         }
  45.  
  46.         public void Write(String path = null)
  47.         {
  48.             if (path is null)
  49.                 path = this.filePath;
  50.             using (FileStream fs = File.Open(path, FileMode.OpenOrCreate, FileAccess.Write))
  51.             {
  52.                 byte[] bytes = System.Text.Encoding.Default.GetBytes(list);
  53.                 fs.Write(bytes, 0, bytes.Length);
  54.             }
  55.         }
  56.  
  57.         public String Show() => list;
  58.         public void Clear() { list = new String(""); }
  59.         public String NewLine(int count = 0) => list += new String('\n', count);
  60.  
  61.         public static String GetBetween(String strSource, String strStart, String strEnd)
  62.         {
  63.             int Start, End;
  64.             if (strSource.Contains(strStart) && strSource.Contains(strEnd))
  65.             {
  66.                 Start = strSource.IndexOf(strStart, 0) + strStart.Length;
  67.                 End = strSource.IndexOf(strEnd, Start);
  68.                 return strSource.Substring(Start, End - Start);
  69.             }
  70.             else
  71.             {
  72.                 return "";
  73.             }
  74.         }
  75.  
  76.         public static int GetShift(String tagName)
  77.         {
  78.             int start = tagName.IndexOf("_", 0) + 1;
  79.             return int.Parse(tagName.Substring(start, tagName.Length-start)) - 1;
  80.         }
  81.  
  82.         public static List<((String, int), String)> Parse(String path="")
  83.         {
  84.             //String[] lines = new String[6]{"<tag_1>", "\t1", "\t<tag_2>", "\t\t2", "\t</tag_2>", "</tag_1>" };
  85.             String[] lines = File.ReadAllLines(path, Encoding.UTF8);
  86.             var tuples = new List<((String, int), String)>();
  87.  
  88.             //drop empty lines
  89.             int j = -1;
  90.             String emptyName = "";
  91.             do
  92.             {
  93.                 j++;
  94.                 emptyName = GetBetween(lines[j], "<", ">");
  95.             } while (emptyName == "" && lines.Length != j);
  96.  
  97.             //fill tags
  98.             for (int i = j; i < lines.Length; i++)
  99.             {
  100.                 String tagName = GetBetween(lines[i], "<", ">");
  101.                 int shift = GetShift(tagName);
  102.                 String tagValue = "";
  103.                 if (tagName[0] != '/')
  104.                 {
  105.                     String localTagName = "";
  106.                     do
  107.                     {
  108.                         i++;
  109.                         localTagName = GetBetween(lines[i], "<", ">");
  110.                         if (localTagName == "")
  111.                         {
  112.                             if (tagValue != "")
  113.                                 tagValue += '\n';
  114.                             tagValue += lines[i];
  115.                         }
  116.                     } while (localTagName == "" && lines.Length != i);
  117.                     i--;
  118.                 }
  119.                 tuples.Add(((tagName,shift),tagValue));
  120.             }
  121.             return tuples;
  122.         }
  123.  
  124.     }
  125.  
  126.     class Program
  127.     {
  128.         static void Main(string[] args)
  129.         {
  130.             //Exercise 1
  131.             Console.WriteLine(CreateTagFile("file.txt"));
  132.             //Exercise 2
  133.             Console.WriteLine(WriteParsedTagsWithInsert("file.txt","file2.txt"));
  134.             Console.WriteLine(WriteParsedValues("file2.txt","file3.txt"));
  135.         }
  136.  
  137.         static public String CreateTagFile(String path)
  138.         {
  139.             Console.WriteLine("CreateTagFile");
  140.             Console.WriteLine(new String('-', 20));
  141.             TagList tagList = new TagList();
  142.             for (int i = 0; i < 10; i++)
  143.             {
  144.                 tagList.Open($"tag_{i + 1}", i);
  145.                 tagList.Value(Convert.ToString(i + 1), i + 1);
  146.             }
  147.             for (int i = 9; i >= 0; i--)
  148.             {
  149.                 tagList.Close($"tag_{i + 1}", i);
  150.             }
  151.             tagList.Write(path);
  152.             return tagList.Show();
  153.         }
  154.  
  155.         static public String WriteParsedTagsWithInsert(String read_path, String save_path, int couple_tags=5, String value="insert value")
  156.         {
  157.             Console.WriteLine("WriteParsedTagsWithInsert");
  158.             Console.WriteLine(new String('-', 20));
  159.             TagList tagList = new TagList();
  160.             var tuples = TagList.Parse(read_path);
  161.             for (int i = 0; i < tuples.Count; i++)
  162.             {
  163.                 String tagName = tuples[i].Item1.Item1;
  164.                 int level = tuples[i].Item1.Item2;
  165.                 String tagValeus = tuples[i].Item2;
  166.                 if (tagName[0] != '/')
  167.                 {
  168.                     tagList.Open(tagName, level);
  169.                     tagList.Value(tagValeus);
  170.                     if (i+1 == couple_tags)
  171.                     {
  172.                         tagList.Value(value, level+1);
  173.                     }
  174.                 }
  175.                 else
  176.                 {
  177.                     tagList.Close(tagName.Substring(1,tagName.Length-1), level);
  178.                 }
  179.             }
  180.             tagList.Write(save_path);
  181.             return tagList.Show();
  182.         }
  183.  
  184.         static public String WriteParsedValues(String read_path, String save_path)
  185.         {
  186.             Console.WriteLine("WriteParsedValues");
  187.             Console.WriteLine(new String('-', 20));
  188.             TagList tagList = new TagList();
  189.             var tuples = TagList.Parse(read_path);
  190.             for (int i = 0; i < tuples.Count; i++)
  191.             {
  192.                 String tagName = tuples[i].Item1.Item1;
  193.                 int level = tuples[i].Item1.Item2;
  194.                 String tagValeus = tuples[i].Item2;
  195.                 if (tagName[0] != '/')
  196.                 {
  197.                     tagList.Value(tagValeus);
  198.                 }
  199.             }
  200.             tagList.Write(save_path);
  201.             return tagList.Show();
  202.         }
  203.     }
  204. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top