/// <summary>
///
/// </summary>
/// <param name="isValid"></param>
/// <param name="normalize"></param>
/// <param name="version"></param>
public Spreadsheet (Func<string, bool> isValid, Func<string, string> normalize, string version)
: base(isValid, normalize, version)
{
allCells = new Dictionary<string, Cell>();
graph = new DependencyGraph();
isChanged = false;
}
/// <summary>
/// Constructor which takes in delegate values from the user
/// </summary>
/// <param name="isValid">Validity delegate</param>
/// <param name="normalize">Normalization delegate</param>
/// <param name="version">Version of spreadsheet</param>
public Spreadsheet(Func<string, bool> isValid, Func<string, string> normalize, string version)
: base(isValid, normalize, version)
{
dependency_graph = new DependencyGraph();
cell = new Dictionary<String, Cell>();
Changed = false; //Test
}
/// <summary>
/// Constructor, creates empty spreadsheet, backed by a List of cells
/// </summary>
public Spreadsheet()
: base(s => true, s => s, "default")
{
allCells = new Dictionary<string, Cell>();
graph = new DependencyGraph();
isChanged = false;
}
/// <summary>
/// Contructs a new spreadsheet, (4 arguments from user)
/// </summary>
public Spreadsheet(string path, Func<string, bool> isValid, Func<string, string> normalize, string version)
: base(isValid, normalize, version)
{
cells = new Dictionary<string, Cell>();
dependencyGraph = new DependencyGraph();
GetSavedVersion(path);
}
/// <summary>
/// Constructor for Spreadsheet with default values added to
/// delegates
/// </summary>
public Spreadsheet()
: base(s => true, s => s, "default")
{
dependency_graph = new DependencyGraph();
cell = new Dictionary<String, Cell>();
Changed = false;
}
public void AddTest2Test()
{
DependencyGraph t = new DependencyGraph();
t.AddDependency("A3", "A2");
t.AddDependency("A1", "A2");
Assert.AreEqual(2, t.Size);
}
/// <summary>
/// Reads a saved spreadsheet from file and uses it to construct a new spreadsheet.
/// The spreadsheet uses the provided validity delegate, normalization delegate and verson.
/// </summary>
/// <param name="file"></param>
/// <param name="isValid"></param>
/// <param name="normalize"></param>
/// <param name="version"></param>
public Spreadsheet(string file, Func<string, bool> isValid, Func<string, string> normalize, string version)
: base(isValid, normalize, version)
{
spreadsheet = new Dictionary<string, Cell>();
dependencyGraph = new DependencyGraph();
ReadFile(file);
}
public void EmptyTest11()
{
DependencyGraph t = new DependencyGraph();
t.AddDependency("x", "y");
Assert.AreEqual(t.Size, 1);
t.RemoveDependency("x", "y");
t.RemoveDependency("x", "y");
}
public void EmptyTest10()
{
DependencyGraph t = new DependencyGraph();
t.AddDependency("x", "y");
Assert.AreEqual(1, t["y"]);
t.RemoveDependency("x", "y");
Assert.AreEqual(0, t["y"]);
}
public Spreadsheet()
: base(s=>true, s => s, "default")
{
this.IsValid = IsValid;
this.Normalize = Normalize;
dg = new DependencyGraph();
cells = new HashSet<Cell>();
change = false;
}
public Spreadsheet(Func<string, bool> isValid, Func<string, string> normalize, string version)
: base(isValid, normalize, version)
{
this.IsValid = isValid;
this.Normalize = normalize;
dg = new DependencyGraph();
cells = new HashSet<Cell>();
change = false;
}
public void EmptyTest12()
{
DependencyGraph t = new DependencyGraph();
t.AddDependency("x", "y");
Assert.AreEqual(t.Size, 1);
t.RemoveDependency("x", "y");
t.ReplaceDependents("x", new HashSet<string>());
t.ReplaceDependees("y", new HashSet<string>());
}
public void AddTest1Test()
{
DependencyGraph t = new DependencyGraph();
t.AddDependency("A1", "A2");
t.AddDependency("A1", "A3");
t.RemoveDependency("A1", "A2");
Assert.AreEqual(1, t.Size);
t.AddDependency("A1", "A4");
Assert.AreEqual(2, t.Size);
HashSet<string> test = new HashSet<string>();
test.Add("A3");
test.Add("A4");
Assert.AreEqual(true, test.SetEquals(t.GetDependents("A1")));
}
public void PrivateDataTest()
{
try
{
DependencyGraph dg = new DependencyGraph();
dg.AddDependency("a", "b");
dg.AddDependency("a", "c");
ICollection<string> temp = (ICollection<string>)dg.GetDependents("a");
temp.Add("d");
Assert.IsTrue(new HashSet<string> { "b", "c", "d" }.SetEquals(temp));
Assert.IsTrue(new HashSet<string> { "b", "c" }.SetEquals(dg.GetDependents("a")));
}
catch (Exception e)
{
if (!(e is NotSupportedException || e is InvalidCastException))
Assert.Fail();
}
}
/// <summary>
/// Opens a saved spreadsheet and puts it back together
/// </summary>
/// <param name="myPath"></param>
/// <param name="myValid"></param>
/// <param name="myNormalize"></param>
/// <param name="myVersion"></param>
public Spreadsheet(string myPath, Func<string, bool> myValid, Func<string, string> myNormalize, string myVersion)
: base(myValid, myNormalize, myVersion)
{
mySpreadsheet = new Dictionary<string, Cell>();
dependentCells = new DependencyGraph();
//GetSavedVersion(myPath);
using (XmlReader myReader = XmlReader.Create(myPath))
{
string myContent = null;
while (myReader.Read())
{
if (myReader.IsStartElement())
{
switch (myReader.Name)
{
case "Version Information":
break;
case "cell":
break;
case "name":
myReader.Read();
myContent = myReader.Value;
break;
case "contents":
myReader.Read();
HashSet<string> mySet = new HashSet<string>();
//Foreach look sets the cell contents and evaluates the value of any direct or indirect dependents
foreach (string s in SetContentsOfCell(myContent, myReader.Value))
{
mySpreadsheet[s].myValue = myEvaluate(s);
}
break;
}
}
}
}
Changed = false;
}
public Spreadsheet(String filename, Func<string, bool> isValid, Func<string, string> normalize, string version)
: base(isValid, normalize, version)
{
this.IsValid = isValid;
this.Normalize = normalize;
dg = new DependencyGraph();
cells = new HashSet<Cell>();
this.filename = filename;
change = false;
if (GetSavedVersion(filename) != version)
{
throw new SpreadsheetReadWriteException("Conflicting versions of file.");
}
try
{
ReadandSetFile(filename);
}
catch (Exception)
{
throw new SpreadsheetReadWriteException("Could not read file");
}
}
/// <summary>
/// Constructs an abstract spreadsheet by recording its variable validity test,
/// its normalization method, and its version information. The variable validity
/// test is used throughout to determine whether a string that consists of one or
/// more letters followed by one or more digits is a valid cell name. The variable
/// equality test should be used thoughout to determine whether two variables are
/// equal.
/// </summary>
public Spreadsheet(string filePath, Func<string, bool> isValid, Func<string, string> normalize, string version)
: base(isValid, normalize, version)
{
//read save file from filePath
spreadsheet = new Dictionary<string, Cell> { };
dependency_graph = new DependencyGraph();
has_changed = false;
try
{
using (XmlReader read_file = XmlReader.Create(filePath))
{
if (GetSavedVersion(filePath) != version)
{
throw new SpreadsheetReadWriteException("File versions are not the same.");
}
try
{
string cell_name = "";
while (read_file.Read())
{
if (read_file.IsStartElement())
{
switch (read_file.Name)
{
case "spreadsheet":
break;
case "cell":
break;
case "name":
read_file.Read();
cell_name = read_file.Value;
break;
case "contents":
read_file.Read();
try
{
SetContentsOfCell(cell_name, read_file.Value);
}
catch (Exception ex)
{
throw new SpreadsheetReadWriteException(ex.Message);
}
break;
}
}
}
}
catch
{
throw new SpreadsheetReadWriteException("Error while reading from file");
}
}
}
catch (Exception ex)
{
throw new SpreadsheetReadWriteException(ex.Message);
}
has_changed = false;
}
/// <summary>
/// Constructs an abstract spreadsheet by recording its variable validity test,
/// its normalization method, and its version information. The variable validity
/// test is used throughout to determine whether a string that consists of one or
/// more letters followed by one or more digits is a valid cell name. The variable
/// equality test should be used thoughout to determine whether two variables are
/// equal.
/// </summary>
public Spreadsheet(Func<string, bool> isValid, Func<string, string> normalize, string version)
: base(isValid, normalize, version)
{
spreadsheet = new Dictionary<string, Cell> { };
dependency_graph = new DependencyGraph();
has_changed = false;
}
/// <summary>
/// Creates a new Spreadsheet.
/// </summary>
public Spreadsheet()
: base(valid_name, name=>name, "default")
{
spreadsheet = new Dictionary<string, Cell> { }; //Keeps track of the Cell names and their Correspoding cell objects.
dependency_graph = new DependencyGraph(); //Keeps track of depencies between Cells.
has_changed = false;
}
/// <summary>
/// The three argument constructor; this allows the user to provide a validity delegate, a normalization delegate,
/// and a version (third parameter).
/// </summary>
/// <param name="isValid"></param>
/// <param name="normalize"></param>
/// <param name="version"></param>
public Spreadsheet(Func<string, bool> isValid, Func<string, string> normalize, string version)
: base(isValid, normalize, version)
{
//Setup data structures that keep track of which cells depend on which, and the association between cells and cell names.
dependencies = new DependencyGraph();
cells = new SortedDictionary<string, Cell>();
Changed = false;
}
public void EmptyTest8()
{
DependencyGraph t = new DependencyGraph();
t.AddDependency("a", "b");
}
public void EmptyTest7()
{
DependencyGraph t = new DependencyGraph();
t.RemoveDependency("a", "b");
Assert.AreEqual(0, t.Size);
}
public void EmptyTest6()
{
DependencyGraph t = new DependencyGraph();
Assert.AreEqual(0, t["a"]);
}
public void EmptyTest5()
{
DependencyGraph t = new DependencyGraph();
Assert.IsFalse(t.GetDependents("a").GetEnumerator().MoveNext());
}
public void EmptyTest3()
{
DependencyGraph t = new DependencyGraph();
Assert.IsFalse(t.HasDependents("a"));
}
public void StressTest15()
{
// Dependency graph
DependencyGraph t = new DependencyGraph();
// A bunch of strings to use
const int SIZE = 100;
string[] letters = new string[SIZE];
for (int i = 0; i < SIZE; i++)
{
letters[i] = ("" + (char)('a' + i));
}
// The correct answers
HashSet<string>[] dents = new HashSet<string>[SIZE];
HashSet<string>[] dees = new HashSet<string>[SIZE];
for (int i = 0; i < SIZE; i++)
{
dents[i] = new HashSet<string>();
dees[i] = new HashSet<string>();
}
// Add a bunch of dependencies
for (int i = 0; i < SIZE; i++)
{
for (int j = i + 1; j < SIZE; j++)
{
t.AddDependency(letters[i], letters[j]);
dents[i].Add(letters[j]);
dees[j].Add(letters[i]);
}
}
// Remove a bunch of dependencies
for (int i = 0; i < SIZE; i++)
{
for (int j = i + 2; j < SIZE; j += 2)
{
t.RemoveDependency(letters[i], letters[j]);
dents[i].Remove(letters[j]);
dees[j].Remove(letters[i]);
}
}
// Replace a bunch of dependees
for (int i = 0; i < SIZE; i += 4)
{
HashSet<string> newDees = new HashSet<String>();
for (int j = 0; j < SIZE; j += 7)
{
newDees.Add(letters[j]);
}
t.ReplaceDependees(letters[i], newDees);
foreach (string s in dees[i])
{
dents[s[0] - 'a'].Remove(letters[i]);
}
foreach (string s in newDees)
{
dents[s[0] - 'a'].Add(letters[i]);
}
dees[i] = newDees;
}
// Make sure everything is right
for (int i = 0; i < SIZE; i++)
{
Assert.IsTrue(dents[i].SetEquals(new HashSet<string>(t.GetDependents(letters[i]))));
Assert.IsTrue(dees[i].SetEquals(new HashSet<string>(t.GetDependees(letters[i]))));
}
}
public void EmptyTest1()
{
DependencyGraph t = new DependencyGraph();
Assert.AreEqual(0, t.Size);
}
public void NonEmptyTest8()
{
DependencyGraph t = new DependencyGraph();
t.AddDependency("a", "b");
t.AddDependency("a", "c");
t.AddDependency("d", "c");
t.ReplaceDependees("c", new HashSet<string>() { "x", "y", "z" });
HashSet<String> cDees = new HashSet<string>(t.GetDependees("c"));
Assert.IsTrue(cDees.SetEquals(new HashSet<string>() { "x", "y", "z" }));
}
public void NonEmptyTest6()
{
DependencyGraph t = new DependencyGraph();
t.AddDependency("a", "b");
t.AddDependency("a", "c");
t.AddDependency("d", "c");
t.RemoveDependency("a", "b");
Assert.AreEqual(2, t.Size);
}
public void NonEmptyTest5()
{
DependencyGraph t = new DependencyGraph();
t.AddDependency("a", "b");
t.AddDependency("a", "c");
t.AddDependency("d", "c");
Assert.AreEqual(0, t["a"]);
Assert.AreEqual(1, t["b"]);
Assert.AreEqual(2, t["c"]);
Assert.AreEqual(0, t["d"]);
Assert.AreEqual(0, t["e"]);
}
