Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
04/15/08 16:41:18 (16 years ago)
Author:
gkronber
Message:

created a branch that combines the XmlReader and XmlWriter branches

Location:
branches/XmlReaderWriterBranch
Files:
13 edited
2 copied

Legend:

Unmodified
Added
Removed

  • branches/XmlReaderWriterBranch/HeuristicLab.Core/AtomicOperation.cs

    r119 r125  
    6262      PersistenceManager.Persist("Scope", Scope, writer, persistedObjects);
    6363    }
    64     public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
    65       base.Populate(node, restoredObjects);
    66       myOperator = (IOperator)PersistenceManager.Restore(node.SelectSingleNode("Operator"), restoredObjects);
    67       myScope = (IScope)PersistenceManager.Restore(node.SelectSingleNode("Scope"), restoredObjects);
     64    //public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
     65    //  base.Populate(node, restoredObjects);
     66    //  myOperator = (IOperator)PersistenceManager.Restore(node.SelectSingleNode("Operator"), restoredObjects);
     67    //  myScope = (IScope)PersistenceManager.Restore(node.SelectSingleNode("Scope"), restoredObjects);
     68    //}
     69    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     70      base.Populate(reader, restoredObjects);
     71      reader.Read();
     72      myOperator = (IOperator)PersistenceManager.Restore(reader, "Operator", restoredObjects);
     73      reader.Skip();
     74      myScope = (IScope)PersistenceManager.Restore(reader, "Scope", restoredObjects);
     75      reader.Read();
    6876    }
    6977    #endregion

  • branches/XmlReaderWriterBranch/HeuristicLab.Core/CompositeOperation.cs

    r119 r125  
    7979      writer.WriteEndElement(); // </Operations>
    8080    }
    81     public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
    82       base.Populate(node, restoredObjects);
     81    //public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
     82    //  base.Populate(node, restoredObjects);
    8383
    84       myExecuteInParallel = bool.Parse(node.Attributes["ExecuteInParallel"].Value);
     84    //  myExecuteInParallel = bool.Parse(node.Attributes["ExecuteInParallel"].Value);
    8585
    86       XmlNode operationsNode = node.SelectSingleNode("Operations");
    87       for (int i = 0; i < operationsNode.ChildNodes.Count; i++)
    88         AddOperation((IOperation)PersistenceManager.Restore(operationsNode.ChildNodes[i], restoredObjects));
     86    //  XmlNode operationsNode = node.SelectSingleNode("Operations");
     87    //  for (int i = 0; i < operationsNode.ChildNodes.Count; i++)
     88    //    AddOperation((IOperation)PersistenceManager.Restore(operationsNode.ChildNodes[i], restoredObjects));
     89    //}
     90    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     91      myExecuteInParallel = bool.Parse(reader["ExecuteInParallel"]);
     92      base.Populate(reader, restoredObjects);
     93
     94      if(reader.Name != "Operations") throw new XmlException("Expected: \"Operations\", found: \""+reader.Name+"\"");
     95      if(!reader.IsEmptyElement) {
     96        reader.Read();
     97        while(reader.IsStartElement()) {
     98          AddOperation((IOperation)PersistenceManager.Restore(reader, restoredObjects));
     99          reader.Skip();
     100        }
     101        reader.ReadEndElement();
     102      } else {
     103        reader.Read();
     104      }
    89105    }
    90106    #endregion

  • branches/XmlReaderWriterBranch/HeuristicLab.Core/ConstrainedItemBase.cs

    r119 r125  
    3939      ConstrainedItemBase clone = (ConstrainedItemBase)base.Clone(clonedObjects);
    4040      clone.myConstraints.Clear();
    41       foreach (IConstraint constraint in Constraints)
     41      foreach(IConstraint constraint in Constraints)
    4242        clone.AddConstraint((IConstraint)Auxiliary.Clone(constraint, clonedObjects));
    4343      return clone;
    … …  
    4949    }
    5050    public virtual void RemoveConstraint(IConstraint constraint) {
    51       if (myConstraints.Remove(constraint))
     51      if(myConstraints.Remove(constraint))
    5252        OnConstraintRemoved(constraint);
    5353    }
    … …  
    5555    public bool IsValid() {
    5656      bool result = true;
    57       foreach (IConstraint constraint in Constraints)
     57      foreach(IConstraint constraint in Constraints)
    5858        result = result && constraint.Check(this);
    5959      return result;
    … …  
    6262      bool result = true;
    6363      violatedConstraints = new List<IConstraint>();
    64       foreach (IConstraint constraint in Constraints) {
    65         if (!constraint.Check(this)) {
     64      foreach(IConstraint constraint in Constraints) {
     65        if(!constraint.Check(this)) {
    6666          result = false;
    6767          violatedConstraints.Add(constraint);
    … …  
    7777    public event EventHandler<ConstraintEventArgs> ConstraintAdded;
    7878    protected virtual void OnConstraintAdded(IConstraint constraint) {
    79       if (ConstraintAdded != null)
     79      if(ConstraintAdded != null)
    8080        ConstraintAdded(this, new ConstraintEventArgs(constraint));
    8181    }
    8282    public event EventHandler<ConstraintEventArgs> ConstraintRemoved;
    8383    protected virtual void OnConstraintRemoved(IConstraint constraint) {
    84       if (ConstraintRemoved != null)
     84      if(ConstraintRemoved != null)
    8585        ConstraintRemoved(this, new ConstraintEventArgs(constraint));
    8686    }
    … …  
    106106      }
    107107    }
    108     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    109       base.Populate(node, restoredObjects);
    110       XmlNode constraintsNode = node.SelectSingleNode("Constraints");
    111       if (constraintsNode != null) {
     108    //public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
     109    //  base.Populate(node, restoredObjects);
     110    //  XmlNode constraintsNode = node.SelectSingleNode("Constraints");
     111    //  if(constraintsNode != null) {
     112    //    myConstraints.Clear();
     113    //    foreach(XmlNode constraintNode in constraintsNode.ChildNodes)
     114    //      AddConstraint((IConstraint)PersistenceManager.Restore(constraintNode, restoredObjects));
     115    //  }
     116    //}
     117    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     118      base.Populate(reader, restoredObjects);
     119      reader.Read();
     120      if(reader.Name == "Constraints") {
    112121        myConstraints.Clear();
    113         foreach (XmlNode constraintNode in constraintsNode.ChildNodes)
    114           AddConstraint((IConstraint)PersistenceManager.Restore(constraintNode, restoredObjects));
     122        reader.Read();
     123        while(reader.IsStartElement()) {
     124          AddConstraint((IConstraint)PersistenceManager.Restore(reader, restoredObjects));
     125          reader.Skip();
     126        }
     127        reader.ReadEndElement();
    115128      }
    116129    }

  • branches/XmlReaderWriterBranch/HeuristicLab.Core/EngineBase.cs

    r119 r125  
    204204      writer.WriteEndElement(); // </ExecutionTime>
    205205    }
    206     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    207       base.Populate(node, restoredObjects);
    208       myOperatorGraph = (IOperatorGraph)PersistenceManager.Restore(node.SelectSingleNode("OperatorGraph"), restoredObjects);
    209       myGlobalScope = (IScope)PersistenceManager.Restore(node.SelectSingleNode("GlobalScope"), restoredObjects);
    210 
    211       XmlNode stackNode = node.SelectSingleNode("ExecutionStack");
    212       for (int i = stackNode.ChildNodes.Count - 1; i >= 0; i--)
    213         myExecutionStack.Push((IOperation)PersistenceManager.Restore(stackNode.ChildNodes[i], restoredObjects));
    214 
    215       XmlNode timeNode = node.SelectSingleNode("ExecutionTime");
    216       myExecutionTime = TimeSpan.Parse(timeNode.InnerText);
     206    public override void Populate(XmlReader reader, IDictionary<Guid,IStorable> restoredObjects) {
     207      base.Populate(reader, restoredObjects);
     208      reader.Read();
     209      myOperatorGraph = (IOperatorGraph)PersistenceManager.Restore(reader, "OperatorGraph", restoredObjects);
     210      reader.Skip();
     211      myGlobalScope = (IScope)PersistenceManager.Restore(reader, "GlobalScope", restoredObjects);
     212      reader.Skip();
     213      if(reader.Name!="ExecutionStack") throw new XmlException("Expected \"ExecutionStack\", found: \""+reader.Name+"\"");
     214      List<IOperation> operationList = new List<IOperation>();
     215      if(!reader.IsEmptyElement) {
     216        reader.Read();
     217        while(reader.IsStartElement()) {
     218          operationList.Insert(0, (IOperation)PersistenceManager.Restore(reader, restoredObjects));
     219          reader.Skip();
     220        }
     221        reader.ReadEndElement();
     222      } else {
     223        reader.Read();
     224      }
     225      foreach(IOperation op in operationList)
     226        myExecutionStack.Push(op);
     227      myExecutionTime = TimeSpan.Parse(reader.ReadElementString("ExecutionTime"));
    217228    }
    218229    #endregion

  • branches/XmlReaderWriterBranch/HeuristicLab.Core/Interfaces/IStorable.cs

    r119 r125  
    3434    //XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects);
    3535    void Persist(string name, XmlWriter writer, IDictionary<Guid, IStorable> persistedObjects);
    36     void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects);
     36    void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects);
    3737  }
    3838}

  • branches/XmlReaderWriterBranch/HeuristicLab.Core/OperatorBase.cs

    r124 r125  
    480480      writer.WriteEndElement(); // </Variables>
    481481    }
    482     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    483       base.Populate(node, restoredObjects);
    484       myName = node.Attributes["Name"].Value;
    485       if (node.Attributes["Breakpoint"] != null)
    486         myBreakpoint = bool.Parse(node.Attributes["Breakpoint"].Value);
    487       XmlNode subOperatorsNode = node.SelectSingleNode("SubOperators");
    488       for (int i = 0; i < subOperatorsNode.ChildNodes.Count; i++)
    489         AddSubOperator((IOperator)PersistenceManager.Restore(subOperatorsNode.ChildNodes[i], restoredObjects));
    490       XmlNode infosNode = node.SelectSingleNode("VariableInfos");
     482    //public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
     483    //  base.Populate(node, restoredObjects);
     484    //  myName = node.Attributes["Name"].Value;
     485    //  if(node.Attributes["Breakpoint"] != null)
     486    //    myBreakpoint = bool.Parse(node.Attributes["Breakpoint"].Value);
     487    //  XmlNode subOperatorsNode = node.SelectSingleNode("SubOperators");
     488    //  for(int i = 0; i < subOperatorsNode.ChildNodes.Count; i++)
     489    //    AddSubOperator((IOperator)PersistenceManager.Restore(subOperatorsNode.ChildNodes[i], restoredObjects));
     490    //  XmlNode infosNode = node.SelectSingleNode("VariableInfos");
     491    //  myVariableInfos.Clear();
     492    //  foreach(XmlNode infoNode in infosNode.ChildNodes)
     493    //    AddVariableInfo((IVariableInfo)PersistenceManager.Restore(infoNode, restoredObjects));
     494    //  XmlNode variablesNode = node.SelectSingleNode("Variables");
     495    //  myVariables.Clear();
     496    //  foreach(XmlNode variableNode in variablesNode.ChildNodes)
     497    //    AddVariable((IVariable)PersistenceManager.Restore(variableNode, restoredObjects));
     498    //}
     499    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     500      myName = reader["Name"];
     501      if(reader["Breakpoint"] != null)
     502        myBreakpoint = bool.Parse(reader["Breakpoint"]);
     503
     504      base.Populate(reader, restoredObjects);
     505      // constraintItemBase already reads to the next subelement
     506      if(reader.Name != "SubOperators") throw new XmlException("Expected: \"SubOperators\" found: \"" + reader.Name+"\"");
     507      if(!reader.IsEmptyElement) {
     508        reader.Read();
     509        while(reader.IsStartElement()) {
     510          AddSubOperator((IOperator)PersistenceManager.Restore(reader, restoredObjects));
     511          reader.Skip();
     512        }
     513        reader.ReadEndElement();
     514      } else {
     515        reader.Read();
     516      }
     517      if(reader.Name != "VariableInfos") throw new XmlException("Expected: \"VariableInfos\" found: \"" + reader.Name+"\"");
    491518      myVariableInfos.Clear();
    492       foreach (XmlNode infoNode in infosNode.ChildNodes)
    493         AddVariableInfo((IVariableInfo)PersistenceManager.Restore(infoNode, restoredObjects));
    494       XmlNode variablesNode = node.SelectSingleNode("Variables");
     519      if(!reader.IsEmptyElement) {
     520        reader.Read();
     521        while(reader.IsStartElement()) {       
     522          AddVariableInfo((IVariableInfo)PersistenceManager.Restore(reader, restoredObjects));
     523          reader.Skip();
     524        }
     525        reader.ReadEndElement();
     526      } else {
     527        reader.Read();
     528      }
     529      if(reader.Name != "Variables") throw new XmlException("Expected: \"Variables\" found: \"" + reader.Name + "\"");
    495530      myVariables.Clear();
    496       foreach (XmlNode variableNode in variablesNode.ChildNodes)
    497         AddVariable((IVariable)PersistenceManager.Restore(variableNode, restoredObjects));
     531      if(!reader.IsEmptyElement) {
     532        reader.Read();
     533        while(reader.IsStartElement()) {
     534          AddVariable((IVariable)PersistenceManager.Restore(reader, restoredObjects));
     535          reader.Skip();
     536        }
     537        reader.ReadEndElement();
     538      } else {
     539        reader.Read();
     540      }
    498541    }
    499542    #endregion

  • branches/XmlReaderWriterBranch/HeuristicLab.Core/OperatorGraph.cs

    r119 r125  
    3535      get { return myInitialOperator; }
    3636      set {
    37         if (myInitialOperator != value) {
     37        if(myInitialOperator != value) {
    3838          myInitialOperator = value;
    3939          OnInitialOperatorChanged();
    … …  
    5353      OperatorGraph clone = new OperatorGraph();
    5454      clonedObjects.Add(Guid, clone);
    55       foreach (IOperator op in Operators)
     55      foreach(IOperator op in Operators)
    5656        clone.AddOperator((IOperator)Auxiliary.Clone(op, clonedObjects));
    57       if (InitialOperator != null)
     57      if(InitialOperator != null)
    5858        clone.myInitialOperator = (IOperator)Auxiliary.Clone(InitialOperator, clonedObjects);
    5959      return clone;
    … …  
    6161
    6262    public void AddOperator(IOperator op) {
    63       if (!myOperators.ContainsKey(op.Guid)) {
     63      if(!myOperators.ContainsKey(op.Guid)) {
    6464        myOperators.Add(op.Guid, op);
    6565        OnOperatorAdded(op);
    6666
    67         foreach (IOperator subOperator in op.SubOperators)
     67        foreach(IOperator subOperator in op.SubOperators)
    6868          AddOperator(subOperator);
    6969      }
    … …  
    7171    public void RemoveOperator(Guid guid) {
    7272      IOperator op = GetOperator(guid);
    73       if (op != null) {
    74         foreach (IOperator o in Operators) {
     73      if(op != null) {
     74        foreach(IOperator o in Operators) {
    7575          int i = 0;
    76           while (i < o.SubOperators.Count) {
    77             if (o.SubOperators[i] == op)
     76          while(i < o.SubOperators.Count) {
     77            if(o.SubOperators[i] == op)
    7878              o.RemoveSubOperator(i);
    7979            else
    … …  
    8181          }
    8282        }
    83         if (InitialOperator == op)
     83        if(InitialOperator == op)
    8484          InitialOperator = null;
    8585        myOperators.Remove(op.Guid);
    … …  
    8989    public IOperator GetOperator(Guid guid) {
    9090      IOperator op;
    91       if (myOperators.TryGetValue(guid, out op))
     91      if(myOperators.TryGetValue(guid, out op))
    9292        return op;
    9393      else
    … …  
    9797      Guid[] guids = new Guid[Operators.Count];
    9898      int i = 0;
    99       foreach (IOperator op in Operators) {
     99      foreach(IOperator op in Operators) {
    100100        guids[i] = op.Guid;
    101101        i++;
    102102      }
    103       for (int j = 0; j < guids.Length; j++)
     103      for(int j = 0; j < guids.Length; j++)
    104104        RemoveOperator(guids[j]);
    105105    }
    … …  
    107107    public event EventHandler<OperatorEventArgs> OperatorAdded;
    108108    protected virtual void OnOperatorAdded(IOperator op) {
    109       if (OperatorAdded != null)
     109      if(OperatorAdded != null)
    110110        OperatorAdded(this, new OperatorEventArgs(op));
    111111    }
    112112    public event EventHandler<OperatorEventArgs> OperatorRemoved;
    113113    protected virtual void OnOperatorRemoved(IOperator op) {
    114       if (OperatorRemoved != null)
     114      if(OperatorRemoved != null)
    115115        OperatorRemoved(this, new OperatorEventArgs(op));
    116116    }
    117117    public event EventHandler InitialOperatorChanged;
    118118    protected virtual void OnInitialOperatorChanged() {
    119       if (InitialOperatorChanged != null)
     119      if(InitialOperatorChanged != null)
    120120        InitialOperatorChanged(this, new EventArgs());
    121121    }
    … …  
    141141        PersistenceManager.Persist("InitialOperator", InitialOperator, writer, persistedObjects);
    142142    }
    143     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    144       base.Populate(node, restoredObjects);
     143    //public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
     144    //  base.Populate(node, restoredObjects);
    145145
    146       XmlNode ops = node.SelectSingleNode("Operators");
    147       for (int i = 0; i < ops.ChildNodes.Count; i++) {
    148         XmlNode opNode = ops.ChildNodes[i];
    149         IOperator op = (IOperator)PersistenceManager.Restore(opNode, restoredObjects);
     146    //  XmlNode ops = node.SelectSingleNode("Operators");
     147    //  for(int i = 0; i < ops.ChildNodes.Count; i++) {
     148    //    XmlNode opNode = ops.ChildNodes[i];
     149    //    IOperator op = (IOperator)PersistenceManager.Restore(opNode, restoredObjects);
     150    //    myOperators.Add(op.Guid, op);
     151    //  }
     152
     153    //  XmlNode initial = node.SelectSingleNode("InitialOperator");
     154    //  if(initial != null)
     155    //    myInitialOperator = (IOperator)PersistenceManager.Restore(initial, restoredObjects);
     156    //}
     157    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     158      base.Populate(reader, restoredObjects);
     159
     160      reader.Read();
     161      if(reader.Name != "Operators") throw new XmlException("Expected: Operators found: " + reader.Name);
     162      reader.Read();
     163      while(reader.IsStartElement()) {
     164        IOperator op = (IOperator)PersistenceManager.Restore(reader, restoredObjects);
     165        reader.Skip();
    150166        myOperators.Add(op.Guid, op);
    151167      }
    152 
    153       XmlNode initial = node.SelectSingleNode("InitialOperator");
    154       if (initial != null)
    155         myInitialOperator = (IOperator)PersistenceManager.Restore(initial, restoredObjects);
     168      reader.ReadEndElement();
     169      if(reader.IsStartElement()) {
     170        myInitialOperator = (IOperator)PersistenceManager.Restore(reader, "InitialOperator", restoredObjects);
     171      }
    156172    }
    157173    #endregion

  • branches/XmlReaderWriterBranch/HeuristicLab.Core/OperatorGroup.cs

    r119 r125  
    110110      writer.WriteEndElement(); // </Operators>
    111111    }
    112     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    113       base.Populate(node, restoredObjects);
    114       myName = node.Attributes["Name"].Value;
    115       XmlNode subGroupsNode = node.SelectSingleNode("SubGroups");
    116       foreach (XmlNode subGroupNode in subGroupsNode.ChildNodes)
    117         AddSubGroup((IOperatorGroup)PersistenceManager.Restore(subGroupNode, restoredObjects));
    118       XmlNode operatorsNode = node.SelectSingleNode("Operators");
    119       foreach (XmlNode operatorNode in operatorsNode.ChildNodes)
    120         AddOperator((IOperator)PersistenceManager.Restore(operatorNode, restoredObjects));
     112    //public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
     113    //  base.Populate(node, restoredObjects);
     114    //  myName = node.Attributes["Name"].Value;
     115    //  XmlNode subGroupsNode = node.SelectSingleNode("SubGroups");
     116    //  foreach(XmlNode subGroupNode in subGroupsNode.ChildNodes)
     117    //    AddSubGroup((IOperatorGroup)PersistenceManager.Restore(subGroupNode, restoredObjects));
     118    //  XmlNode operatorsNode = node.SelectSingleNode("Operators");
     119    //  foreach(XmlNode operatorNode in operatorsNode.ChildNodes)
     120    //    AddOperator((IOperator)PersistenceManager.Restore(operatorNode, restoredObjects));
     121    //}
     122    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     123      myName = reader["Name"];
     124      base.Populate(reader, restoredObjects);
     125      reader.Read();
     126      if(reader.Name != "SubGroups") throw new XmlException("Expected: \"SubGroups\", found: \"" + reader.Name + "\"");
     127      if(!reader.IsEmptyElement) {
     128        reader.Read();
     129        while(reader.IsStartElement()) {
     130          AddSubGroup((IOperatorGroup)PersistenceManager.Restore(reader, restoredObjects));
     131          reader.Skip();
     132        }
     133        reader.ReadEndElement();
     134      } else {
     135        reader.Read();
     136      }
     137      if(reader.Name != "Operators") throw new XmlException("Expected: \"Operators\", found: \"" + reader.Name + "\"");
     138      if(!reader.IsEmptyElement) {
     139        reader.Read();
     140        while(reader.IsStartElement()) {
     141          AddOperator((IOperator)PersistenceManager.Restore(reader, restoredObjects));
     142          reader.Skip();
     143        }
     144        reader.ReadEndElement();
     145      } else {
     146        reader.Read();
     147      }
    121148    }
    122149    #endregion

  • branches/XmlReaderWriterBranch/HeuristicLab.Core/OperatorLibrary.cs

    r119 r125  
    6060      PersistenceManager.Persist("OperatorGroup", Group, writer, persistedObjects);
    6161    }
    62     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    63       base.Populate(node, restoredObjects);
    64       myGroup = (IOperatorGroup)PersistenceManager.Restore(node.SelectSingleNode("OperatorGroup"), restoredObjects);
     62    public override void Populate(XmlReader reader, IDictionary<Guid,IStorable> restoredObjects) {
     63      base.Populate(reader, restoredObjects);
     64      reader.Read();
     65      myGroup = (IOperatorGroup)PersistenceManager.Restore(reader, "OperatorGroup", restoredObjects);
     66      reader.Read();
    6567    }
    6668    #endregion

  • branches/XmlReaderWriterBranch/HeuristicLab.Core/PersistenceManager.cs

    r119 r125  
    5757    }
    5858
    59     public static IStorable Restore(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    60       Guid guid = new Guid(node.Attributes["GUID"].Value);
    61       if (restoredObjects.ContainsKey(guid)) {
     59    public static IStorable Restore(XmlReader reader, string elementName, IDictionary<Guid, IStorable> restoredObjects) {
     60      reader = reader.ReadSubtree();
     61      reader.Read();
     62      if(reader.Name != elementName) throw new XmlException("Expected: \"" + elementName + "\" found: \"" + reader.Name+"\"");
     63      IStorable result = RestoreElement(reader, restoredObjects);
     64      reader.Read();
     65      reader.Close();
     66      return result;
     67    }
     68
     69    public static IStorable Restore(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     70      reader = reader.ReadSubtree();
     71      reader.Read();
     72      IStorable result = RestoreElement(reader, restoredObjects);
     73      reader.Read();
     74      reader.Close();
     75      return result;
     76    }
     77    private static IStorable RestoreElement(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     78      Guid guid = new Guid(reader["GUID"]);
     79      if(restoredObjects.ContainsKey(guid)) {       
    6280        return restoredObjects[guid];
    6381      } else {
    64         Type type = Type.GetType(node.Attributes["Type"].Value, true);
     82        Type type = Type.GetType(reader["Type"], true);
    6583        IStorable instance = (IStorable)Activator.CreateInstance(type);
    6684        restoredObjects.Add(guid, instance);
    67         instance.Populate(node, restoredObjects);
     85        instance.Populate(reader, restoredObjects);
    6886        return instance;
    6987      }
    … …  
    89107    }
    90108    public static IStorable Load(Stream stream) {
    91       XmlDocument doc = new XmlDocument();
    92       doc.Load(stream);
    93       return PersistenceManager.Restore(doc.ChildNodes[1], new Dictionary<Guid, IStorable>());
     109      XmlReaderSettings settings = new XmlReaderSettings();
     110      settings.IgnoreComments = true;
     111      settings.IgnoreWhitespace = true;
     112      XmlReader reader = XmlReader.Create(stream, settings);
     113      reader.MoveToContent(); // read "<?xml version="1.0"?/>
     114      return PersistenceManager.RestoreElement(reader, new Dictionary<Guid, IStorable>());
    94115    }
    95116

  • branches/XmlReaderWriterBranch/HeuristicLab.Core/Scope.cs

    r119 r125  
    311311      writer.WriteEndElement(); // </SubScopes>
    312312    }
    313     public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
    314       base.Populate(node, restoredObjects);
    315       myName = node.Attributes["Name"].Value;
    316 
    317       XmlNode variables = node.SelectSingleNode("Variables");
    318       foreach (XmlNode variableNode in variables.ChildNodes) {
    319         IVariable variable = (IVariable)PersistenceManager.Restore(variableNode, restoredObjects);
    320         AddVariable(variable);
    321       }
    322 
    323       XmlNode aliases = node.SelectSingleNode("Aliases");
    324       if (aliases != null) {
    325         foreach (XmlNode aliasNode in aliases.ChildNodes)
    326           AddAlias(aliasNode.Attributes["Alias"].Value, aliasNode.Attributes["Name"].Value);
    327       }
    328 
    329       XmlNode subScopes = node.SelectSingleNode("SubScopes");
    330       for (int i = 0; i < subScopes.ChildNodes.Count; i++) {
    331         IScope scope = (IScope)PersistenceManager.Restore(subScopes.ChildNodes[i], restoredObjects);
    332         AddSubScope(scope);
     313    //public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
     314    //  base.Populate(node, restoredObjects);
     315    //  myName = node.Attributes["Name"].Value;
     316
     317    //  XmlNode variables = node.SelectSingleNode("Variables");
     318    //  foreach(XmlNode variableNode in variables.ChildNodes) {
     319    //    IVariable variable = (IVariable)PersistenceManager.Restore(variableNode, restoredObjects);
     320    //    AddVariable(variable);
     321    //  }
     322
     323    //  XmlNode aliases = node.SelectSingleNode("Aliases");
     324    //  if(aliases != null) {
     325    //    foreach(XmlNode aliasNode in aliases.ChildNodes)
     326    //      AddAlias(aliasNode.Attributes["Alias"].Value, aliasNode.Attributes["Name"].Value);
     327    //  }
     328
     329    //  XmlNode subScopes = node.SelectSingleNode("SubScopes");
     330    //  for(int i = 0; i < subScopes.ChildNodes.Count; i++) {
     331    //    IScope scope = (IScope)PersistenceManager.Restore(subScopes.ChildNodes[i], restoredObjects);
     332    //    AddSubScope(scope);
     333    //  }
     334    //}
     335    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     336      myName = reader["Name"];
     337      base.Populate(reader, restoredObjects);
     338      reader.Read();
     339      if(reader.Name != "Variables") throw new XmlException("Expected: \"Variables\", found: \""+reader.Name+"\"");
     340      if(!reader.IsEmptyElement) {
     341        reader.Read();
     342        while(reader.IsStartElement()) {
     343          IVariable variable = (IVariable)PersistenceManager.Restore(reader, restoredObjects);
     344          reader.Skip();
     345          AddVariable(variable);
     346        }
     347        reader.ReadEndElement();
     348      } else {
     349        reader.Read();
     350      }
     351      if(reader.Name == "Aliases" && !reader.IsEmptyElement) {
     352        reader.Read();
     353        while(reader.IsStartElement()) {
     354          AddAlias(reader["Alias"], reader["Name"]);
     355        }
     356        reader.ReadEndElement();
     357      } else {
     358        reader.Read();
     359      }
     360      if(reader.Name != "SubScopes") throw new XmlException("Expected: \"SubScopes\", found: \"" + reader.Name + "\"");
     361      if(!reader.IsEmptyElement) {
     362        reader.Read();
     363        while(reader.IsStartElement()) {
     364          IScope scope = (IScope)PersistenceManager.Restore(reader, restoredObjects);
     365          reader.Skip();
     366          AddSubScope(scope);
     367        }
     368        reader.ReadEndElement();
     369      } else {
     370        reader.Read();
    333371      }
    334372    }

  • branches/XmlReaderWriterBranch/HeuristicLab.Core/StorableBase.cs

    r119 r125  
    5959      writer.WriteAttributeString("GUID", Guid.ToString());
    6060    }
    61     public virtual void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    62       myGuid = new Guid(node.Attributes["GUID"].Value);
     61    public virtual void Populate(XmlReader reader, IDictionary<Guid,IStorable> restoredObjects) {
     62      myGuid = new Guid(reader["GUID"]);
    6363    }
    6464  }

  • branches/XmlReaderWriterBranch/HeuristicLab.Core/Variable.cs

    r119 r125  
    115115        PersistenceManager.Persist("Value", Value, writer, persistedObjects);
    116116    }
    117     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    118       myName = node.Attributes["Name"].Value;
    119       XmlNode valueNode = node.SelectSingleNode("Value");
    120       if (valueNode != null)
    121         myValue = (IItem)PersistenceManager.Restore(valueNode, restoredObjects);
     117    //public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
     118    //  myName = node.Attributes["Name"].Value;
     119    //  XmlNode valueNode = node.SelectSingleNode("Value");
     120    //  if(valueNode != null)
     121    //    myValue = (IItem)PersistenceManager.Restore(valueNode, restoredObjects);
     122    //}
     123    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     124      myName = reader["Name"];
     125      reader.Read();
     126      if(reader.IsStartElement())
     127        myValue = (IItem)PersistenceManager.Restore(reader, "Value", restoredObjects);
    122128    }
    123129    #endregion

  • branches/XmlReaderWriterBranch/HeuristicLab.Core/VariableInfo.cs

    r119 r125  
    146146      writer.WriteAttributeString("Local", Local.ToString());
    147147    }
    148     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    149       myActualName = node.Attributes["ActualName"].Value;
    150       myFormalName = node.Attributes["FormalName"].Value;
    151       myDescription = node.Attributes["Description"].Value;
    152       myDataType = Type.GetType(node.Attributes["DataType"].Value, true);
    153       myKind = (VariableKind)Enum.Parse(typeof(VariableKind), node.Attributes["Kind"].Value);
    154       myLocal = bool.Parse(node.Attributes["Local"].Value);
     148    //public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
     149    //  myActualName = node.Attributes["ActualName"].Value;
     150    //  myFormalName = node.Attributes["FormalName"].Value;
     151    //  myDescription = node.Attributes["Description"].Value;
     152    //  myDataType = Type.GetType(node.Attributes["DataType"].Value, true);
     153    //  myKind = (VariableKind)Enum.Parse(typeof(VariableKind), node.Attributes["Kind"].Value);
     154    //  myLocal = bool.Parse(node.Attributes["Local"].Value);
     155    //}
     156    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     157      myActualName = reader["ActualName"];
     158      myFormalName = reader["FormalName"];
     159      myDescription = reader["Description"];
     160      myDataType = Type.GetType(reader["DataType"], true);
     161      myKind = (VariableKind)Enum.Parse(typeof(VariableKind), reader["Kind"]);
     162      myLocal = bool.Parse(reader["Local"]);
    155163    }
    156164    #endregion
Note: See TracChangeset for help on using the changeset viewer.