//needs to assign the text asset as part of its creation static void ProcessAsset(string origLocation, TextAsset txt, DeadSimpleCSV csv) { //if matching file exists, then get it ExternalVarsSO extvar = ExternalVarsSOManager.Instance().FindByExternalFile(txt); var fileName = origLocation.Substring(0, origLocation.Length - (".csv".Length)) + ".asset"; bool createdAsset = false; //if not create it an if (extvar == null) { extvar = ExternalVarsSO.CreateInstance <ExternalVarsSO>(); extvar.localCSV = txt; AssetDatabase.CreateAsset(extvar, fileName); createdAsset = true; } try { extvar.GenerateVars(csv.ConvertRowsToObjects <ExternalVarsSO.VarSpec>()); } catch (Exception) { if (createdAsset) { AssetDatabase.DeleteAsset(fileName); UnityEngine.Object.DestroyImmediate(extvar); } } }
public override void OnInspectorGUI() { CSVWranglerStartUp my = (CSVWranglerStartUp)target; //EditorGUIUtility.LookLikeControls(); DrawDefaultInspector(); EditorGUILayout.BeginHorizontal(); if (GUILayout.Button("Download index file")) { FileDownloadWindow.Init(); FileDownloadWindow.instance.AddToDlQueue(my.settings.liveURL, "CSVs/csvWrangler.csv", FileDownloadWindow.DownloadLocation.ResourceFolder); } if (File.Exists(Application.dataPath + "/Resources/CSVs/csvWrangler.csv") && GUILayout.Button("Download referenced csvs")) { //open the csvWrangler.csv into deadsimple csv DeadSimpleCSV indexTable = new DeadSimpleCSV(File.ReadAllText(Application.dataPath + "/Resources/CSVs/csvWrangler.csv"), true); //dump into classlist List<CSVWrangler.IndexRow> rows = indexTable.ConvertRowsToObjects<CSVWrangler.IndexRow>(); FileDownloadWindow.Init(); foreach (CSVWrangler.IndexRow row in rows) { FileDownloadWindow.instance.AddToDlQueue(row.url, "CSVs/" + row.name + ".csv", FileDownloadWindow.DownloadLocation.ResourceFolder); } } EditorGUILayout.EndHorizontal(); }
//load local tables from persist storage as described in the curtable, which is loaded from the csvwrangler.csv // currently synchronous, in the future may become async public void LoadTables() { State = CSVWranglerState.Loading; //reset so we could reload tables = new Dictionary <string, DeadSimpleCSV>(); //grab the row and load each file of name into the tables dict string[] tableNames = indexTable.GetColumn("name"); foreach (string name in tableNames) { string tableFullLoc = Application.persistentDataPath + "/" + name + ".csv"; //TODO could change this logic so the file contents is returned by the util function so we don't double load? //make sure it exists UTIL.EnsureTextResourceIsHere(tableFullLoc, "csvs/" + name); //attempt to load string fileContents = UTIL.ReadAllText(tableFullLoc); //notify of failure if (string.IsNullOrEmpty(fileContents)) { Debug.LogWarning("Tried to load the " + name + " csv but something went wrong"); } else//success, maybe { DeadSimpleCSV table = new DeadSimpleCSV(fileContents, true); tables.Add(name, table); } } State = CSVWranglerState.Ready; }
public void WriteVarsToLocal() { var rows = GenerateVarSpecs(); var csvFile = DeadSimpleCSV.CreateFromList(rows).GetAsCSVString(true); #if UNITY_EDITOR System.IO.File.WriteAllText(AssetDatabase.GetAssetPath(localCSV), csvFile); AssetDatabase.Refresh(); #endif }
private void _addStringMoveForward(List <string> addto, string s) { int len = s.Length; var r = DeadSimpleCSV.DecodeFromCSV(s); addto.Add(trimWhiteSpace ? r.Trim() : r); curIndex += len; }
public void SetupTests() { csvFromFile = new AID.DeadSimpleCSV(fileContents, true); listFromCSV = csvFromFile.ConvertRowsToObjects <ExampleCSVSerialiseClass>(); csvFromList = AID.DeadSimpleCSV.CreateFromList(listFromCSV); listFromCSVFromList = csvFromList.ConvertRowsToObjects <ExampleCSVSerialiseClass>(); csvFromListStr = csvFromList.GetAsCSVString(true); }
//create an instance from a list of objects static public DeadSimpleCSV CreateFromList <T>(List <T> l) where T : class, new() { DeadSimpleCSV retval = new DeadSimpleCSV(); Type t = typeof(T); //create header FieldInfo[] fields = t.GetFields(); PropertyInfo[] props = t.GetProperties(); retval.headers = new string[fields.Length + props.Length]; int i = 0; for (; i < l.Count; i++) { retval.rows.Add(new string[fields.Length + props.Length]); } i = 0; foreach (FieldInfo f in fields) { //filling in headers retval.headers[i] = f.Name; for (int j = 0; j < l.Count; j++) { retval.rows[j][i] = (string)Convert.ChangeType(f.GetValue(l[j]), typeof(string)); } i++; } foreach (PropertyInfo p in props) { //filling in headers retval.headers[i] = p.Name; for (int j = 0; j < l.Count; j++) { retval.rows[j][i] = (string)Convert.ChangeType(p.GetValue(l[j], null), typeof(string)); } i++; } retval.GenerateColumnLookup(); return(retval); }
public void AppendCols(int skipCols, DeadSimpleCSV appendFrom) { var appendThis = appendFrom.SkipCols(skipCols); for (int i = 0; i < rows.Count && i < appendThis.rows.Count; i++) { List <string> tmp = new List <string>(); tmp.AddRange(rows[i]); tmp.AddRange(appendThis.rows[i]); rows[i] = tmp.ToArray(); } }
//find table of given name. Should be called sparingly, if you need the table a lot then cache it // DeadSimpleCSV myTable = CSVWrangler.Instance().GetTable("Example"); public DeadSimpleCSV GetTable(string name) { DeadSimpleCSV retval = null; tables.TryGetValue(name, out retval); if (retval == null) { Debug.LogWarning("No table with name " + name); } return(retval); }
private void _processAllNewRows(List <string> colnames, DeadSimpleCSV newTable) { //for all foreach (string targetName in colnames) { string[] curRow = indexTable.GetRowWithData("name", targetName); string[] newRow = newTable.GetRowWithData("name", targetName); if (curRow == null) { //we don't have it add the version and download if (newRow != null) { UpdateTable(targetName, newTable.GetCell("url", newRow), newTable.GetCell("ver", newRow)); Debug.Log(targetName + " did not exist, creating from live."); } } else if (newRow == null) { Debug.Log(targetName + " no longer exists in live, removing."); //this table doesn't exist anymore, drop it indexTable.RemoveRow(curRow); //we only try to load files that are in the latest csvwrangler index so we can delete this old one now File.Delete(Application.persistentDataPath + "/" + targetName + ".csv"); } else { //if the version in ours is lower download int curVer = int.Parse(indexTable.GetCell("ver", curRow));// curRow[curTable.ColumnNames["ver"]]); int newVer = int.Parse(newTable.GetCell("ver", newRow)); if (newVer > curVer || settings.alwaysDownloadTables) { Debug.Log(targetName + (newVer > curVer ? " was old, updating" : " was forced to update")); //download new ver UpdateTable(targetName, newTable.GetCell("url", newRow), newTable.GetCell("ver", newRow)); } } } }
private void ProcessIndex(DeadSimpleCSV newTable) { State = CSVWranglerState.ProcessingIndex; //make a list of all name col names string[] curNames = indexTable.GetColumn("name"), newNames = newTable.GetColumn("name"); List <string> colnames = new List <string>(); colnames.AddRange(curNames.ToList()); colnames.AddRange(newNames.ToList()); colnames = colnames.Distinct().ToList(); //this is all a bit too table-ey and memory trashy but it is a table and it is a one off init process //handles all new rows from the given index, updates, creates and destroys as required _processAllNewRows(colnames, newTable); //flush the index file back to storage StartCoroutine(_flushUpdatedTable(true)); }
static bool ProcessIfValidExtVarAsset(string item) { //if it is a csv and it loads and it has the required cols if (item.EndsWith(".csv")) { var txt = AssetDatabase.LoadAssetAtPath <TextAsset>(item); if (txt == null) { return(false); } DeadSimpleCSV csv = null; try { csv = new DeadSimpleCSV(txt.text, true); } catch (Exception) { } ProcessAsset(item, txt, csv); } return(false); }
public void ForceInitIndex() { string csvIndexLoc = Application.persistentDataPath + "/csvWrangler.csv"; //ForceCacheLocalFiles(); if (!ForceCacheIndex()) { Debug.LogError("CSV Wrangler is trying to be used without a local cached csvWrangler.csv in the Resources. Did you remember to cache your csvs?"); State = CSVWranglerState.ErrorNoIndex; return; } //load previous csvwrangler index csv file indexTable = new DeadSimpleCSV(UTIL.ReadAllText(csvIndexLoc), true); //something terrible happened fake an empty one if (indexTable.headers == null || indexTable.headers.Length == 0) { indexTable.headers = new string[] { "name", "url", "ver" }; } State = CSVWranglerState.IndexOnly; }
void Start() { //get the call back for all dls completed //handles native types and enums // this shows loading a table of data where the col name matches a classes var name // the ConvertRowsToObjects uses reflection and convert to out each row as the given object // has not been tested with classes that have refs to other classes, this will most likely NOT work AID.DeadSimpleCSV csvFromFile = new AID.DeadSimpleCSV(txtFile.text, true); List <ExampleCSVSerialiseClass> listFromCSV = csvFromFile.ConvertRowsToObjects <ExampleCSVSerialiseClass>(); foreach (ExampleCSVSerialiseClass o in listFromCSV) { print(o); } AID.DeadSimpleCSV csvFromList = AID.DeadSimpleCSV.CreateFromList <ExampleCSVSerialiseClass>(listFromCSV); print(csvFromList.GetAsCSVString(true)); AID.CSVWrangler.Instance().CSVWranglerChange += CSVWranglerStateHasChanged; AID.CSVWrangler.Instance().Init(); }
internal void AppendRows(int skipRows, DeadSimpleCSV t) { rows.AddRange(t.rows.GetRange(skipRows, t.rows.Count - skipRows)); }
public static List <T> ConvertStringCSVToObjects <T>(string csvStr, bool generateColumnLookup) where T : class, new() { var csv = new DeadSimpleCSV(csvStr, generateColumnLookup); return(csv.ConvertRowsToObjects <T>()); }
public void GenerateVarsLocalCSV() { var items = DeadSimpleCSV.ConvertStringCSVToObjects <VarSpec>(localCSV.text, true); GenerateVars(items); }