/// <summary>
/// Serializes an object using MiniJSON and writes to a given path
/// </summary>
/// <param name="destFileName"></param>
/// <param name="serializableObject"></param>
public void WriteJson(object serializableObject, WriteFileInfo writeFileInfo)
{
string ppJson = MiniJSON.Json.Serialize(serializableObject);
File.WriteAllText(writeFileInfo.FullPath, ppJson);
executeOnMainThreadQueue.Enqueue(() => onWriteFile.Invoke(writeFileInfo));
}
/// <summary>
/// Writes a DataTable to file to a path.
/// </summary>
/// <param name="data"></param>
/// <param name="fpath"></param>
public void WriteCSV(DataTable data, WriteFileInfo writeFileInfo)
{
var writer = new CSVFile.CSVWriter(writeFileInfo.FullPath);
writer.Write(data, true);
writer.Dispose();
executeOnMainThreadQueue.Enqueue(() => onWriteFile.Invoke(writeFileInfo));
}
/// <summary>
/// Writes a list of string arrays with a given header to a file at given path.
/// </summary>
/// <param name="header">Row of headers</param>
/// <param name="data"></param>
/// <param name="fpath"></param>
public void WriteCSV(string[] header, IList <string[]> data, WriteFileInfo writeFileInfo)
{
string[] csvRows = new string[data.Count + 1];
csvRows[0] = string.Join(",", header);
for (int i = 1; i <= data.Count; i++)
{
csvRows[i] = string.Join(",", data[i - 1]);
}
File.WriteAllLines(writeFileInfo.FullPath, csvRows);
executeOnMainThreadQueue.Enqueue(() => onWriteFile.Invoke(writeFileInfo));
}
/// <summary>
/// Writes trial data (List of OrderedResultsDict) to file at fpath
/// </summary>
/// <param name="dictList"></param>
/// <param name="fpath"></param>
public void WriteTrials(List <ResultsDictionary> dictList, WriteFileInfo writeFileInfo)
{
// generate list of all headers possible
// hashset keeps unique set of keys
HashSet <string> headers = new HashSet <string>();
foreach (ResultsDictionary dict in dictList)
{
if (dict != null)
{
foreach (string key in dict.Keys)
{
headers.Add(key);
}
}
}
// final output: array of rows (comma-separated strings)
string[] csvRows = new string[dictList.Count + 1];
// first row: headers
csvRows[0] = string.Join(",", headers.ToArray());
for (int i = 0; i < dictList.Count; i++)
{
ResultsDictionary dict = dictList[i];
if (dict == null)
{
continue; // empty trial, try next loop iteration
}
// add all observations to the row, in correct order.
// check if null, if so assign to empty string (?? operator)
var row = headers
.Select(header =>
{
object val;
try { val = dict[header]; }
catch (KeyNotFoundException) { val = string.Empty; }
if (val == null)
{
val = string.Empty;
}
return(val.ToString());
}
);
// join to string & store in output
csvRows[i + 1] = string.Join(",", row.ToArray());
}
File.WriteAllLines(writeFileInfo.FullPath, csvRows);
executeOnMainThreadQueue.Enqueue(() => onWriteFile.Invoke(writeFileInfo));
}
public void CommitCSV()
{
FileInfo fileInfo = new FileInfo(ppListPath);
WriteFileInfo writeFileInfo = new WriteFileInfo(
WriteFileType.ParticipantList,
fileInfo.DirectoryName,
fileInfo.Name
);
fileIOManager.WriteCSV(ppList, writeFileInfo);
Debug.Log(string.Format("Updating: {0}", ppListPath));
}
void SaveResults()
{
List <ResultsDictionary> results = Trials.Select(t => t.result).ToList();
string fileName = "trial_results.csv";
WriteFileInfo fileInfo = new WriteFileInfo(
WriteFileType.Trials,
BasePath,
experimentName,
ppid,
FolderName,
fileName
);
fileIOManager.ManageInWorker(() => fileIOManager.WriteTrials(results, fileInfo));
}
/// <summary>
/// Finalises the session logger, saving the data and detaching its logging method from handling Debug.Log messages
/// </summary>
public void Finalise()
{
WriteFileInfo fileInfo = new WriteFileInfo(
WriteFileType.Log,
session.BasePath,
session.experimentName,
session.ppid,
session.FolderName,
"log.csv"
);
fileIOManager.ManageInWorker(() => fileIOManager.WriteCSV(table, fileInfo));
Application.logMessageReceived -= HandleLog;
session.cleanUp -= Finalise;
}
void SaveResults()
{
List <OrderedResultDict> results = trials.Select(t => t.result).ToList();
string fileName = "trial_results.csv";
WriteFileInfo fileInfo = new WriteFileInfo(
WriteFileType.Trials,
this.basePath,
experimentName,
ppid,
folderName,
fileName
);
fileIOManager.ManageInWorker(() => fileIOManager.WriteTrials(results, headers.ToArray(), fileInfo));
}
/// <summary>
/// Writes trial data (List of OrderedResultsDict) to file at fpath
/// </summary>
/// <param name="dataDict"></param>
/// <param name="headers"></param>
/// <param name="fpath"></param>
public void WriteTrials(List <OrderedResultDict> dataDict, string[] headers, WriteFileInfo writeFileInfo)
{
string[] csvRows = new string[dataDict.Count + 1];
csvRows[0] = string.Join(",", headers.ToArray());
object[] row = new object[headers.Length];
for (int i = 1; i <= dataDict.Count; i++)
{
OrderedResultDict dict = dataDict[i - 1];
if (dict != null)
{
dict.Values.CopyTo(row, 0);
csvRows[i] = string.Join(",", row.Select(v => System.Convert.ToString(v)).ToArray());
}
}
File.WriteAllLines(writeFileInfo.FullPath, csvRows);
executeOnMainThreadQueue.Enqueue(() => onWriteFile.Invoke(writeFileInfo));
}
/// <summary>
/// Save tracking data for this trial
/// </summary>
/// <param name="tracker">The tracker to take data from to save</param>
/// <returns>Name of the saved file</returns>
public string SaveTrackerData(Tracker tracker)
{
string fname = string.Format("{0}_{1}_T{2:000}.csv", tracker.objectName, tracker.measurementDescriptor, currentTrialNum);
WriteFileInfo fileInfo = new WriteFileInfo(
WriteFileType.Tracker,
this.basePath,
experimentName,
ppid,
folderName,
fname
);
List <string[]> dataCopy = tracker.GetDataCopy();
fileIOManager.ManageInWorker(() => fileIOManager.WriteCSV(tracker.header, dataCopy, fileInfo));
// return name of the file so it can be stored in behavioural data
return(fileInfo.FileName);
}
/// <summary>
/// Write a dictionary object to a JSON file in the session folder (in a new FileIOManager thread)
/// </summary>
/// <param name="dict">Dictionary object to write</param>
/// <param name="objectName">Name of the object (is used for file name)</param>
public void WriteDictToSessionFolder(Dictionary <string, object> dict, string objectName)
{
if (hasInitialised)
{
string fileName = string.Format("{0}.json", objectName);
WriteFileInfo fileInfo = new WriteFileInfo(
WriteFileType.Dictionary,
this.basePath,
experimentName,
ppid,
folderName,
fileName
);
fileIOManager.ManageInWorker(() => fileIOManager.WriteJson(dict, fileInfo));
}
else
{
throw new System.InvalidOperationException("Can't write dictionary before session has initalised!");
}
}
void CreateNewPPList(string filePath)
{
// create example table
DataTable exampleData = new DataTable();
// create headers
foreach (var header in startup.participantDataPoints.Select(x => x.internalName))
{
exampleData.Columns.Add(new DataColumn(header, typeof(string)));
}
// create example row
DataRow row1 = exampleData.NewRow();
foreach (var dataPoint in startup.participantDataPoints)
{
row1[dataPoint.internalName] = dataPoint.controller.GetDefault();
}
row1["ppid"] = "test";
exampleData.Rows.Add(row1);
FileInfo fileInfo = new FileInfo(filePath);
WriteFileInfo writeFileInfo = new WriteFileInfo(
WriteFileType.ParticipantList,
fileInfo.DirectoryName,
fileInfo.Name
);
// save, this is single threaded in this case
fileIOManager.WriteCSV(exampleData, writeFileInfo);
// re-read it back in
CheckSetList(filePath);
}
/// <summary>
/// Writes trial data (List of OrderedResultsDict) to file at fpath
/// </summary>
/// <param name="dictList"></param>
/// <param name="fpath"></param>
public void WriteTrials(List <ResultsDictionary> dictList, WriteFileInfo writeFileInfo)
{
// generate list of all headers possible
// hashset keeps unique set of keys
HashSet <string> headers = new HashSet <string>();
foreach (ResultsDictionary dict in dictList)
{
if (dict != null)
{
foreach (string key in dict.Keys)
{
headers.Add(key);
}
}
}
// final output: array of rows (comma-separated strings)
string[] csvRows = new string[dictList.Count + 1];
// first row: headers
csvRows[0] = string.Join(",", headers.ToArray());
for (int i = 0; i < dictList.Count; i++)
{
ResultsDictionary dict = dictList[i];
if (dict == null)
{
continue; // empty trial, try next loop iteration
}
// add all observations to the row, in correct order.
// check if null, if so assign to empty string
var row = headers
.Select(header =>
{
object val;
try { val = dict[header]; }
catch (KeyNotFoundException) { val = string.Empty; }
if (val == null)
{
val = string.Empty;
}
string stringValue = val.ToString();
// check for commas
// commas not allowed in CSV format, as they are parsed as new rows
if (stringValue.Contains(','))
{
Debug.LogWarningFormat(
"Replacing comma characters (',') in value '{0}' (result[\"{1}\"] in trial {2}) with '_' character. Reason: Comma characters not allowed in values in CSV file.",
stringValue, header, i
);
stringValue = stringValue.Replace(',', '_');
}
return(stringValue);
}
);
// join to string & store in output
csvRows[i + 1] = string.Join(",", row.ToArray());
}
File.WriteAllLines(writeFileInfo.FullPath, csvRows);
executeOnMainThreadQueue.Enqueue(() => onWriteFile.Invoke(writeFileInfo));
}
