Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
04/14/08 21:51:15 (16 years ago)
Author:
gkronber
Message:

created a branch that uses XmlTextReader instead of XMLDocument to load documents. Investigating ticket #103. (...work in progress!)

Location:
branches/XmlTextReaderBranch
Files:
14 edited
1 copied

Legend:

Unmodified
Added
Removed

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

    r2 r121  
    5757      return node;
    5858    }
    59     public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
    60       base.Populate(node, restoredObjects);
    61       myOperator = (IOperator)PersistenceManager.Restore(node.SelectSingleNode("Operator"), restoredObjects);
    62       myScope = (IScope)PersistenceManager.Restore(node.SelectSingleNode("Scope"), restoredObjects);
     59    //public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
     60    //  base.Populate(node, restoredObjects);
     61    //  myOperator = (IOperator)PersistenceManager.Restore(node.SelectSingleNode("Operator"), restoredObjects);
     62    //  myScope = (IScope)PersistenceManager.Restore(node.SelectSingleNode("Scope"), restoredObjects);
     63    //}
     64    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     65      base.Populate(reader, restoredObjects);
     66      myOperator = (IOperator)PersistenceManager.Restore(reader, "Operator", restoredObjects);
     67      myScope = (IScope)PersistenceManager.Restore(reader, "Scope", restoredObjects);
    6368    }
    6469    #endregion

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

    r2 r121  
    7171      return node;
    7272    }
    73     public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
    74       base.Populate(node, restoredObjects);
     73    //public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
     74    //  base.Populate(node, restoredObjects);
    7575
    76       myExecuteInParallel = bool.Parse(node.Attributes["ExecuteInParallel"].Value);
     76    //  myExecuteInParallel = bool.Parse(node.Attributes["ExecuteInParallel"].Value);
    7777
    78       XmlNode operationsNode = node.SelectSingleNode("Operations");
    79       for (int i = 0; i < operationsNode.ChildNodes.Count; i++)
    80         AddOperation((IOperation)PersistenceManager.Restore(operationsNode.ChildNodes[i], restoredObjects));
     78    //  XmlNode operationsNode = node.SelectSingleNode("Operations");
     79    //  for (int i = 0; i < operationsNode.ChildNodes.Count; i++)
     80    //    AddOperation((IOperation)PersistenceManager.Restore(operationsNode.ChildNodes[i], restoredObjects));
     81    //}
     82    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     83      base.Populate(reader, restoredObjects);
     84
     85      myExecuteInParallel = bool.Parse(reader["ExecuteInParallel"]);
     86
     87      reader.ReadStartElement("Operations");
     88      while(reader.IsStartElement())
     89        AddOperation((IOperation)PersistenceManager.Restore(reader, restoredObjects));
     90      reader.ReadEndElement();
    8191    }
    8292    #endregion

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

    r2 r121  
    9797      return node;
    9898    }
    99     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    100       base.Populate(node, restoredObjects);
    101       XmlNode constraintsNode = node.SelectSingleNode("Constraints");
    102       if (constraintsNode != null) {
     99    //public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
     100    //  base.Populate(node, restoredObjects);
     101    //  XmlNode constraintsNode = node.SelectSingleNode("Constraints");
     102    //  if(constraintsNode != null) {
     103    //    myConstraints.Clear();
     104    //    foreach(XmlNode constraintNode in constraintsNode.ChildNodes)
     105    //      AddConstraint((IConstraint)PersistenceManager.Restore(constraintNode, restoredObjects));
     106    //  }
     107    //}
     108    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     109      base.Populate(reader, restoredObjects);
     110      if(reader.IsStartElement()) {
     111        reader.ReadToDescendant("Constraints");
    103112        myConstraints.Clear();
    104         foreach (XmlNode constraintNode in constraintsNode.ChildNodes)
    105           AddConstraint((IConstraint)PersistenceManager.Restore(constraintNode, restoredObjects));
     113        while(reader.IsStartElement())
     114          AddConstraint((IConstraint)PersistenceManager.Restore(reader, restoredObjects));
     115        reader.ReadEndElement();
    106116      }
    107117    }

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

    r47 r121  
    190190      return node;
    191191    }
    192     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    193       base.Populate(node, restoredObjects);
    194       myOperatorGraph = (IOperatorGraph)PersistenceManager.Restore(node.SelectSingleNode("OperatorGraph"), restoredObjects);
    195       myGlobalScope = (IScope)PersistenceManager.Restore(node.SelectSingleNode("GlobalScope"), restoredObjects);
    196 
    197       XmlNode stackNode = node.SelectSingleNode("ExecutionStack");
    198       for (int i = stackNode.ChildNodes.Count - 1; i >= 0; i--)
    199         myExecutionStack.Push((IOperation)PersistenceManager.Restore(stackNode.ChildNodes[i], restoredObjects));
    200 
    201       XmlNode timeNode = node.SelectSingleNode("ExecutionTime");
    202       myExecutionTime = TimeSpan.Parse(timeNode.InnerText);
     192    public override void Populate(XmlReader reader, IDictionary<Guid,IStorable> restoredObjects) {
     193      base.Populate(reader, restoredObjects);
     194      myOperatorGraph = (IOperatorGraph)PersistenceManager.Restore(reader, "OperatorGraph", restoredObjects);
     195      myGlobalScope = (IScope)PersistenceManager.Restore(reader, "GlobalScope", restoredObjects);
     196
     197      reader.ReadStartElement("ExecutionStack");
     198      List<IOperation> operationList = new List<IOperation>();
     199      while(reader.IsStartElement()) {
     200        operationList.Insert(0, (IOperation)PersistenceManager.Restore(reader, restoredObjects));
     201      }
     202      foreach(IOperation op in operationList)
     203        myExecutionStack.Push(op);
     204      reader.ReadEndElement();
     205
     206      reader.ReadStartElement("ExecutionTime");
     207      myExecutionTime = TimeSpan.Parse(reader.ReadString());
     208      reader.ReadEndElement();
    203209    }
    204210    #endregion

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

    r2 r121  
    3333
    3434    XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects);
    35     void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects);
     35    void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects);
    3636  }
    3737}

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

    r76 r121  
    461461      return node;
    462462    }
    463     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    464       base.Populate(node, restoredObjects);
    465       myName = node.Attributes["Name"].Value;
    466       if (node.Attributes["Breakpoint"] != null)
    467         myBreakpoint = bool.Parse(node.Attributes["Breakpoint"].Value);
    468       XmlNode subOperatorsNode = node.SelectSingleNode("SubOperators");
    469       for (int i = 0; i < subOperatorsNode.ChildNodes.Count; i++)
    470         AddSubOperator((IOperator)PersistenceManager.Restore(subOperatorsNode.ChildNodes[i], restoredObjects));
    471       XmlNode infosNode = node.SelectSingleNode("VariableInfos");
     463    //public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
     464    //  base.Populate(node, restoredObjects);
     465    //  myName = node.Attributes["Name"].Value;
     466    //  if(node.Attributes["Breakpoint"] != null)
     467    //    myBreakpoint = bool.Parse(node.Attributes["Breakpoint"].Value);
     468    //  XmlNode subOperatorsNode = node.SelectSingleNode("SubOperators");
     469    //  for(int i = 0; i < subOperatorsNode.ChildNodes.Count; i++)
     470    //    AddSubOperator((IOperator)PersistenceManager.Restore(subOperatorsNode.ChildNodes[i], restoredObjects));
     471    //  XmlNode infosNode = node.SelectSingleNode("VariableInfos");
     472    //  myVariableInfos.Clear();
     473    //  foreach(XmlNode infoNode in infosNode.ChildNodes)
     474    //    AddVariableInfo((IVariableInfo)PersistenceManager.Restore(infoNode, restoredObjects));
     475    //  XmlNode variablesNode = node.SelectSingleNode("Variables");
     476    //  myVariables.Clear();
     477    //  foreach(XmlNode variableNode in variablesNode.ChildNodes)
     478    //    AddVariable((IVariable)PersistenceManager.Restore(variableNode, restoredObjects));
     479    //}
     480    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     481      base.Populate(reader, restoredObjects);
     482      myName = reader["Name"];
     483      if(reader["Breakpoint"] != null)
     484        myBreakpoint = bool.Parse(reader["Breakpoint"]);
     485      reader.ReadStartElement("SubOperators");
     486      while(reader.IsStartElement())
     487        AddSubOperator((IOperator)PersistenceManager.Restore(reader, restoredObjects));
     488      reader.ReadEndElement();
     489      reader.ReadStartElement("VariableInfos");
    472490      myVariableInfos.Clear();
    473       foreach (XmlNode infoNode in infosNode.ChildNodes)
    474         AddVariableInfo((IVariableInfo)PersistenceManager.Restore(infoNode, restoredObjects));
    475       XmlNode variablesNode = node.SelectSingleNode("Variables");
     491      while(reader.IsStartElement())
     492        AddVariableInfo((IVariableInfo)PersistenceManager.Restore(reader, restoredObjects));
     493      reader.ReadEndElement();
     494      reader.ReadStartElement("Variables");
    476495      myVariables.Clear();
    477       foreach (XmlNode variableNode in variablesNode.ChildNodes)
    478         AddVariable((IVariable)PersistenceManager.Restore(variableNode, restoredObjects));
     496      while(reader.IsStartElement())
     497        AddVariable((IVariable)PersistenceManager.Restore(reader, restoredObjects));
     498      reader.ReadEndElement();
    479499    }
    480500    #endregion

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

    r47 r121  
    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    }
    122122
    123123    #region Persistence Methods
    124     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid,IStorable> persistedObjects) {
     124    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
    125125      XmlNode node = base.GetXmlNode(name, document, persistedObjects);
    126126      XmlNode ops = document.CreateNode(XmlNodeType.Element, "Operators", null);
    127       foreach (IOperator op in myOperators.Values)
     127      foreach(IOperator op in myOperators.Values)
    128128        ops.AppendChild(PersistenceManager.Persist(op, document, persistedObjects));
    129129      node.AppendChild(ops);
    130       if (InitialOperator != null)
     130      if(InitialOperator != null)
    131131        node.AppendChild(PersistenceManager.Persist("InitialOperator", InitialOperator, document, persistedObjects));
    132132      return node;
    133133    }
    134     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    135       base.Populate(node, restoredObjects);
     134    //public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
     135    //  base.Populate(node, restoredObjects);
    136136
    137       XmlNode ops = node.SelectSingleNode("Operators");
    138       for (int i = 0; i < ops.ChildNodes.Count; i++) {
    139         XmlNode opNode = ops.ChildNodes[i];
    140         IOperator op = (IOperator)PersistenceManager.Restore(opNode, restoredObjects);
     137    //  XmlNode ops = node.SelectSingleNode("Operators");
     138    //  for(int i = 0; i < ops.ChildNodes.Count; i++) {
     139    //    XmlNode opNode = ops.ChildNodes[i];
     140    //    IOperator op = (IOperator)PersistenceManager.Restore(opNode, restoredObjects);
     141    //    myOperators.Add(op.Guid, op);
     142    //  }
     143
     144    //  XmlNode initial = node.SelectSingleNode("InitialOperator");
     145    //  if(initial != null)
     146    //    myInitialOperator = (IOperator)PersistenceManager.Restore(initial, restoredObjects);
     147    //}
     148    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     149      base.Populate(reader, restoredObjects);
     150
     151      reader.ReadToDescendant("Operators");
     152      while(reader.IsStartElement()) {
     153        IOperator op = (IOperator)PersistenceManager.Restore(reader, restoredObjects);
    141154        myOperators.Add(op.Guid, op);
    142155      }
    143 
    144       XmlNode initial = node.SelectSingleNode("InitialOperator");
    145       if (initial != null)
    146         myInitialOperator = (IOperator)PersistenceManager.Restore(initial, restoredObjects);
     156      reader.ReadEndElement();
     157      if(reader.IsStartElement()) {
     158        myInitialOperator = (IOperator)PersistenceManager.Restore(reader, "InitialOperator", restoredObjects);
     159      }
    147160    }
    148161    #endregion

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

    r2 r121  
    9898      return node;
    9999    }
    100     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    101       base.Populate(node, restoredObjects);
    102       myName = node.Attributes["Name"].Value;
    103       XmlNode subGroupsNode = node.SelectSingleNode("SubGroups");
    104       foreach (XmlNode subGroupNode in subGroupsNode.ChildNodes)
    105         AddSubGroup((IOperatorGroup)PersistenceManager.Restore(subGroupNode, restoredObjects));
    106       XmlNode operatorsNode = node.SelectSingleNode("Operators");
    107       foreach (XmlNode operatorNode in operatorsNode.ChildNodes)
    108         AddOperator((IOperator)PersistenceManager.Restore(operatorNode, restoredObjects));
     100    //public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
     101    //  base.Populate(node, restoredObjects);
     102    //  myName = node.Attributes["Name"].Value;
     103    //  XmlNode subGroupsNode = node.SelectSingleNode("SubGroups");
     104    //  foreach(XmlNode subGroupNode in subGroupsNode.ChildNodes)
     105    //    AddSubGroup((IOperatorGroup)PersistenceManager.Restore(subGroupNode, restoredObjects));
     106    //  XmlNode operatorsNode = node.SelectSingleNode("Operators");
     107    //  foreach(XmlNode operatorNode in operatorsNode.ChildNodes)
     108    //    AddOperator((IOperator)PersistenceManager.Restore(operatorNode, restoredObjects));
     109    //}
     110    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     111      base.Populate(reader, restoredObjects);
     112      myName = reader["Name"];
     113      reader.ReadStartElement("SubGroups");
     114      while(reader.IsStartElement())
     115        AddSubGroup((IOperatorGroup)PersistenceManager.Restore(reader, restoredObjects));
     116      reader.ReadEndElement();
     117      reader.ReadStartElement("Operators");
     118      while(reader.IsStartElement())
     119        AddOperator((IOperator)PersistenceManager.Restore(reader, restoredObjects));
     120      reader.ReadEndElement();
    109121    }
    110122    #endregion

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

    r2 r121  
    5656      return node;
    5757    }
    58     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    59       base.Populate(node, restoredObjects);
    60       myGroup = (IOperatorGroup)PersistenceManager.Restore(node.SelectSingleNode("OperatorGroup"), restoredObjects);
     58    public override void Populate(XmlReader reader, IDictionary<Guid,IStorable> restoredObjects) {
     59      base.Populate(reader, restoredObjects);
     60      myGroup = (IOperatorGroup)PersistenceManager.Restore(reader, "OperatorGroup", restoredObjects);
    6161    }
    6262    #endregion

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

    r40 r121  
    4949      }
    5050    }
    51     public static IStorable Restore(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    52       Guid guid = new Guid(node.Attributes["GUID"].Value);
    53       if (restoredObjects.ContainsKey(guid)) {
     51
     52    public static IStorable Restore(XmlReader reader, string elementName, IDictionary<Guid, IStorable> restoredObjects) {
     53      reader.ReadToDescendant(elementName);
     54      return RestoreElement(reader, restoredObjects);
     55    }
     56
     57    public static IStorable Restore(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     58      reader.Read();
     59      return RestoreElement(reader, restoredObjects);
     60    }
     61    private static IStorable RestoreElement(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     62      Guid guid = new Guid(reader["GUID"]);
     63      if(restoredObjects.ContainsKey(guid)) {
     64        reader.ReadEndElement();
    5465        return restoredObjects[guid];
    5566      } else {
    56         Type type = Type.GetType(node.Attributes["Type"].Value, true);
     67        Type type = Type.GetType(reader["Type"], true);
    5768        IStorable instance = (IStorable)Activator.CreateInstance(type);
    5869        restoredObjects.Add(guid, instance);
    59         instance.Populate(node, restoredObjects);
     70        instance.Populate(reader, restoredObjects);
     71        reader.ReadEndElement();
    6072        return instance;
    6173      }
    … …  
    7991    public static IStorable Load(Stream stream) {
    8092      XmlDocument doc = new XmlDocument();
    81       doc.Load(stream);
    82       return PersistenceManager.Restore(doc.ChildNodes[1], new Dictionary<Guid, IStorable>());
     93      XmlTextReader reader = new XmlTextReader(stream);
     94      reader.WhitespaceHandling = WhitespaceHandling.None;
     95      reader.MoveToContent(); // read "<?xml version="1.0"?/>
     96      return PersistenceManager.RestoreElement(reader, new Dictionary<Guid, IStorable>());
    8397    }
    8498

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

    r63 r121  
    290290      return node;
    291291    }
    292     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    293       base.Populate(node, restoredObjects);
    294       myName = node.Attributes["Name"].Value;
    295 
    296       XmlNode variables = node.SelectSingleNode("Variables");
    297       foreach (XmlNode variableNode in variables.ChildNodes) {
    298         IVariable variable = (IVariable)PersistenceManager.Restore(variableNode, restoredObjects);
     292    //public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
     293    //  base.Populate(node, restoredObjects);
     294    //  myName = node.Attributes["Name"].Value;
     295
     296    //  XmlNode variables = node.SelectSingleNode("Variables");
     297    //  foreach(XmlNode variableNode in variables.ChildNodes) {
     298    //    IVariable variable = (IVariable)PersistenceManager.Restore(variableNode, restoredObjects);
     299    //    AddVariable(variable);
     300    //  }
     301
     302    //  XmlNode aliases = node.SelectSingleNode("Aliases");
     303    //  if(aliases != null) {
     304    //    foreach(XmlNode aliasNode in aliases.ChildNodes)
     305    //      AddAlias(aliasNode.Attributes["Alias"].Value, aliasNode.Attributes["Name"].Value);
     306    //  }
     307
     308    //  XmlNode subScopes = node.SelectSingleNode("SubScopes");
     309    //  for(int i = 0; i < subScopes.ChildNodes.Count; i++) {
     310    //    IScope scope = (IScope)PersistenceManager.Restore(subScopes.ChildNodes[i], restoredObjects);
     311    //    AddSubScope(scope);
     312    //  }
     313    //}
     314    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     315      base.Populate(reader, restoredObjects);
     316      myName = reader["Name"];
     317
     318      reader.ReadStartElement("Variables");
     319      while(reader.IsStartElement()) {
     320        IVariable variable = (IVariable)PersistenceManager.Restore(reader, restoredObjects);
    299321        AddVariable(variable);
    300322      }
    301 
    302       XmlNode aliases = node.SelectSingleNode("Aliases");
    303       if (aliases != null) {
    304         foreach (XmlNode aliasNode in aliases.ChildNodes)
    305           AddAlias(aliasNode.Attributes["Alias"].Value, aliasNode.Attributes["Name"].Value);
    306       }
    307 
    308       XmlNode subScopes = node.SelectSingleNode("SubScopes");
    309       for (int i = 0; i < subScopes.ChildNodes.Count; i++) {
    310         IScope scope = (IScope)PersistenceManager.Restore(subScopes.ChildNodes[i], restoredObjects);
     323      reader.ReadEndElement();
     324
     325      if(reader.IsStartElement() && reader.Name=="Aliases") {
     326        reader.ReadStartElement("Aliases");
     327        while(reader.IsStartElement())
     328          AddAlias(reader["Alias"], reader["Name"]);
     329        reader.ReadEndElement();
     330      }
     331      reader.ReadStartElement("SubScopes");
     332      while(reader.IsStartElement()) {
     333        IScope scope = (IScope)PersistenceManager.Restore(reader, restoredObjects);
    311334        AddSubScope(scope);
    312335      }
     336      reader.ReadEndElement();
    313337    }
    314338    #endregion

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

    r40 r121  
    5555      return node;
    5656    }
    57     public virtual void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    58       myGuid = new Guid(node.Attributes["GUID"].Value);
     57    public virtual void Populate(XmlReader reader, IDictionary<Guid,IStorable> restoredObjects) {
     58      myGuid = new Guid(reader["GUID"]);
    5959    }
    6060  }

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

    r2 r121  
    109109      return node;
    110110    }
    111     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    112       myName = node.Attributes["Name"].Value;
    113       XmlNode valueNode = node.SelectSingleNode("Value");
    114       if (valueNode != null)
    115         myValue = (IItem)PersistenceManager.Restore(valueNode, restoredObjects);
     111    //public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
     112    //  myName = node.Attributes["Name"].Value;
     113    //  XmlNode valueNode = node.SelectSingleNode("Value");
     114    //  if(valueNode != null)
     115    //    myValue = (IItem)PersistenceManager.Restore(valueNode, restoredObjects);
     116    //}
     117    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     118      myName = reader["Name"];
     119      if(reader.IsStartElement())
     120        myValue = (IItem)PersistenceManager.Restore(reader, "Value", restoredObjects);
    116121    }
    117122    #endregion

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

    r40 r121  
    137137      return node;
    138138    }
    139     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
    140       myActualName = node.Attributes["ActualName"].Value;
    141       myFormalName = node.Attributes["FormalName"].Value;
    142       myDescription = node.Attributes["Description"].Value;
    143       myDataType = Type.GetType(node.Attributes["DataType"].Value, true);
    144       myKind = (VariableKind)Enum.Parse(typeof(VariableKind), node.Attributes["Kind"].Value);
    145       myLocal = bool.Parse(node.Attributes["Local"].Value);
     139    //public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
     140    //  myActualName = node.Attributes["ActualName"].Value;
     141    //  myFormalName = node.Attributes["FormalName"].Value;
     142    //  myDescription = node.Attributes["Description"].Value;
     143    //  myDataType = Type.GetType(node.Attributes["DataType"].Value, true);
     144    //  myKind = (VariableKind)Enum.Parse(typeof(VariableKind), node.Attributes["Kind"].Value);
     145    //  myLocal = bool.Parse(node.Attributes["Local"].Value);
     146    //}
     147    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     148      myActualName = reader["ActualName"];
     149      myFormalName = reader["FormalName"];
     150      myDescription = reader["Description"];
     151      myDataType = Type.GetType(reader["DataType"], true);
     152      myKind = (VariableKind)Enum.Parse(typeof(VariableKind), reader["Kind"]);
     153      myLocal = bool.Parse(reader["Local"]);
    146154    }
    147155    #endregion
Note: See TracChangeset for help on using the changeset viewer.