Exemplo n.º 1
0
        // deserialize an object from the given XML file
        public static AbstractExercise ReadExerciseFromXml(string fileName)
        {
            if (fileName == null)
            {
                throw new System.ArgumentNullException();
            }

            // open XML file in FileStream
            FileStream xmlFile = new FileStream(fileName, FileMode.Open);

            // crete a text XML reader
            // associated it with the opened XML file above
            XmlDictionaryReader reader =
                XmlDictionaryReader.CreateTextReader(xmlFile, new XmlDictionaryReaderQuotas());

            // create a serializer for the AbstratExercise type
            DataContractSerializer serizalizer = new DataContractSerializer(typeof(AbstractExercise));

            // Deserialize the object
            AbstractExercise exercise = (AbstractExercise)serizalizer.ReadObject(reader, true);

            // close streams
            reader.Close();
            xmlFile.Close();

            return(exercise);
        }
Exemplo n.º 2
0
        // serialize the object exercise into XML file by fileName
        public static void WriteExerciseToXml(AbstractExercise exercise, string fileName)
        {
            if (exercise == null ||
                fileName == null)
            {
                throw new System.ArgumentNullException();
            }

            // open the XML file in FileStream
            // overwrite the file if it exists, otherwise create a new one
            FileStream xmlFile = new FileStream(fileName, FileMode.Create);

            // create a text XML writer
            // associated it with the opened XML file stream above
            XmlDictionaryWriter xmlWriter = XmlDictionaryWriter.CreateTextWriter(xmlFile);

            // create a serializer for the AbstractExercise type
            DataContractSerializer serializer =
                new DataContractSerializer(typeof(AbstractExercise));

            // serialize the exercise object
            serializer.WriteObject(xmlWriter, exercise);

            // close streams
            xmlWriter.Close();
            xmlFile.Close();
        }
Exemplo n.º 3
0
        protected override void DeleteThisExercise()
        {
            foreach (KeyValuePair <string, AbstractExercise> pair in NestedExercises_)
            {
                AbstractExercise.DeleteThis((AbstractExercise)pair.Value);
            }

            InvalidateThis();
        }
Exemplo n.º 4
0
 // Equals (overload object.Equals())
 // use the overriden GetHashCode() to test equality.
 public bool Equals(AbstractExercise oth)
 {
     TestValid();
     if (null == oth)
     {
         return(false);
     }
     else
     {
         return(this.GetHashCode() == oth.GetHashCode());
     }
 }
Exemplo n.º 5
0
        // delete an exercise in this album
        public bool DeleteExercise(string name)
        {
            TestValid();

            if (name != null && NestedExercises_.ContainsKey(name))
            {
                AbstractExercise ae = NestedExercises_[name];
                AbstractExercise.DeleteThis(ae);
                NestedExercises_.Remove(name);
                return(true);
            }

            return(false);
        }
Exemplo n.º 6
0
        // get and return the exercise named exerciseName
        // nested in workDirectory
        public static AbstractExercise GetExercise(ExerciseAlbum workDirectory, string exerciseName)
        {
            // validate input arguments
            if (workDirectory == null ||
                exerciseName == null ||
                exerciseName == string.Empty)
            {
                throw new System.ArgumentException();
            }

            // get exercise
            AbstractExercise exercise = workDirectory.GetExercise(exerciseName);

            // validate the result
            if (exercise == null)
            {
                throw new System.Exception(
                          "this album does not contain such exercise album or exercise single!");
            }
            return(exercise);
        }
Exemplo n.º 7
0
        // add
        // return true if success and vice versa
        public bool AddExercise(AbstractExercise exercise)
        {
            TestValid();

            // validate input
            if (exercise == null || exercise.Name == string.Empty)
            {
                return(false);
            }

            // check duplicate exercise by name
            // throw an exception if a duplicate exists
            if (NestedExercises_.ContainsKey(exercise.Name))
            {
                string ErrorInfo = "This album already has a(n) " + exercise.Name + "!";
                throw new System.Exception(ErrorInfo);
            }

            // insert to the backing field
            //AbstractExercise newExercise = (AbstractExercise)exercise.Clone();
            NestedExercises_.Add(exercise.Name, exercise);

            return(true);
        }
Exemplo n.º 8
0
 // load root album
 //private static string rootAlbum = "RootAlbum.xml";
 public static ExerciseAlbum LoadRootExerciseAlbum(string rootAlbumPath)
 {
     return((ExerciseAlbum)AbstractExercise.ReadExerciseFromXml(rootAlbumPath));
 }
Exemplo n.º 9
0
 // to call the correct version of DeleteThisExercise at run-time
 // based on the actual type of the object ae
 protected static void DeleteThis(AbstractExercise ae)
 {
     ae.DeleteThisExercise();
 }