/// <summary>
        /// read the source field and fill the spread sheet in the field
        /// </summary>
        /// <param name="source"></param>
        /// <param name="newIsValid"></param>
        public Spreadsheet(TextReader source, Regex newIsValid)
        {
            isvalName = newIsValid;
            Regex oldIsvail = null;

            sheet      = new Dictionary <string, cell>();
            dependency = new DependencyGraph();


            // Create an XmlSchemaSet object.
            XmlSchemaSet sc = new XmlSchemaSet();

            // NOTE: To read states3.xsd this way, it must be stored in the same folder with the
            // executable.  To arrange this, I set the "Copy to Output Directory" propery of states3.xsd to
            // "Copy If Newer", which will copy states3.xsd as part of each build (if it has changed
            // since the last build).
            sc.Add(null, "Spreadsheet.xsd");

            // Configure validation.
            XmlReaderSettings settings = new XmlReaderSettings();

            settings.ValidationType          = ValidationType.Schema;
            settings.Schemas                 = sc;
            settings.ValidationEventHandler += ValidationCallback;

            // try to read the field
            try
            {
                // begin to read
                using (XmlReader reader = XmlReader.Create(source, settings))
                {
                    // in the each token,
                    // first check if it is vaild
                    // then save them into the sheet once it is vaild
                    while (reader.Read())
                    {
                        if (reader.IsStartElement())
                        {
                            switch (reader.Name)
                            {
                            case "spreadsheet":
                                try
                                {
                                    oldIsvail = new Regex(reader["IsValid"]);
                                }
                                catch
                                {
                                    throw new SpreadsheetReadException("wrong regular expression");
                                }
                                break;

                            // checkall the requirements
                            case "cell":
                                try
                                {
                                    string name = reader["name"];

                                    if (!oldIsvail.IsMatch(name))
                                    {
                                        throw new SpreadsheetReadException("the name is ilegal");
                                    }
                                    if (!isvalName.IsMatch(name))
                                    {
                                        throw new SpreadsheetVersionException("the name is ilegal");
                                    }
                                    if (sheet.ContainsKey(name))
                                    {
                                        throw new SpreadsheetReadException("the name is duplicate");
                                    }

                                    SetContentsOfCell(name, reader["contents"]);
                                }
                                catch
                                {
                                    throw new SpreadsheetReadException("can not read name or contents");
                                }
                                break;
                            }
                        }
                    }
                }
            }

            // throw exception once it doen't read
            catch
            {
                throw new IOException();
            }
        }
 /// <summary>
 /// the spreadsheet will takes no peremeter
 /// </summary>
 public Spreadsheet()
 {
     sheet          = new Dictionary <string, cell>();
     dependency     = new DependencyGraph();
     constructorUse = 1;
 }
 /// <summary>
 /// it will take a new isVaild check if match the requirement
 /// </summary>
 /// <param name="isValid"></param>
 public Spreadsheet(Regex isValid)
 {
     isvalName  = isValid;
     sheet      = new Dictionary <string, cell>();
     dependency = new DependencyGraph();
 }
Ejemplo n.º 4
0
        /// Creates a Spreadsheet that is a duplicate of the spreadsheet saved in source.

        public Spreadsheet(TextReader source, Regex newIsValid)
        {
            this.dg       = new DependencyGraph();
            this.cellList = new Dictionary <string, Cell>();

            IsValid      = newIsValid;
            this.Changed = false;

            Regex        r      = newIsValid;
            XmlSchemaSet schema = new XmlSchemaSet();

            schema.Add(null, "Spreadsheet.xsd");

            XmlReaderSettings settings = new XmlReaderSettings();

            settings.ValidationType          = ValidationType.Schema;
            settings.Schemas                 = schema;
            settings.ValidationEventHandler += ThrowExceptionValidation;

            using (XmlReader reader = XmlReader.Create(source, settings))
            {
                while (reader.Read())
                {
                    if (reader.IsStartElement())
                    {
                        switch (reader.Name)
                        {
                        case "spreadsheet":
                            try
                            {
                                r = new Regex(reader["IsValid"]);
                            }
                            catch
                            {
                                throw new SpreadsheetReadException("Invalid Expression");
                            }
                            break;

                        case "cell":
                            if (cellList.ContainsKey(reader["name"]))
                            {
                                throw new SpreadsheetReadException("");
                            }

                            IsValid = r;
                            try
                            {
                                this.SetContentsOfCell(reader["name"], reader["contents"]);
                            }
                            catch (Exception e) when(e is FormulaFormatException || e is CircularException || e is InvalidNameException)
                            {
                                if (e is FormulaFormatException)
                                {
                                    throw new SpreadsheetVersionException("");
                                }

                                if (e is FormulaFormatException)
                                {
                                    throw new SpreadsheetVersionException("");
                                }
                                if (e is InvalidNameException)
                                {
                                    throw new SpreadsheetVersionException("");
                                }
                            }

                            IsValid = newIsValid;
                            try
                            {
                                this.SetContentsOfCell(reader["name"], reader["contents"]);
                            }
                            catch (Exception ee) when(ee is FormulaFormatException || ee is CircularException || ee is InvalidNameException)
                            {
                                if (ee is FormulaFormatException)
                                {
                                    throw new SpreadsheetVersionException("");
                                }

                                if (ee is FormulaFormatException)
                                {
                                    throw new SpreadsheetVersionException("");
                                }
                                if (ee is InvalidNameException)
                                {
                                    throw new SpreadsheetVersionException("");
                                }
                            }
                            break;
                        }
                    }
                }
            }
        }
Ejemplo n.º 5
0
 /// <summary>
 /// Three argument constructor.
 /// </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)
 {
     dg      = new DependencyGraph();
     sd      = new Dictionary <string, Cell>();
     Changed = false;
 }
Ejemplo n.º 6
0
        /// <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;
        }
Ejemplo n.º 7
0
 /// <summary>
 /// zero-argument constructor should create an empty spreadsheet that imposes no
 /// extra validity conditions, normalizes every cell name to itself,
 /// and has version "default".
 /// </summary>
 public Spreadsheet() : base(s => true, s => s, "default")
 {
     Changed = false;
     myDG    = new DependencyGraph();
     mySS    = new Dictionary <string, Cell>();
 }
Ejemplo n.º 8
0
 /// <summary>
 /// A zero-argument constructor that creates an empty spreadsheet.
 /// </summary>
 public Spreadsheet()
 {
     Graph         = new DependencyGraph();
     NonEmptyCells = new Dictionary <string, Cell>();
 }
Ejemplo n.º 9
0
 /// <summary>
 /// No arguments in constructor. Cell validity has same rule for all
 /// spreadsheets, and is determined by IsValid method in this class.
 /// Cell name normalization has same rule (all uppercase letters) for all
 /// spreadsheets, and is determined by Normalize method in this class.
 /// </summary>
 public Spreadsheet()
 {
     cells           = new Dictionary <string, Cell>();
     dependencyGraph = new DependencyGraph();
 }
Ejemplo n.º 10
0
        public Spreadsheet(string path, Func <string, bool> isValid, Func <string, string> normalize, string version) : base(x => true, x => x, version)
        {
            //declaring a dependency graph.
            DG = new DependencyGraph();
            //declarign a cell from the cells class.
            Cells = new Dictionary <string, Cell>();
            //declaring is Valid and Normalize
            this.IsValid   = isValid;
            this.Normalize = normalize;
            this.Version   = version;
            Changed        = false;

            try
            {   //reading a file from the path
                using (XmlReader reader = XmlReader.Create(path))
                {
                    while (reader.Read())
                    {         //if start element is correct.
                        if (reader.IsStartElement())
                        {     //if spreadsheet is read.
                            if (reader.Name == "spreadsheet")
                            { //set version to reader version.
                                version = reader["version"];
                            }
                            //if cell is read.
                            if (reader.Name == "cell")
                            {
                                //if reader Name is not equal to name.
                                while (!reader.Name.Equals("name"))
                                {
                                    reader.Read();
                                }
                                reader.Read();
                                //storing value in name.
                                string name = reader.Value;
                                while (!reader.Name.Equals("contents"))
                                {
                                    reader.Read();
                                }
                                reader.Read();
                                //set value in content.
                                string content = reader.Value;

                                //rerunning setCentent of cell on name and content.
                                SetContentsOfCell(name, content);
                            }
                        }
                    }
                }
            }

            catch (Exception)
            {
                throw new SpreadsheetReadWriteException("error");
            }

            //if version doesnt match throw an exception.
            if (!GetSavedVersion(path).Equals(Version))
            {
                throw new SpreadsheetReadWriteException("the version do not match");
            }
        }
Ejemplo n.º 11
0
        /// <summary>
        /// Requires that all of the variables in formula are valid cell names.
        ///
        /// If name is null or invalid, throws an InvalidNameException.
        ///
        /// Otherwise, if changing the contents of the named cell to be the formula would cause a
        /// circular dependency, throws a CircularException.
        ///
        /// Otherwise, the contents of the named cell becomes formula.  The method returns a
        /// Set consisting of name plus the names of all other cells whose value depends,
        /// directly or indirectly, on the named cell.
        ///
        /// For example, if name is A1, B1 contains A1*2, and C1 contains B1+A1, the
        /// set {A1, B1, C1} is returned.
        /// </summary>
        protected override ISet <string> SetCellContents(string name, Formula formula)
        {
            name = name.ToUpper();

            // check if passed in formula contains a dependent of the named cell
            // to prevent a ciruclar dependency
            //foreach(string token in GetDirectDependents(name))
            //{
            //    if(formula.ToString().Contains(token))
            //    {
            //        throw new CircularException();
            //    }
            //}



            HashSet <string> set = new HashSet <string>();

            // A backup spreadsheet for revert in case a CircularException is thrown
            Dictionary <string, Cell> tempDict = new Dictionary <string, Cell>();

            // A backup DependencyGraph for revert in case a CircularException is thrown
            DependencyGraph tempGraph = new DependencyGraph(graph);

            //create a copy for the spreadsheet
            foreach (KeyValuePair <string, Cell> key in cellList)
            {
                tempDict.Add(key.Key, key.Value);
            }

            // Replace current cell's content for update
            graph.ReplaceDependees(name, new List <string>());

            // Create dependency relationship between cell and valid variables generated by Formula
            foreach (string var in formula.GetVariables())
            {
                CheckParameters(var);
                graph.AddDependency(var, name);
            }

            // Generate a new cell if such named cell doesn't exists yet, or simply replace the existing
            // cell with new information
            GenerateCellInfo(name, formula);
            set.Add(name);

            // This try catch block is used to detect possible Circular dependency by calling GetCellsToRecalculate()
            try
            {
                foreach (string var in GetCellsToRecalculate(name))
                {
                    set.Add(var);
                }
            }
            catch (CircularException e)
            {
                // If a CircularException is caught, revert the entire operation.
                cellList = tempDict;
                graph    = tempGraph;
                Changed  = false;
                throw e;
            }

            // Update current named cell's dependee's content, value and dependency
            UpdateCellInfo(set, name);
            Changed = true;
            return(set);
        }
Ejemplo n.º 12
0
        /// Creates a Spreadsheet that is a duplicate of the spreadsheet saved in source.
        ///
        /// See the AbstractSpreadsheet.Save method and Spreadsheet.xsd for the file format
        /// specification.
        ///
        /// If there's a problem reading source, throws an IOException.
        ///
        /// Else if the contents of source are not consistent with the schema in Spreadsheet.xsd,
        /// throws a SpreadsheetReadException.
        ///
        /// Else if the IsValid string contained in source is not a valid C# regular expression, throws
        /// a SpreadsheetReadException.  (If the exception is not thrown, this regex is referred to
        /// below as oldIsValid.)
        ///
        /// Else if there is a duplicate cell name in the source, throws a SpreadsheetReadException.
        /// (Two cell names are duplicates if they are identical after being converted to upper case.)
        ///
        /// Else if there is an invalid cell name or an invalid formula in the source, throws a
        /// SpreadsheetReadException.  (Use oldIsValid in place of IsValid in the definition of
        /// cell name validity.)
        ///
        /// Else if there is an invalid cell name or an invalid formula in the source, throws a
        /// SpreadsheetVersionException.  (Use newIsValid in place of IsValid in the definition of
        /// cell name validity.)
        ///
        /// Else if there's a formula that causes a circular dependency, throws a SpreadsheetReadException.
        ///
        /// Else, create a Spreadsheet that is a duplicate of the one encoded in source except that
        /// the new Spreadsheet's IsValid regular expression should be newIsValid.
        public Spreadsheet(TextReader source, Regex newIsValid)
        {
            cells        = new Dictionary <string, Cell>();
            dependencies = new DependencyGraph();
            validator    = newIsValid;

            XmlSchemaSet sc = new XmlSchemaSet();

            sc.Add(null, "Spreadsheet.xsd");
            XmlReaderSettings settings = new XmlReaderSettings();

            settings.ValidationType          = ValidationType.Schema;
            settings.Schemas                 = sc;
            settings.ValidationEventHandler += delegate(object sender, ValidationEventArgs e) { throw new SpreadsheetReadException("Validation Error: " + e); };

            Regex oldIsValid = new Regex("");

            using (XmlReader reader = XmlReader.Create(source, settings))
            {
                while (reader.Read())
                {
                    if (reader.IsStartElement())
                    {
                        switch (reader.Name)
                        {
                        case "spreadsheet":
                            try
                            {
                                oldIsValid = new Regex(reader["IsValid"]);
                            }
                            catch (Exception e)
                            {
                                throw new SpreadsheetReadException(e.Message);
                            }
                            break;

                        case "cell":
                            if (cells.ContainsKey(reader["name"].ToUpper()))
                            {
                                throw new SpreadsheetReadException("Duplicate cell name: " + reader["name"].ToUpper());
                            }
                            if (!oldIsValid.IsMatch(reader["name"]))
                            {
                                throw new SpreadsheetReadException("According to the old IsValid regex, " + reader["name"] + " is not a valid cell name");
                            }
                            if (!validator.IsMatch(reader["name"]))
                            {
                                throw new SpreadsheetVersionException("According to the new IsValid regex, " + reader["name"] + " is not a valid cell name");
                            }
                            ValidateVarsUsingOld(reader["contents"], oldIsValid);
                            try
                            {
                                SetContentsOfCell(reader["name"], reader["contents"]);
                            }
                            catch (CircularException e)
                            {
                                throw new SpreadsheetReadException(e.Message);
                            }
                            catch (Exception e)
                            {
                                throw new SpreadsheetVersionException(e.Message);
                            }
                            break;
                        }
                    }
                }
            }
            changed = false;
        }
        /// <summary>
        /// Constructor for Spreadsheet to create a new spreadsheetCells dictionary
        /// and a dependencies dependency graph object.
        /// This constructor creates a Spreadsheet that is a duplicate of the spreadsheet
        /// saved in source.
        /// If there's a problem reading source, throws an IOException
        /// If the contents of source is not formatted properly, throws a SpreadsheetReadException.
        /// </summary>
        public Spreadsheet(TextReader source)
        {
            try
            {
                // Create an empty spreadsheetCells dictionary
                spreadsheetCells = new Dictionary <String, Cell>();
                // Create an empty dependencies DG
                dependencies = new DependencyGraph();


                // Read in the XML file
                using (XmlReader reader = XmlReader.Create(source))
                {
                    // Create a temporary cell object
                    Cell readCell = new Cell();
                    while (reader.Read())
                    {
                        if (reader.IsStartElement())
                        {
                            switch (reader.Name)
                            {
                            // If reader is on spreadsheet, read in and set the isvalid regex
                            case "spreadsheet":
                                reader.MoveToFirstAttribute();
                                reader.ReadAttributeValue();
                                String regex     = reader.Value;
                                Regex  tempRegex = new Regex(regex);
                                isValidRegex = tempRegex;
                                break;

                            // If reader is on cell, initialize a new temporary cell
                            case "cell":
                                readCell = new Cell();
                                break;

                            // If reader is on name, set the temporary cell's name to name
                            case "name":
                                reader.Read();
                                String name = reader.Value;
                                readCell.cellName = name;
                                break;

                            // If reader is on contents, set the temporary cell's contents to contents
                            // and add the temporary cell to the spreadsheet
                            case "contents":
                                reader.Read();
                                String contents = reader.Value;
                                readCell.cellContents = contents;
                                SetContentsOfCell(readCell.cellName, contents);
                                break;
                            }
                        }
                    }
                }
                // Set Changed equal to false
                Changed = false;
            }
            catch (IOException)
            {
                throw new IOException();
            }
            catch (XmlException e)
            {
                throw new SpreadsheetReadException(e.Message);
            }
        }
Ejemplo n.º 14
0
 /// <summary>
 /// Constructor for Spreadsheet with zero arguments
 /// </summary>
 public Spreadsheet()
 {
     dependency_graph = new DependencyGraph();
     cell             = new Dictionary <String, Cell>();
 }
Ejemplo n.º 15
0
        /// <summary>
        /// Creates a Spreadsheet that is a duplicate of the spreadsheet saved in source.
        /// See the AbstractSpreadsheet.Save method for the file format specification.
        /// If there's a problem reading source, throws an IOException
        /// If the contents of source is not formatted properly, throws a SpreadsheetReadException
        ///
        /// Sample reading file:
        ///
        /// <spreadsheet isvalid="IsValid regex goes here">
        ///   <cell>
        ///     <name>
        ///       cell name goes here
        ///     </name>
        ///     <contents>
        ///       cell contents goes here
        ///     </contents>
        ///   </cell>
        /// </spreadsheet>
        ///
        /// The value of the isvalid attribute should be IsValid.ToString()
        /// </summary>
        public Spreadsheet(TextReader source)
        {
            // Initiating our DependencyGraph and our Cells Dictionary
            DGSpreadsheet  = new DependencyGraph();
            cellDictionary = new Dictionary <string, Cell>();

            // Local variables to hold the xml data (name of cell and content of cell)
            string tempCellName = "";
            string tempContent  = "";

            isValidBool = true;

            // Using xml processing to break the different elements of a source reader into
            // usuable information to make a spreadsheet. If we have difficulty reading the input file
            // we throw a IOException
            try
            {
                using (XmlReader xmlReader = XmlReader.Create(source))
                {
                    // if any elements read are not in an appropriate format,
                    // we throw a Spreadsheet read exception
                    try
                    {
                        while (xmlReader.Read())
                        {
                            if (xmlReader.IsStartElement())
                            {
                                switch (xmlReader.Name.ToString())
                                {
                                // Checking for the title of the xml file and grabbing
                                // a regex expression if one exists
                                case "spreadsheet":

                                    isValid = new Regex(xmlReader.GetAttribute("isvalid"));
                                    break;

                                // cell is checked only for formatting purposes that were given
                                // in the assignment description
                                case "cell":
                                    break;


                                // Grabing the name of the cell (stored in a temp variable)
                                case "name":
                                    tempCellName = xmlReader.ReadString();
                                    // Checking if the name is valid
                                    if (!nameValidation(tempCellName))
                                    {
                                        throw new InvalidNameException();
                                    }
                                    break;

                                // Grabing the content of the cell and setting a cell using SetContentsOfCell
                                case "contents":
                                    tempContent = xmlReader.ReadString();
                                    SetContentsOfCell(tempCellName, tempContent);
                                    break;

                                default:
                                    throw new SpreadsheetReadException("Error in reading spreadsheet");
                                }
                            }
                        }
                        Changed = false;
                    }
                    catch (Exception)
                    {
                        throw new SpreadsheetReadException("There was a problem reading from the input file.");
                    }
                }
            }
            catch (IOException) { throw new IOException("There was an issue reading from the source file"); }
        }
Ejemplo n.º 16
0
 /// <summary>
 /// constructor for spreadsheet with no parameters
 ///
 /// </summary>
 public Spreadsheet() : base(s => true, s => s, "default")
 {
     spreadsheet = new Dictionary <string, Cell>();
     graph       = new DependencyGraph();
     changed     = false;
 }
Ejemplo n.º 17
0
        /// <summary>
        /// creates a Spreadsheet from a saved file
        /// </summary>
        public Spreadsheet(TextReader source, Regex newIsValid)//CHANGE HERE FOR REGRADE
        {
            cells   = new Dictionary <string, Cell>();
            dg      = new DependencyGraph();
            changed = false;

            try
            {
                XmlSchemaSet sc = new XmlSchemaSet();
                sc.Add(null, "Spreadsheet.xsd");

                XmlReaderSettings settings = new XmlReaderSettings();
                settings.ValidationType = ValidationType.Schema;
                settings.Schemas        = sc;


                //using xml reader to read file
                try
                {
                    XmlReader reader = XmlReader.Create(source, settings);//CHANGE HERE

                    //cell name
                    string cellName = "";
                    //cell value
                    string cellContent = "";

                    bool RegexMatch = true;

                    bool setContents;

                    while (reader.Read())
                    {
                        if (reader.IsStartElement())
                        {
                            setContents = false;
                            string name = reader.Name;

                            switch (name)
                            {
                            case "spreadsheet":
                                string v = reader.GetAttribute("IsValid");
                                try
                                {
                                    oldValid = new Regex(v);
                                }
                                catch (Exception)
                                {
                                    throw new SpreadsheetReadException("invalid Regex");
                                }


                                if (string.IsNullOrEmpty(oldValid.ToString()))
                                {
                                    RegexMatch = false;
                                }


                                else if (oldValid.ToString().Equals(newIsValid.ToString()))
                                {
                                    RegexMatch = true;
                                }



                                valid = newIsValid;

                                break;

                            //read the cell name
                            case "cell":
                                string a = reader.GetAttribute("name");
                                cellName = a;
                                string b = reader.GetAttribute("contents");
                                cellContent = b;
                                setContents = true;



                                if (!Regex.IsMatch(a, newIsValid.ToString()))
                                {
                                    throw new SpreadsheetVersionException("Spreadsheet version");
                                }

                                if (!Regex.IsMatch(a, oldValid.ToString()))
                                {
                                    throw new SpreadsheetReadException("invalid regex");
                                }
                                break;
                            }

                            if (!RegexMatch)
                            {
                                throw new SpreadsheetReadException("Regex does not match");
                            }



                            if (setContents)
                            {
                                if (cells.ContainsKey(cellName))
                                {
                                    throw new SpreadsheetReadException("duplicate cell");
                                }
                                SetContentsOfCell(cellName, cellContent);
                            }
                        }
                    }

                    reader.Close();
                }
                catch (XmlException)
                {
                    throw new SpreadsheetReadException("Spreadsheet cannot be read");
                }
            }
            catch (XmlSchemaException)
            {
                throw new SpreadsheetReadException("Spreadsheet cannot be read");
            }
        }
Ejemplo n.º 18
0
 /// <summary>
 /// Empty argument constructor.
 /// </summary>
 public Spreadsheet() : base(s => true, s => s, "default")
 {
     graph   = new DependencyGraph();
     cellMap = new Dictionary <string, Cell>();
 }
Ejemplo n.º 19
0
        /// If there's a problem reading source, throws an IOException.
        ///
        /// Else if the contents of source are not consistent with the schema in Spreadsheet.xsd,
        /// throws a SpreadsheetReadException.
        ///
        /// Else if the IsValid string contained in source is not a valid C# regular expression, throws
        /// a SpreadsheetReadException.  (If the exception is not thrown, this regex is referred to
        /// below as oldIsValid.)
        ///
        /// Else if there is a duplicate cell name in the source, throws a SpreadsheetReadException.
        /// (Two cell names are duplicates if they are identical after being converted to upper case.)
        ///
        /// Else if there is an invalid cell name or an invalid formula in the source, throws a
        /// SpreadsheetReadException.  (Use oldIsValid in place of IsValid in the definition of
        /// cell name validity.)
        ///
        /// Else if there is an invalid cell name or an invalid formula in the source, throws a
        /// SpreadsheetVersionException.  (Use newIsValid in place of IsValid in the definition of
        /// cell name validity.)
        ///
        /// Else if there's a formula that causes a circular dependency, throws a SpreadsheetReadException.
        ///
        /// Else, create a Spreadsheet that is a duplicate of the one encoded in source except that
        /// the new Spreadsheet's IsValid regular expression should be newIsValid.
        public Spreadsheet(TextReader source, Regex newIsValid)
        {
            this.dg    = new DependencyGraph();
            this.cells = new Dictionary <string, Cell>();

            Regex checkValid = newIsValid;

            XmlSchemaSet schema = new XmlSchemaSet();

            schema.Add(null, "Spreadsheet.xsd");

            XmlReaderSettings xmlSetting = new XmlReaderSettings();

            xmlSetting.ValidationType          = ValidationType.Schema;
            xmlSetting.Schemas                 = schema;
            xmlSetting.ValidationEventHandler += (object sender, ValidationEventArgs e) => throw new SpreadsheetReadException("not valid");

            using (XmlReader xmlReader = XmlReader.Create(source, xmlSetting))
            {
                while (xmlReader.Read())
                {
                    if (xmlReader.IsStartElement())
                    {
                        if (xmlReader.Name == "cell")
                        {
                            if (cells.ContainsKey(xmlReader["name"]))
                            {
                                throw new SpreadsheetReadException("duplicate cell in the source");
                            }

                            IsValid = checkValid;
                            try
                            {
                                this.SetContentsOfCell(xmlReader["name"], xmlReader["contents"]);
                            }
                            catch (FormulaFormatException e)
                            {
                                throw new SpreadsheetReadException("invalid");
                            }
                            catch (CircularException e)
                            {
                                throw new SpreadsheetReadException("invalid");
                            }
                            catch (InvalidNameException e)
                            {
                                throw new SpreadsheetReadException("invalid");
                            }


                            IsValid = newIsValid;
                            try
                            {
                                this.SetContentsOfCell(xmlReader["name"], xmlReader["contents"]);
                            }
                            catch (FormulaFormatException e)
                            {
                                throw new SpreadsheetVersionException("invalid");
                            }
                            catch (CircularException e)
                            {
                                throw new SpreadsheetVersionException("invalid");
                            }
                            catch (InvalidNameException e)
                            {
                                throw new SpreadsheetVersionException("invalid");
                            }
                        }
                        else if (xmlReader.Name == "spreadsheet")
                        {
                            try
                            {
                                checkValid = new Regex(xmlReader["IsValid"]);
                            }
                            catch (ArgumentException e)
                            {
                                throw new SpreadsheetReadException("invalid");
                            }
                        }
                    }
                }
            }
        }
 // ADDED FOR PS5
 /// <summary>
 /// Constructs a 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)
 {
     usedCells = new Dictionary <string, Cell>();
     depGraph  = new DependencyGraph();
 }
Ejemplo n.º 21
0
 /// <summary>
 /// constrctor
 /// </summary>
 public Spreadsheet()
 {
     DG    = new DependencyGraph();
     Sheet = new Dictionary <string, Cell>();
 }
Ejemplo n.º 22
0
 /// <summary>
 /// Constructor Method, sets all data values to new.
 /// </summary>
 public Spreadsheet() : base(s => true, s => s, "default")
 {
     spreadSheetCells = new Dictionary <string, Cell>();
     dependencies     = new DependencyGraph();
     Changed          = false;
 }