public void TestComplexTypes() { RuntimeCsvRepresentation rcr = new RuntimeCsvRepresentation(); rcr.Headers = new CsvHeader[1]; rcr.Headers[0] = new CsvHeader("Contained (NonGraphicalTests.IO.Csv.TypeToDeserialize)"); rcr.Records = new List <string[]>(); rcr.Records.Add(new string[1]); rcr.Records[0][0] = "X = 4"; List <Container> listToPopulate = new List <Container>(); rcr.CreateObjectList(typeof(Container), listToPopulate); if (listToPopulate[0].Contained.X != 4) { throw new Exception("Complex types are not being deserialized properly"); } rcr.Records[0][0] = "AvailableEnemies = (\"Dragon\")"; listToPopulate = new List <Container>(); rcr.CreateObjectList(typeof(Container), listToPopulate); if (listToPopulate[0].Contained.AvailableEnemies[0] != "Dragon") { throw new Exception("Inline lists in complex objects are not deserializing properly"); } }
static RuntimeCsvRepresentation LoadCsv(ReferencedFileSave r) { RuntimeCsvRepresentation rcr = FlatRedBallServices.Load <RuntimeCsvRepresentation>(ElementRuntime.ContentDirectory + r.Name, GluxManager.ContentManagerName); return(rcr); }
internal static List <string> GetMemberNamesFrom(ReferencedFileSave rfs) { List <string> toReturn = new List <string>(); string fileName = rfs.Name; fileName = ProjectManager.MakeAbsolute(fileName); RuntimeCsvRepresentation rcr = CsvFileManager.CsvDeserializeToRuntime( fileName); for (int i = 0; i < rcr.Headers.Length; i++) { string memberName = rcr.Headers[i].Name; if (memberName.Trim().StartsWith("//")) { continue; } memberName = StringFunctions.RemoveWhitespace(memberName); if (memberName.Contains("(")) { memberName = memberName.Substring(0, memberName.IndexOfAny(new char[] { '(' })); } toReturn.Add(memberName); } return(toReturn); }
private string GetCsvContents(EntitySave entity, PlatformerEntityViewModel viewModel) { List <PlatformerValues> values = new List <PlatformerValues>(); foreach (var valuesViewModel in viewModel.PlatformerValues) { values.Add(valuesViewModel.ToValues()); } RuntimeCsvRepresentation rcr = RuntimeCsvRepresentation.FromList(values); var nameHeader = rcr.Headers[0]; nameHeader.IsRequired = true; // Setting it to IsRequired is not sufficient, need to // modify the "Original Text" prop // chop off the closing quote, and add ", required)" nameHeader.OriginalText = nameHeader.OriginalText.Substring(0, nameHeader.OriginalText.Length - 1) + ", required)"; rcr.Headers[0] = nameHeader; var toReturn = rcr.GenerateCsvString(); return(toReturn); }
private static void GetStartingAndCount(RuntimeCsvRepresentation rcr, int requiredIndex, string requiredName, out int startingRow, out int count) { startingRow = -1; count = 0; for (int i = 0; i < rcr.Records.Count; i++) { if (startingRow == -1) { if (rcr.Records[i][requiredIndex] == requiredName) { startingRow = i; count = 1; } } else if (startingRow != -1) { if (string.IsNullOrEmpty(rcr.Records[i][requiredIndex])) { count++; } else { break; } } } }
private void ReadFromStream(BinaryReader reader, string assetName, out RuntimeCsvRepresentation csvOutput) { csvOutput = new FlatRedBall.IO.Csv.RuntimeCsvRepresentation(); int numberOfRows = reader.ReadInt32(); int numberOfColumns = reader.ReadInt32(); csvOutput.Name = assetName; csvOutput.Headers = new CsvHeader[numberOfColumns]; for (int i = 0; i < numberOfColumns; i++) { csvOutput.Headers[i] = new CsvHeader(reader.ReadString()); } csvOutput.Records = new List <string[]>(); for (int row = 0; row < numberOfRows; row++) { string[] record = new string[numberOfColumns]; csvOutput.Records.Add(record); for (int column = 0; column < numberOfColumns; column++) { record[column] = reader.ReadString(); } } }
private static string GetRequiredKeyType(RuntimeCsvRepresentation rcr, List <TypedMemberBase> members, Dictionary <string, string> untypedMembers, int requiredHeader) { // At this point the headers have their proper names (like XOffset) and don't include their type, so we // can use the simple .Name property string requiredMember = rcr.Headers[requiredHeader].Name; string type = null; foreach (TypedMemberBase tmb in members) { if (tmb.MemberName == requiredMember) { type = tmb.MemberType.FullName; break; } } if (string.IsNullOrEmpty(type)) { foreach (KeyValuePair <string, string> kvp in untypedMembers) { if (kvp.Key == requiredMember) { type = kvp.Value; break; } } } return(type); }
private void SetLocalizationDb(string filePath) { GlueCommands.Self.TryMultipleTimes(() => { LocalizationDb = CsvFileManager.CsvDeserializeToRuntime(filePath); }, 5); }
private string GetCsvContents(EntitySave entity, RacingEntityViewModel viewModel) { List <RacingEntityValues> values = new List <RacingEntityValues>(); var defaultValues = new RacingEntityValues(); defaultValues.Name = "DefaultValues"; // leave the defaults from the class values.Add(defaultValues); RuntimeCsvRepresentation rcr = RuntimeCsvRepresentation.FromList(values); var nameHeader = rcr.Headers[0]; // Setting it to IsRequired is not sufficient, need to // modify the "Original Text" prop // chop off the closing quote, and add ", required)" nameHeader.OriginalText = nameHeader.OriginalText.Substring(0, nameHeader.OriginalText.Length - 1) + ", required)"; rcr.Headers[0] = nameHeader; // if we want more defaults here... rcr.Records.Add(new string[0]); var toReturn = rcr.GenerateCsvString(); return(toReturn); }
private static void AddAvailableValuesFromFileToList(string absoluteFile, List <string> stringsToReturn, bool shouldAppendFileName) { if (System.IO.File.Exists(absoluteFile)) { try { string toAppend = ""; if (shouldAppendFileName) { // Eventually we want to make this relative to the container, not just the folename toAppend = " in " + FileManager.RemovePath(absoluteFile); } RuntimeCsvRepresentation rcr = CsvFileManager.CsvDeserializeToRuntime(absoluteFile); rcr.RemoveHeaderWhitespaceAndDetermineIfRequired(); int requiredIndex = -1; for (int i = 0; i < rcr.Headers.Length; i++) { if (rcr.Headers[i].IsRequired) { requiredIndex = i; break; } } if (requiredIndex != -1) { foreach (string[] record in rcr.Records) { string possibleValue = record[requiredIndex]; if (!string.IsNullOrEmpty(possibleValue)) { if (shouldAppendFileName) { stringsToReturn.Add(possibleValue + toAppend); } else { stringsToReturn.Add(possibleValue); } } } } } catch (Exception e) { // do nothing for now... } } }
public static void GetDictionaryTypes(ReferencedFileSave referencedFileSave, out string keyType, out string valueType) { valueType = referencedFileSave.GetTypeForCsvFile(); // To know the value type, we gotta pop this bad boy open and find the first requied type keyType = null; char oldDelimiter = CsvFileManager.Delimiter; switch (referencedFileSave.CsvDelimiter) { case AvailableDelimiters.Comma: CsvFileManager.Delimiter = ','; break; case AvailableDelimiters.Tab: CsvFileManager.Delimiter = '\t'; break; case AvailableDelimiters.Pipe: CsvFileManager.Delimiter = '|'; break; } string absoluteFileName = ProjectManager.MakeAbsolute(referencedFileSave.Name); // If the file doesn't exist this will generate bad code. But this isn't // considered a silent failure because Glue will raise flags about missing // files earlier (like when it first starts up). We don't want to crash the // entire application in this case. if (System.IO.File.Exists(absoluteFileName)) { RuntimeCsvRepresentation rcr = CsvFileManager.CsvDeserializeToRuntime(absoluteFileName); // See if any of the headers are required foreach (CsvHeader header in rcr.Headers) { int indexOfOpeningParen = header.Name.IndexOf("("); if (indexOfOpeningParen != -1) { if (header.Name.IndexOf("required", indexOfOpeningParen) != -1) { keyType = CsvHeader.GetClassNameFromHeader(header.Name); break; } } } } CsvFileManager.Delimiter = oldDelimiter; }
public void TestSerialization() { RuntimeCsvRepresentation rcr = new RuntimeCsvRepresentation(); rcr.Headers = new CsvHeader[4]; rcr.Headers[0] = new CsvHeader("Header1"); rcr.Headers[1] = new CsvHeader("Header2"); rcr.Headers[2] = new CsvHeader("Newline Test1"); rcr.Headers[3] = new CsvHeader("Something"); rcr.Headers[3].IsRequired = true; rcr.Records = new List<string[]>(); rcr.Records.Add(new string[4]); rcr.Records[0][0] = "NoQuotes \"Quotes\" NoQuotes"; rcr.Records[0][1] = "Value = \"Something\""; rcr.Records[0][2] = string.Concat("Line 1", Environment.NewLine, "Line 2"); rcr.Records[0][3] = ""; string result = rcr.GenerateCsvString(); if (!result.Contains("NoQuotes \"\"Quotes\"\" NoQuotes")) { throw new Exception("rcr.GenerateCsvString is not properly adding double quotes for quotes"); } if (!result.Contains("\"Value = \"\"Something\"\"\"")) { throw new Exception("rcr.GenerateCsvString is not properly wrapping text in quotes when it should"); } if (!result.Contains(string.Concat("\"", rcr.Records[0][2], "\""))) { throw new Exception("rcr.GenerateCsvString is not properly wrapping newlined text in quotes"); } FileManager.SaveText(result, "SavedCsv.csv"); RuntimeCsvRepresentation loaded = CsvFileManager.CsvDeserializeToRuntime("SavedCsv.csv"); for (int i = 0; i < loaded.Records.Count; i++) { for (int j = 0; j < loaded.Records[i].Length; j++) { var loadedAtIandJ = loaded.Records[i][j]; var rcrAtIandJ = rcr.Records[i][j]; if (loadedAtIandJ != rcrAtIandJ) { throw new Exception("Loaded RCR doesn't equal what was saved"); } } } }
public void TestSerialization() { RuntimeCsvRepresentation rcr = new RuntimeCsvRepresentation(); rcr.Headers = new CsvHeader[4]; rcr.Headers[0] = new CsvHeader("Header1"); rcr.Headers[1] = new CsvHeader("Header2"); rcr.Headers[2] = new CsvHeader("Newline Test1"); rcr.Headers[3] = new CsvHeader("Something"); rcr.Headers[3].IsRequired = true; rcr.Records = new List <string[]>(); rcr.Records.Add(new string[4]); rcr.Records[0][0] = "NoQuotes \"Quotes\" NoQuotes"; rcr.Records[0][1] = "Value = \"Something\""; rcr.Records[0][2] = string.Concat("Line 1", Environment.NewLine, "Line 2"); rcr.Records[0][3] = ""; string result = rcr.GenerateCsvString(); if (!result.Contains("NoQuotes \"\"Quotes\"\" NoQuotes")) { throw new Exception("rcr.GenerateCsvString is not properly adding double quotes for quotes"); } if (!result.Contains("\"Value = \"\"Something\"\"\"")) { throw new Exception("rcr.GenerateCsvString is not properly wrapping text in quotes when it should"); } if (!result.Contains(string.Concat("\"", rcr.Records[0][2], "\""))) { throw new Exception("rcr.GenerateCsvString is not properly wrapping newlined text in quotes"); } FileManager.SaveText(result, "SavedCsv.csv"); RuntimeCsvRepresentation loaded = CsvFileManager.CsvDeserializeToRuntime("SavedCsv.csv"); for (int i = 0; i < loaded.Records.Count; i++) { for (int j = 0; j < loaded.Records[i].Length; j++) { var loadedAtIandJ = loaded.Records[i][j]; var rcrAtIandJ = rcr.Records[i][j]; if (loadedAtIandJ != rcrAtIandJ) { throw new Exception("Loaded RCR doesn't equal what was saved"); } } } }
static IEnumerable <string> RequiredColumnValues(RuntimeCsvRepresentation rcr) { int requiredHeader = rcr.GetRequiredIndex(); foreach (string[] record in rcr.Records) { string value = record[requiredHeader]; if (!string.IsNullOrEmpty(value) && !value.StartsWith("//")) { yield return(value); } } }
private static string GetClassInfo(string fileName, RuntimeCsvRepresentation rcr, CustomClassSave customClass, out List <TypedMemberBase> members, out Dictionary <string, string> untypedMembers) { bool usesCustomClass = customClass != null; List <RuntimeCsvRepresentation> rcrsForClass = new List <RuntimeCsvRepresentation>(); if (usesCustomClass) { foreach (string name in customClass.CsvFilesUsingThis) { ReferencedFileSave foundRfs = ObjectFinder.Self.GetReferencedFileSaveFromFile(name); if (foundRfs == null) { int m = 3; } else { fileName = foundRfs.Name; fileName = ProjectManager.MakeAbsolute(fileName); RuntimeCsvRepresentation runtimeToAdd = null; try { runtimeToAdd = CsvFileManager.CsvDeserializeToRuntime(fileName); } catch (Exception e) { MessageBox.Show("Error trying to parse CSV:\n" + e.ToString()); } if (runtimeToAdd != null) { rcrsForClass.Add(runtimeToAdd); } } } } else if (rcr != null) { rcrsForClass.Add(rcr); } GetClassInfoFromCsv(rcrsForClass, customClass, out members, out untypedMembers); return(fileName); }
public void TestCsvGeneration() { string nameInCsv = "Name With Spaces and Invalids*~"; string constName = CsvCodeGenerator.GetConstNameForValue(nameInCsv); if (constName.Contains(' ')) { throw new Exception("Const name for CSV is invalid!"); } if (constName.IndexOfAny(NameVerifier.InvalidCharacters) != -1) { throw new Exception("Const name contains invalid characters!"); } Type type = TypeManager.GetTypeFromString("bool"); if (type != typeof(bool)) { throw new Exception("TypeManager is not properly returning type from \"bool\""); } type = TypeManager.GetTypeFromString("System.Boolean"); if (type != typeof(bool)) { throw new Exception("TypeManager is not properly returning type from \"bool\""); } type = TypeManager.GetTypeFromString("Boolean"); if (type != typeof(bool)) { throw new Exception("TypeManager is not properly returning type from \"bool\""); } RuntimeCsvRepresentation rcr = new RuntimeCsvRepresentation(); rcr.Headers = new CsvHeader[2]; rcr.Headers[0].OriginalText = "Variable"; rcr.Headers[1].OriginalText = "Variable (float)"; string why = CsvCodeGenerator.GetWhyCsvIsWrong(rcr, false, null); if (string.IsNullOrEmpty(why)) { throw new Exception("Glue should be reporting errors on CSVs that have duplicate header names (but of different types)"); } }
public static string GetWhyCsvIsWrong(RuntimeCsvRepresentation rcr, bool createsDictionary, string fileName) { string duplicateHeader = null; string duplicateRequiredField = null; duplicateHeader = rcr.GetFirstDuplicateHeader; // Check for duplicates ignoring the type if (createsDictionary) { duplicateRequiredField = rcr.FirstDuplicateRequiredField; } if (!string.IsNullOrEmpty(duplicateHeader)) { return("The CSV file " + fileName + "\n\nhas the following duplicate header.\n\n" + duplicateHeader); } else if (createsDictionary && !string.IsNullOrEmpty(duplicateRequiredField)) { return("The CSV file " + fileName + "\n\nhas a duplicate required field:" + duplicateRequiredField); } // WE also have to check for duplicates with different types but the same name List <string> namesFound = new List <string>(); foreach (var header in rcr.Headers) { string name = CsvHeader.GetNameWithoutParentheses(header.OriginalText); if (!string.IsNullOrEmpty(name)) { if (namesFound.Contains(name)) { return("The CSV file " + fileName + " has a duplicate header: " + name); } else { namesFound.Add(name); } } } return(null); }
internal void CreateAdditionalCsvFile(string name, GlobalOrProjectSpecific globalOrProjectSpecific) { // We're going to load the full // AvailableAssetTypes just to get // the headers. Then we'll // create a new RCR, copy over the headers // then save off the RCR using the argument // fileName. The new one will be empty except // for the headers. RuntimeCsvRepresentation rcr = CsvFileManager.CsvDeserializeToRuntime( mCoreTypesFileLocation); rcr.Records = new List <string[]>(); string desiredFullPath = null; if (globalOrProjectSpecific == GlobalOrProjectSpecific.Global) { desiredFullPath = GlobalCustomContentTypesFolder + name + ".csv"; } else // project-specific { desiredFullPath = ProjectSpecificContentTypesFolder + name + ".csv"; } if (File.Exists(desiredFullPath)) { MessageBox.Show("The CSV " + desiredFullPath + " already exists."); } else { try { CsvFileManager.Serialize(rcr, desiredFullPath); } catch (UnauthorizedAccessException) { MessageBox.Show("Unable to save the CSV file. You need to run Glue as an administrator"); } catch (Exception e) { MessageBox.Show("Unknown error attempting to create the CSV:\n\n" + e.ToString()); } } }
/// <summary> /// Verifies that the CSV is properly set up - this code doesn't generate anything because uniform type CSVs don't actually make /// a new class. They'll instead deserialize to something like string[] /// </summary> /// <param name="rfs">The file reference to the CSV.</param> /// <param name="fileName">The filename of the CSV</param> /// <param name="oldDelimiter">The old CSV delimiter - what to set the CSV delimiter back to after deserializing this CSV.</param> private static void CheckUniformTypeValidity(ReferencedFileSave rfs, string fileName, char oldDelimiter) { string duplicateHeader; RuntimeCsvRepresentation rcr = CsvFileManager.CsvDeserializeToRuntime( fileName); CsvFileManager.Delimiter = oldDelimiter; duplicateHeader = rcr.GetFirstDuplicateHeader; if (rfs.CreatesDictionary) { string duplicateRequiredField = rcr.FirstDuplicateRequiredField; if (!string.IsNullOrEmpty(duplicateRequiredField)) { System.Windows.Forms.MessageBox.Show("The CSV file " + fileName + "\n\nhas a duplicate required field:" + duplicateRequiredField); } } }
private object EvaluateIndexerExpression(ICSharpCode.NRefactory.CSharp.IndexerExpression indexerExpression, CodeContext codeContext) { object evaluatedTarget = EvaluateExpression(indexerExpression.Target, codeContext); if (evaluatedTarget is RuntimeCsvRepresentation) { List <object> evaluatedArguments = new List <object>(); foreach (var argument in indexerExpression.Arguments) { evaluatedArguments.Add(EvaluateExpression(argument, codeContext)); } string requiredKey = evaluatedArguments[0] as string; RuntimeCsvRepresentation rcr = evaluatedTarget as RuntimeCsvRepresentation; return(GetCsvEntryByRequiredKey(requiredKey, rcr)); } return(null); }
private static object GetCsvEntryByRequiredKey(string requiredKey, RuntimeCsvRepresentation rcr) { rcr.RemoveHeaderWhitespaceAndDetermineIfRequired(); int requiredIndex = rcr.GetRequiredIndex(); int startingRow; int count; GetStartingAndCount(rcr, requiredIndex, requiredKey, out startingRow, out count); CsvEntry csvEntry = null; if (startingRow != -1) { csvEntry = new CsvEntry(); csvEntry.RuntimeCsvRepresentation = rcr; csvEntry.Count = count; csvEntry.StartIndex = startingRow; } return(csvEntry); }
private string GetCsvContents(EntitySave entity, TopDownEntityViewModel viewModel) { List <TopDownValues> values = new List <TopDownValues>(); // create a default entry: var defaultValue = new TopDownValues(); defaultValue.Name = "DefaultValues"; defaultValue.MaxSpeed = 250; defaultValue.AccelerationTime = 1; defaultValue.DecelerationTime = .5f; defaultValue.UpdateDirectionFromVelocity = true; values.Add(defaultValue); RuntimeCsvRepresentation rcr = RuntimeCsvRepresentation.FromList(values); var nameHeader = rcr.Headers[0]; nameHeader.IsRequired = true; // Setting it to IsRequired is not sufficient, need to // modify the "Original Text" prop // chop off the closing quote, and add ", required)" nameHeader.OriginalText = nameHeader.OriginalText.Substring(0, nameHeader.OriginalText.Length - 1) + ", required)"; rcr.Headers[0] = nameHeader; var movementDefaults = new string[] { }; rcr.Records.Add(movementDefaults); var toReturn = rcr.GenerateCsvString(); return(toReturn); }
public void TestCreateObjectList() { RuntimeCsvRepresentation rcr = new RuntimeCsvRepresentation(); rcr.Headers = new CsvHeader[3]; rcr.Headers[0] = new CsvHeader("X (float)"); rcr.Headers[1] = new CsvHeader("Visible (bool)"); rcr.Headers[2] = new CsvHeader("AvailableEnemies (List<string>)"); rcr.Records = new List <string[]>(); rcr.Records.Add(new string[3]); rcr.Records[0][0] = "3"; rcr.Records[0][1] = "true"; rcr.Records[0][2] = "Dragon"; List <TypeToDeserialize> listToPopulate = new List <TypeToDeserialize>(); rcr.CreateObjectList(typeof(TypeToDeserialize), listToPopulate); if (listToPopulate[0].AvailableEnemies.Count != 1 || listToPopulate[0].AvailableEnemies[0] != "Dragon") { throw new Exception("Lists are not being deserialized properly"); } }
private static void FillCodeBlockWithKeys(ICodeBlock codeBlock, string keyType, RuntimeCsvRepresentation rcr) { foreach (string value in RequiredColumnValues(rcr)) { string rightSideOfEquals = value; if (keyType == "System.String") { rightSideOfEquals = "\"" + rightSideOfEquals + "\""; } string leftSideOfEquals = GetConstNameForValue(value); codeBlock.Line("public const " + keyType + " " + leftSideOfEquals + " = " + rightSideOfEquals + ";"); } }
private static void DeserializeToRcr(AvailableDelimiters delimiter, string fileName, out RuntimeCsvRepresentation rcr, out bool succeeded) { rcr = null; succeeded = true; try { // Let's load this bad boy and get info about the class we need to make rcr = CsvFileManager.CsvDeserializeToRuntime(fileName); } catch (Exception e) { GlueGui.ShowMessageBox("Error parsing CSV\n\n" + fileName + "\nAttempted to use " + delimiter + " as the delimiter. If this is not the delimiter of the file, try changing the delimiter in Glue after the file is added"); FlatRedBall.Glue.Plugins.PluginManager.ReceiveError(e.ToString()); succeeded = false; } }
private static void FillOrderedListWithKeys(ICodeBlock codeBlock, string type, RuntimeCsvRepresentation rcr) { int numberAdded = 0; foreach (string value in RequiredColumnValues(rcr)) { if (numberAdded == 0) { codeBlock.Line("public static System.Collections.Generic.List<" + type + "> OrderedList = new System.Collections.Generic.List<" + type + ">"); codeBlock.Line("{"); codeBlock.TabCount++; } string name = GetConstNameForValue(value); if (numberAdded != 0) { // This is a little more efficient than doing a count first, then adding codeBlock.Line("," + name); } else { codeBlock.Line(name); } numberAdded++; } if (numberAdded != 0) { codeBlock.TabCount--; codeBlock.Line("};"); } }
private static string GetClassInfoFromCsvs(ReferencedFileSave rfs, string fileName, RuntimeCsvRepresentation rcr, out string className, out List <TypedMemberBase> members, out Dictionary <string, string> untypedMembers) { className = rfs.GetUnqualifiedTypeForCsv(); CustomClassSave customClass = GetCustomClassForCsv(rfs.Name); fileName = GetClassInfo(fileName, rcr, customClass, out members, out untypedMembers); return(fileName); }
public static string GetWhyCsvIsWrong(RuntimeCsvRepresentation rcr, bool createsDictionary, string fileName) { string duplicateHeader = null; string duplicateRequiredField = null; duplicateHeader = rcr.GetFirstDuplicateHeader; // Check for duplicates ignoring the type if (createsDictionary) { duplicateRequiredField = rcr.FirstDuplicateRequiredField; } if (!string.IsNullOrEmpty(duplicateHeader)) { return "The CSV file " + fileName + "\n\nhas the following duplicate header.\n\n" + duplicateHeader; } else if (createsDictionary && !string.IsNullOrEmpty(duplicateRequiredField)) { return "The CSV file " + fileName + "\n\nhas a duplicate required field:" + duplicateRequiredField; } // WE also have to check for duplicates with different types but the same name List<string> namesFound = new List<string>(); foreach (var header in rcr.Headers) { string name = CsvHeader.GetNameWithoutParentheses(header.OriginalText); if (!string.IsNullOrEmpty(name)) { if (namesFound.Contains(name)) { return "The CSV file " + fileName + " has a duplicate header: " + name; } else { namesFound.Add(name); } } } return null; }
private static void GetMembersForRcr(List <TypedMemberBase> members, Dictionary <string, string> untypedMembers, List <string> membersAlreadyAdded, RuntimeCsvRepresentation rcr) { for (int i = 0; i < rcr.Headers.Length; i++) { CsvHeader header = rcr.Headers[i]; string memberName = header.Name; if (string.IsNullOrWhiteSpace(memberName) == false && memberName.Trim().StartsWith("//") == false) { Type type; string classType; GetTypeFromHeader(ref header, ref memberName, out type, out classType); TryAddMember(members, untypedMembers, membersAlreadyAdded, memberName, type, classType); } } }
public void SaveCsv(string fileName) { RuntimeCsvRepresentation rcr = RuntimeCsvRepresentation.FromList <BuildToolAssociation>(this.BuildToolList); CsvFileManager.Serialize(rcr, fileName); }
private static void FillCodeBlockWithKeys(ICodeBlock codeBlock, string keyType, RuntimeCsvRepresentation rcr) { foreach(string value in RequiredColumnValues(rcr)) { string rightSideOfEquals = value; if (keyType == "System.String") { rightSideOfEquals = "\"" + rightSideOfEquals + "\""; } string leftSideOfEquals = GetConstNameForValue(value); codeBlock.Line("public const " + keyType + " " + leftSideOfEquals + " = " + rightSideOfEquals + ";"); } }
static IEnumerable<string> RequiredColumnValues(RuntimeCsvRepresentation rcr) { int requiredHeader = rcr.GetRequiredIndex(); foreach (string[] record in rcr.Records) { string value = record[requiredHeader]; if (!string.IsNullOrEmpty(value) && !value.StartsWith("//")) { yield return value; } } }
private static string GetRequiredKeyType(RuntimeCsvRepresentation rcr, List<TypedMemberBase> members, Dictionary<string, string> untypedMembers, int requiredHeader) { // At this point the headers have their proper names (like XOffset) and don't include their type, so we // can use the simple .Name property string requiredMember = rcr.Headers[requiredHeader].Name; string type = null; foreach (TypedMemberBase tmb in members) { if (tmb.MemberName == requiredMember) { type = tmb.MemberType.FullName; break; } } if (string.IsNullOrEmpty(type)) { foreach (KeyValuePair<string, string> kvp in untypedMembers) { if (kvp.Key == requiredMember) { type = kvp.Value; break; } } } return type; }
private static void GetMembersForRcr(List<TypedMemberBase> members, Dictionary<string, string> untypedMembers, List<string> membersAlreadyAdded, RuntimeCsvRepresentation rcr) { for (int i = 0; i < rcr.Headers.Length; i++) { CsvHeader header = rcr.Headers[i]; string memberName = header.Name; if (string.IsNullOrWhiteSpace(memberName) == false && memberName.Trim().StartsWith("//") == false) { Type type; string classType; GetTypeFromHeader(ref header, ref memberName, out type, out classType); TryAddMember(members, untypedMembers, membersAlreadyAdded, memberName, type, classType); } } }
public static object GetValueFromCsv(string rowValue, string variableName, string csvType, IElement element, ElementRuntime elementRuntime) { // We should check the csvType (which might be a class already). // If we don't get anything back then we should try stripping off // the extension and path object foundValue = null; ReferencedFileSave rfs = ObjectFinder.Self.GetFirstCsvUsingClass(csvType, element); if (rfs == null && FileManager.GetExtension(csvType) == "csv") { string strippedType = FileManager.RemovePath(FileManager.RemoveExtension(csvType)); rfs = ObjectFinder.Self.GetFirstCsvUsingClass(strippedType, element); } if (rfs != null) { RuntimeCsvRepresentation rcr = null; // This could be global content or it could be a RFS in the element if (element.ContainsRecursively(rfs)) { var loadedFile = elementRuntime.LoadReferencedFileSave(rfs, true, element); rcr = loadedFile.RuntimeObject as RuntimeCsvRepresentation; } else { var loadedFile = GluxManager.GlobalContentFilesRuntime.LoadReferencedFileSave(rfs, true, element); // Load this thing from global content rcr = loadedFile.RuntimeObject as RuntimeCsvRepresentation; } if (rcr.GetRequiredIndex() == -1) { rcr.RemoveHeaderWhitespaceAndDetermineIfRequired(); } int indexOfColumn = 0; for (int i = 0; i < rcr.Headers.Length; i++) { if (rcr.Headers[i].Name == variableName) { indexOfColumn = i; break; } } if (rcr != null) { // Right now I'm writing this to only support dictionaries. int indexOfRequired = rcr.GetRequiredIndex(); string[] matchingRecord = null; foreach (string[] record in rcr.Records) { try { if (record.Length > indexOfRequired && record[indexOfRequired] == rowValue) { if (indexOfColumn >= record.Length) { int m = 3; } foundValue = record[indexOfColumn]; foundValue = ConvertValueToType(foundValue, rcr.Headers[indexOfColumn].OriginalText); break; } } catch { int m = 3; } } } } // We need to find a RFS either in this IElement or in GlobalContentFiles that match this name return(foundValue); }
private static string GetClassInfo(string fileName, RuntimeCsvRepresentation rcr, CustomClassSave customClass, out List<TypedMemberBase> members, out Dictionary<string, string> untypedMembers) { bool usesCustomClass = customClass != null; List<RuntimeCsvRepresentation> rcrsForClass = new List<RuntimeCsvRepresentation>(); if (usesCustomClass) { foreach (string name in customClass.CsvFilesUsingThis) { ReferencedFileSave foundRfs = ObjectFinder.Self.GetReferencedFileSaveFromFile(name); if (foundRfs == null) { int m = 3; } else { fileName = foundRfs.Name; fileName = ProjectManager.MakeAbsolute(fileName); RuntimeCsvRepresentation runtimeToAdd = null; try { runtimeToAdd = CsvFileManager.CsvDeserializeToRuntime(fileName); } catch (Exception e) { MessageBox.Show("Error trying to parse CSV:\n" + e.ToString()); } if (runtimeToAdd != null) { rcrsForClass.Add(runtimeToAdd); } } } } else if(rcr != null) { rcrsForClass.Add(rcr); } GetClassInfoFromCsv(rcrsForClass, customClass, out members, out untypedMembers); return fileName; }
public void TestCreateObjectList() { RuntimeCsvRepresentation rcr = new RuntimeCsvRepresentation(); rcr.Headers = new CsvHeader[3]; rcr.Headers[0] = new CsvHeader("X (float)"); rcr.Headers[1] = new CsvHeader("Visible (bool)"); rcr.Headers[2] = new CsvHeader("AvailableEnemies (List<string>)"); rcr.Records = new List<string[]>(); rcr.Records.Add(new string[3]); rcr.Records[0][0] = "3"; rcr.Records[0][1] = "true"; rcr.Records[0][2] = "Dragon"; List<TypeToDeserialize> listToPopulate = new List<TypeToDeserialize>(); rcr.CreateObjectList(typeof(TypeToDeserialize), listToPopulate); if (listToPopulate[0].AvailableEnemies.Count != 1 || listToPopulate[0].AvailableEnemies[0] != "Dragon") { throw new Exception("Lists are not being deserialized properly"); } }
private static string GetClassInfoFromCsvs(ReferencedFileSave rfs, string fileName, RuntimeCsvRepresentation rcr, out string className, out List<TypedMemberBase> members, out Dictionary<string, string> untypedMembers) { className = rfs.GetUnqualifiedTypeForCsv(); CustomClassSave customClass = GetCustomClassForCsv(rfs.Name); fileName = GetClassInfo(fileName, rcr, customClass, out members, out untypedMembers); return fileName; }
public void TestComplexTypes() { RuntimeCsvRepresentation rcr = new RuntimeCsvRepresentation(); rcr.Headers = new CsvHeader[1]; rcr.Headers[0] = new CsvHeader("Contained (NonGraphicalTests.IO.Csv.TypeToDeserialize)"); rcr.Records = new List<string[]>(); rcr.Records.Add(new string[1]); rcr.Records[0][0] = "X = 4"; List<Container> listToPopulate = new List<Container>(); rcr.CreateObjectList(typeof(Container), listToPopulate); if (listToPopulate[0].Contained.X != 4) { throw new Exception("Complex types are not being deserialized properly"); } rcr.Records[0][0] = "AvailableEnemies = (\"Dragon\")"; listToPopulate = new List<Container>(); rcr.CreateObjectList(typeof(Container), listToPopulate); if (listToPopulate[0].Contained.AvailableEnemies[0] != "Dragon") { throw new Exception("Inline lists in complex objects are not deserializing properly"); } }
private static object GetCsvEntryByRequiredKey(string requiredKey, RuntimeCsvRepresentation rcr) { rcr.RemoveHeaderWhitespaceAndDetermineIfRequired(); int requiredIndex = rcr.GetRequiredIndex(); int startingRow; int count; GetStartingAndCount(rcr, requiredIndex, requiredKey, out startingRow, out count); CsvEntry csvEntry = null; if (startingRow != -1) { csvEntry = new CsvEntry(); csvEntry.RuntimeCsvRepresentation = rcr; csvEntry.Count = count; csvEntry.StartIndex = startingRow; } return csvEntry; }
public static RuntimeCsvRepresentation GetRuntimeCsvRepresentationFromStream(Stream stream, HeaderPresence headerPresence, bool trimEmptyLines, char delimiter) { System.IO.StreamReader streamReader = new StreamReader(stream); RuntimeCsvRepresentation runtimeCsvRepresentation = null; bool hasHeaders = headerPresence == HeaderPresence.HasHeaders; using (CsvReader csv = new CsvReader(streamReader, hasHeaders, delimiter, CsvReader.DefaultQuote, CsvReader.DefaultEscape, CsvReader.DefaultComment, true, CsvReader.DefaultBufferSize)) { csv.SkipsComments = false; runtimeCsvRepresentation = new RuntimeCsvRepresentation(); string[] fileHeaders = csv.GetFieldHeaders(); runtimeCsvRepresentation.Headers = new CsvHeader[fileHeaders.Length]; for (int i = 0; i < fileHeaders.Length; i++) { runtimeCsvRepresentation.Headers[i] = new CsvHeader(fileHeaders[i]); } // use field count instead of header count because there may not be headers int numberOfHeaders = csv.FieldCount; runtimeCsvRepresentation.Records = new List<string[]>(); while (csv.ReadNextRecord()) { string[] newRecord = new string[numberOfHeaders]; bool shouldAddRow = !trimEmptyLines; for (int i = 0; i < numberOfHeaders; i++) { string record = csv[i]; newRecord[i] = record; if (!string.IsNullOrEmpty(record)) { shouldAddRow = true; } } if (shouldAddRow) { runtimeCsvRepresentation.Records.Add(newRecord); } } } // Vic says - not sure how this got here, but it causes a crash! //streamReader.DiscardBufferedData(); streamReader.Close(); streamReader.Dispose(); return runtimeCsvRepresentation; }