private void ParsePatches(ParseTreeNode node, FieldData rawData)
 {
     foreach (ParseTreeNode rootEntryNode in node.FindDictEntries(null))
     {
         var s = new BoundaryPatch();
         s.Name = rootEntryNode.GetEntryIdentifier();
         rawData.Patches.Add(s);
         ParsePatch(rootEntryNode.ChildNodes[2], s);
     }
 }
        public override object Read(string path)
        {
            var rawData = new FieldData();
            string txt;
            using (var reader = new StreamReader(path))
            {
                txt = reader.ReadToEnd();
            }

            var formatMatch = Regex.Match(txt, FieldFormatRegex);
            rawData.FieldFormat = (Format)Enum.Parse(typeof(Format), formatMatch.Groups[1].Value);

            var classMatch = Regex.Match(txt, FieldClassRegex);
            rawData.FieldClass = (FieldClass)Enum.Parse(typeof(FieldClass), classMatch.Groups[1].Value);

            var locationMatch = Regex.Match(txt, FieldLocationRegex);
            rawData.FieldLocation = locationMatch.Groups[1].Value;

            var objectMatch = Regex.Match(txt, FieldObjectRegex);
            rawData.FieldObject = objectMatch.Groups[1].Value;

            var dimMatch = Regex.Match(txt, DimRegex);
            rawData.Dimensions.Mass = decimal.Parse(dimMatch.Groups[1].Value);
            rawData.Dimensions.Length = decimal.Parse(dimMatch.Groups[2].Value);
            rawData.Dimensions.Time = decimal.Parse(dimMatch.Groups[3].Value);
            rawData.Dimensions.Temperature = decimal.Parse(dimMatch.Groups[4].Value);
            rawData.Dimensions.Quantity = decimal.Parse(dimMatch.Groups[5].Value);
            rawData.Dimensions.Current = decimal.Parse(dimMatch.Groups[6].Value);
            rawData.Dimensions.LuminousIntensity = decimal.Parse(dimMatch.Groups[7].Value);

            var grammar = new OpenFoamGrammar();
            var parser = new Parser(grammar);
            var tree = parser.Parse(txt);

            foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null))
            {
                var identifier = rootEntryNode.GetEntryIdentifier();
                switch (identifier)
                {
                    case "boundaryField":
                        ParsePatches(rootEntryNode.ChildNodes[2], rawData);
                        break;
                    case "internalField":
                        rawData.InternalFieldType = GetFieldType(rootEntryNode);
                        rawData.InternalFieldValue = GetFieldValue(rootEntryNode.ChildNodes[2].ChildNodes[0]);
                        break;
                }
            }
            return rawData;
        }