Free cookie consent management tool by TermsFeed Policy Generator

Changeset 122 for branches


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

bug fixes to make loading of OSGA-TSP work. Some non-working code remains

Location:
branches/XmlTextReaderBranch
Files:
31 edited

Legend:

Unmodified
Added
Removed

  • branches/XmlTextReaderBranch/HeuristicLab.Constraints/DoubleBoundedConstraint.cs

    r121 r122  
    182182    //}
    183183    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
    184       base.Populate(reader, restoredObjects);
    185184      lowerBound = double.Parse(reader["LowerBound"]);
    186185      if(reader["LowerBoundIncluded"] != null) {
    … …  
    206205        upperBoundEnabled = true;
    207206      }
     207      base.Populate(reader, restoredObjects);
    208208    }
    209209    #endregion

  • branches/XmlTextReaderBranch/HeuristicLab.Constraints/IntBoundedConstraint.cs

    r121 r122  
    177177    //}
    178178    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
    179       base.Populate(reader, restoredObjects);
    180179      lowerBound = int.Parse(reader["LowerBound"]);
    181180      if(reader["LowerBoundIncluded"] != null) {
    … …  
    201200        upperBoundEnabled = true;
    202201      }
     202      base.Populate(reader, restoredObjects);
    203203    }
    204204

  • branches/XmlTextReaderBranch/HeuristicLab.Constraints/ItemTypeConstraint.cs

    r121 r122  
    9292    //}
    9393    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     94      type = Type.GetType(reader["ItemType"]);
    9495      base.Populate(reader, restoredObjects);
    95       type = Type.GetType(reader["ItemType"]);
    9696    }
    9797    #endregion

  • branches/XmlTextReaderBranch/HeuristicLab.Constraints/NumberOfSubOperatorsConstraint.cs

    r121 r122  
    9494    //}
    9595    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
    96       base.Populate(reader, restoredObjects);
    9796      minOperators = (IntData)PersistenceManager.Restore(reader, "min", restoredObjects);
    9897      maxOperators = (IntData)PersistenceManager.Restore(reader, "max", restoredObjects);
     98      base.Populate(reader, restoredObjects);
    9999    }
    100100    #endregion persistence

  • branches/XmlTextReaderBranch/HeuristicLab.Constraints/SubOperatorsTypeConstraint.cs

    r121 r122  
    133133      subOperatorIndex = (IntData)PersistenceManager.Restore(reader, "SubOperatorIndex", restoredObjects);
    134134      subOperators = new List<IOperator>();
    135       reader.ReadStartElement("AllowedSubOperators");
     135      reader.ReadToDescendant("AllowedSubOperators");
    136136      while(reader.IsStartElement())
    137137        subOperators.Add((IOperator)PersistenceManager.Restore(reader, restoredObjects));

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

    r121 r122  
    6464    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
    6565      base.Populate(reader, restoredObjects);
     66      reader.Read();
    6667      myOperator = (IOperator)PersistenceManager.Restore(reader, "Operator", restoredObjects);
     68      reader.Skip();
    6769      myScope = (IScope)PersistenceManager.Restore(reader, "Scope", restoredObjects);
     70      reader.Read();
    6871    }
    6972    #endregion

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

    r121 r122  
    8181    //}
    8282    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     83      myExecuteInParallel = bool.Parse(reader["ExecuteInParallel"]);
    8384      base.Populate(reader, restoredObjects);
    8485
    85       myExecuteInParallel = bool.Parse(reader["ExecuteInParallel"]);
    86 
    87       reader.ReadStartElement("Operations");
     86      reader.ReadToDescendant("Operations");
    8887      while(reader.IsStartElement())
    8988        AddOperation((IOperation)PersistenceManager.Restore(reader, restoredObjects));

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

    r121 r122  
    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    }
    8787
    8888    #region Persistence Methods
    89     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid,IStorable> persistedObjects) {
     89    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
    9090      XmlNode node = base.GetXmlNode(name, document, persistedObjects);
    91       if (Constraints.Count > 0) {
     91      if(Constraints.Count > 0) {
    9292        XmlNode constraintsNode = document.CreateNode(XmlNodeType.Element, "Constraints", null);
    93         foreach (IConstraint constraint in Constraints)
     93        foreach(IConstraint constraint in Constraints)
    9494          constraintsNode.AppendChild(PersistenceManager.Persist(constraint, document, persistedObjects));
    9595        node.AppendChild(constraintsNode);
    … …  
    108108    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
    109109      base.Populate(reader, restoredObjects);
    110       if(reader.IsStartElement()) {
    111         reader.ReadToDescendant("Constraints");
     110      reader.Read();
     111      if(reader.Name == "Constraints") {
    112112        myConstraints.Clear();
    113113        while(reader.IsStartElement())

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

    r121 r122  
    192192    public override void Populate(XmlReader reader, IDictionary<Guid,IStorable> restoredObjects) {
    193193      base.Populate(reader, restoredObjects);
     194      reader.Read();
    194195      myOperatorGraph = (IOperatorGraph)PersistenceManager.Restore(reader, "OperatorGraph", restoredObjects);
     196      reader.Skip();
    195197      myGlobalScope = (IScope)PersistenceManager.Restore(reader, "GlobalScope", restoredObjects);
    196 
    197       reader.ReadStartElement("ExecutionStack");
     198      reader.Skip();
     199      if(reader.Name!="ExecutionStack") throw new XmlException("Expected \"ExecutionStack\", found: \""+reader.Name+"\"");
    198200      List<IOperation> operationList = new List<IOperation>();
    199       while(reader.IsStartElement()) {
    200         operationList.Insert(0, (IOperation)PersistenceManager.Restore(reader, restoredObjects));
     201      if(!reader.IsEmptyElement) {
     202        reader.Read();
     203        while(reader.IsStartElement()) {
     204          operationList.Insert(0, (IOperation)PersistenceManager.Restore(reader, restoredObjects));
     205          reader.Skip();
     206        }
     207        reader.ReadEndElement();
     208      } else {
     209        reader.Read();
    201210      }
    202211      foreach(IOperation op in operationList)
    203212        myExecutionStack.Push(op);
    204       reader.ReadEndElement();
    205 
    206       reader.ReadStartElement("ExecutionTime");
    207       myExecutionTime = TimeSpan.Parse(reader.ReadString());
    208       reader.ReadEndElement();
     213      myExecutionTime = TimeSpan.Parse(reader.ReadElementString("ExecutionTime"));
    209214    }
    210215    #endregion

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

    r121 r122  
    479479    //}
    480480    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
    481       base.Populate(reader, restoredObjects);
    482481      myName = reader["Name"];
    483482      if(reader["Breakpoint"] != null)
    484483        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");
     484
     485      base.Populate(reader, restoredObjects);
     486      // constraintItemBase already reads to the next subelement
     487      if(reader.Name != "SubOperators") throw new XmlException("Expected: \"SubOperators\" found: \"" + reader.Name+"\"");
     488      if(!reader.IsEmptyElement) {
     489        reader.Read();
     490        while(reader.IsStartElement()) {
     491          AddSubOperator((IOperator)PersistenceManager.Restore(reader, restoredObjects));
     492          reader.Skip();
     493        }
     494        reader.ReadEndElement();
     495      } else {
     496        reader.Read();
     497      }
     498      if(reader.Name != "VariableInfos") throw new XmlException("Expected: \"VariableInfos\" found: \"" + reader.Name+"\"");
    490499      myVariableInfos.Clear();
    491       while(reader.IsStartElement())
    492         AddVariableInfo((IVariableInfo)PersistenceManager.Restore(reader, restoredObjects));
    493       reader.ReadEndElement();
    494       reader.ReadStartElement("Variables");
     500      if(!reader.IsEmptyElement) {
     501        reader.Read();
     502        while(reader.IsStartElement()) {       
     503          AddVariableInfo((IVariableInfo)PersistenceManager.Restore(reader, restoredObjects));
     504          reader.Skip();
     505        }
     506        reader.ReadEndElement();
     507      } else {
     508        reader.Read();
     509      }
     510      if(reader.Name != "Variables") throw new XmlException("Expected: \"Variables\" found: \"" + reader.Name + "\"");
    495511      myVariables.Clear();
    496       while(reader.IsStartElement())
    497         AddVariable((IVariable)PersistenceManager.Restore(reader, restoredObjects));
    498       reader.ReadEndElement();
     512      if(!reader.IsEmptyElement) {
     513        reader.Read();
     514        while(reader.IsStartElement()) {
     515          AddVariable((IVariable)PersistenceManager.Restore(reader, restoredObjects));
     516          reader.Skip();
     517        }
     518        reader.ReadEndElement();
     519      } else {
     520        reader.Read();
     521      }
    499522    }
    500523    #endregion

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

    r121 r122  
    149149      base.Populate(reader, restoredObjects);
    150150
    151       reader.ReadToDescendant("Operators");
     151      reader.Read();
     152      if(reader.Name != "Operators") throw new XmlException("Expected: Operators found: " + reader.Name);
     153      reader.Read();
    152154      while(reader.IsStartElement()) {
    153155        IOperator op = (IOperator)PersistenceManager.Restore(reader, restoredObjects);
     156        reader.Skip();
    154157        myOperators.Add(op.Guid, op);
    155158      }

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

    r121 r122  
    109109    //}
    110110    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     111      myName = reader["Name"];
    111112      base.Populate(reader, restoredObjects);
    112       myName = reader["Name"];
    113       reader.ReadStartElement("SubGroups");
     113
     114      reader.ReadToDescendant("SubGroups");
    114115      while(reader.IsStartElement())
    115116        AddSubGroup((IOperatorGroup)PersistenceManager.Restore(reader, restoredObjects));
    116117      reader.ReadEndElement();
    117       reader.ReadStartElement("Operators");
     118      reader.ReadToDescendant("Operators");
    118119      while(reader.IsStartElement())
    119120        AddOperator((IOperator)PersistenceManager.Restore(reader, restoredObjects));

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

    r121 r122  
    5151
    5252    public static IStorable Restore(XmlReader reader, string elementName, IDictionary<Guid, IStorable> restoredObjects) {
    53       reader.ReadToDescendant(elementName);
    54       return RestoreElement(reader, restoredObjects);
     53      reader = reader.ReadSubtree();
     54      reader.Read();
     55      if(reader.Name != elementName) throw new XmlException("Expected: \"" + elementName + "\" found: \"" + reader.Name+"\"");
     56      IStorable result = RestoreElement(reader, restoredObjects);
     57      reader.Read();
     58      reader.Close();
     59      return result;
    5560    }
    5661
    5762    public static IStorable Restore(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     63      reader = reader.ReadSubtree();
    5864      reader.Read();
    59       return RestoreElement(reader, restoredObjects);
     65      IStorable result = RestoreElement(reader, restoredObjects);
     66      reader.Read();
     67      reader.Close();
     68      return result;
    6069    }
    6170    private static IStorable RestoreElement(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
    6271      Guid guid = new Guid(reader["GUID"]);
    63       if(restoredObjects.ContainsKey(guid)) {
    64         reader.ReadEndElement();
     72      if(restoredObjects.ContainsKey(guid)) {       
    6573        return restoredObjects[guid];
    6674      } else {
    … …  
    6977        restoredObjects.Add(guid, instance);
    7078        instance.Populate(reader, restoredObjects);
    71         reader.ReadEndElement();
    7279        return instance;
    7380      }
    … …  
    9097    }
    9198    public static IStorable Load(Stream stream) {
    92       XmlDocument doc = new XmlDocument();
    93       XmlTextReader reader = new XmlTextReader(stream);
    94       reader.WhitespaceHandling = WhitespaceHandling.None;
     99      XmlReaderSettings settings = new XmlReaderSettings();
     100      settings.IgnoreComments = true;
     101      settings.IgnoreWhitespace = true;
     102      XmlReader reader = XmlReader.Create(stream, settings);
    95103      reader.MoveToContent(); // read "<?xml version="1.0"?/>
    96104      return PersistenceManager.RestoreElement(reader, new Dictionary<Guid, IStorable>());

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

    r121 r122  
    313313    //}
    314314    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     315      myName = reader["Name"];
    315316      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);
    321         AddVariable(variable);
    322       }
    323       reader.ReadEndElement();
    324 
    325       if(reader.IsStartElement() && reader.Name=="Aliases") {
    326         reader.ReadStartElement("Aliases");
    327         while(reader.IsStartElement())
     317      reader.Read();
     318      if(reader.Name != "Variables") throw new XmlException("Expected: \"Variables\", found: \""+reader.Name+"\"");
     319      if(!reader.IsEmptyElement) {
     320        reader.Read();
     321        while(reader.IsStartElement()) {
     322          IVariable variable = (IVariable)PersistenceManager.Restore(reader, restoredObjects);
     323          reader.Skip();
     324          AddVariable(variable);
     325        }
     326        reader.ReadEndElement();
     327      } else {
     328        reader.Read();
     329      }
     330      if(reader.Name == "Aliases" && !reader.IsEmptyElement) {
     331        reader.Read();
     332        while(reader.IsStartElement()) {
    328333          AddAlias(reader["Alias"], reader["Name"]);
     334        }
    329335        reader.ReadEndElement();
    330       }
    331       reader.ReadStartElement("SubScopes");
    332       while(reader.IsStartElement()) {
    333         IScope scope = (IScope)PersistenceManager.Restore(reader, restoredObjects);
    334         AddSubScope(scope);
    335       }
    336       reader.ReadEndElement();
     336      } else {
     337        reader.Read();
     338      }
     339      if(reader.Name != "SubScopes") throw new XmlException("Expected: \"SubScopes\", found: \"" + reader.Name + "\"");
     340      if(!reader.IsEmptyElement) {
     341        reader.Read();
     342        while(reader.IsStartElement()) {
     343          IScope scope = (IScope)PersistenceManager.Restore(reader, restoredObjects);
     344          reader.Skip();
     345          AddSubScope(scope);
     346        }
     347        reader.ReadEndElement();
     348      } else {
     349        reader.Read();
     350      }
    337351    }
    338352    #endregion

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

    r121 r122  
    117117    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
    118118      myName = reader["Name"];
     119      reader.Read();
    119120      if(reader.IsStartElement())
    120121        myValue = (IItem)PersistenceManager.Restore(reader, "Value", restoredObjects);

  • branches/XmlTextReaderBranch/HeuristicLab.Data/ConstrainedItemList.cs

    r121 r122  
    7777    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
    7878      base.Populate(reader, restoredObjects);
    79       reader.ReadStartElement("ListItems");
     79      reader.Read();
     80      if(reader.Name!="ListItems") throw new XmlException("Expected: \"ListItems\", found: \""+reader.Name+"\"");
    8081      suspendConstraintCheck = bool.Parse(reader["SuspendConstraintCheck"]);
    8182      list = new List<IItem>();
    82       while(reader.IsStartElement())
    83         list.Add((IItem)PersistenceManager.Restore(reader, restoredObjects));
    84       reader.ReadEndElement();
     83      if(!reader.IsEmptyElement) {
     84        while(reader.IsStartElement()) {
     85          list.Add((IItem)PersistenceManager.Restore(reader, restoredObjects));
     86          reader.Skip();
     87        }
     88        reader.ReadEndElement();
     89      } else {
     90        reader.Read();
     91      }
    8592    }
    8693    #endregion

  • branches/XmlTextReaderBranch/HeuristicLab.Data/DoubleData.cs

    r121 r122  
    6969      base.Populate(reader, restoredObjects);
    7070      double data;
    71       if(double.TryParse(reader.ReadString(), NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out data) == true) {
     71      string token = reader.ReadString();
     72      if(double.TryParse(token, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out data) == true) {
    7273        Data = data;
    7374      } else {
    74         throw new FormatException("Can't parse " + reader.ReadString() + " as double value.");
     75        throw new FormatException("Can't parse " + token + " as double value.");
    7576      }
    7677    }

  • branches/XmlTextReaderBranch/HeuristicLab.Data/IntMatrixData.cs

    r121 r122  
    7474      int dim2 = int.Parse(reader["Dimension2"], CultureInfo.InvariantCulture.NumberFormat);
    7575      string[] tokens = reader.ReadString().Split(';');
     76
    7677      int[,] data = new int[dim1, dim2];
    7778      for(int i = 0; i < dim1; i++) {

  • branches/XmlTextReaderBranch/HeuristicLab.Data/ItemList_T.cs

    r121 r122  
    6363    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
    6464      base.Populate(reader, restoredObjects);
    65       while(reader.IsStartElement())
     65      reader.Read();
     66      while(reader.IsStartElement()) {
    6667        list.Add((T)PersistenceManager.Restore(reader, restoredObjects));
     68        reader.Skip();
     69      }
     70      reader.ReadEndElement();
    6771    }
    6872

  • branches/XmlTextReaderBranch/HeuristicLab.DataAnalysis/Dataset.cs

    r121 r122  
    166166      rows = int.Parse(reader["Dimension1"], CultureInfo.InvariantCulture.NumberFormat);
    167167      columns = int.Parse(reader["Dimension2"], CultureInfo.InvariantCulture.NumberFormat);
    168 
    169168      VariableNames = ParseVariableNamesString(reader["VariableNames"]);
    170 
    171169      string[] tokens = reader.ReadString().Split(';');
     170
    172171      if(tokens.Length != rows * columns) throw new FormatException();
    173172      samples = new double[rows * columns];

  • branches/XmlTextReaderBranch/HeuristicLab.DistributedEngine/DistributedEngine.cs

    r121 r122  
    193193    //}
    194194    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     195      ServerAddress = reader["ServerAddress"];
    195196      base.Populate(reader, restoredObjects);
    196       ServerAddress = reader["ServerAddress"];
    197197    }
    198198    #endregion

  • branches/XmlTextReaderBranch/HeuristicLab.ES/ES.cs

    r121 r122  
    612612    //}
    613613    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     614      myEngine = (IEngine)PersistenceManager.Restore(reader, "Engine", restoredObjects);
    614615      base.Populate(reader, restoredObjects);
    615       myEngine = (IEngine)PersistenceManager.Restore(reader, "Engine", restoredObjects);
    616616      SetReferences();
    617617    }

  • branches/XmlTextReaderBranch/HeuristicLab.Functions/FunctionBase.cs

    r121 r122  
    337337
    338338      // load local variables
    339       reader.ReadStartElement("LocalVariables");
     339      reader.ReadToDescendant("LocalVariables");
    340340      // remove the variables that have been added in a constructor
    341341      variables.Clear();

  • branches/XmlTextReaderBranch/HeuristicLab.Operators.Programmable/ProgrammableOperator.cs

    r121 r122  
    211211    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
    212212      base.Populate(reader, restoredObjects);
    213       reader.ReadStartElement("Description");
     213      reader.ReadToDescendant("Description");
    214214      myDescription = reader.ReadString();
    215215      reader.ReadEndElement();
    216       reader.ReadStartElement("Code");
     216      reader.ReadToDescendant("Code");
    217217      myCode = reader.ReadString();
    218218      reader.ReadEndElement();

  • branches/XmlTextReaderBranch/HeuristicLab.Operators/CombinedOperator.cs

    r121 r122  
    104104    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
    105105      base.Populate(reader, restoredObjects);
    106       if(reader.IsStartElement() && reader.Name == "Description") {
    107         reader.ReadStartElement("Description");
    108         myDescription = reader.ReadString();
    109         reader.ReadEndElement();
    110       }
     106      myDescription = reader.ReadElementString("Description");
    111107      myOperatorGraph = (IOperatorGraph)PersistenceManager.Restore(reader, "OperatorGraph", restoredObjects);
    112108    }

  • branches/XmlTextReaderBranch/HeuristicLab.Random/MersenneTwister.cs

    r121 r122  
    143143      base.Populate(reader, restoredObjects);
    144144
    145       reader.ReadStartElement("State");
     145      reader.ReadToDescendant("State");
    146146      string stateString = reader.ReadString();
    147147      reader.ReadEndElement();
    … …  
    149149      for(int i = 0; i < tokens.Length; i++)
    150150        state[i] = uint.Parse(tokens[i]);
    151       reader.ReadStartElement("P");
     151      reader.ReadToDescendant("P");
    152152      p = int.Parse(reader.ReadString());
    153153      reader.ReadEndElement();
    154       reader.ReadStartElement("Init");
     154      reader.ReadToDescendant("Init");
    155155      init = bool.Parse(reader.ReadString());
    156156      reader.ReadEndElement();

  • branches/XmlTextReaderBranch/HeuristicLab.Random/NormalDistributedRandom.cs

    r121 r122  
    538538    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
    539539      base.Populate(reader, restoredObjects);
    540       reader.ReadStartElement("Mu");
     540      reader.ReadToDescendant("Mu");
    541541      mu = double.Parse(reader.ReadString());
    542542      reader.ReadEndElement();
    543       reader.ReadStartElement("Sigma");
     543      reader.ReadToDescendant("Sigma");
    544544      sigma = double.Parse(reader.ReadString());
    545545      reader.ReadEndElement();

  • branches/XmlTextReaderBranch/HeuristicLab.Scheduling.JSSP/Schedule.cs

    r121 r122  
    8686    //}
    8787    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     88      int machines = int.Parse(reader["Machines"]);
    8889      base.Populate(reader, restoredObjects);
    89       int machines = int.Parse(reader["Machines"]);
    9090      schedule = new ScheduleTree[machines];
    9191      for(int i = 0; i < machines; i++) {

  • branches/XmlTextReaderBranch/HeuristicLab.Scheduling.JSSP/ScheduleTree.cs

    r121 r122  
    225225    //}
    226226    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     227      string[] tokens = reader.ReadString().Split(';');
    227228      base.Populate(reader, restoredObjects);
    228       string[] tokens = reader.ReadString().Split(';');
    229229      for(int i = 0; i < tokens.Length - 1; i++) {
    230230        TimeSlot t = new TimeSlot(tokens[i]);

  • branches/XmlTextReaderBranch/HeuristicLab.ThreadParallelEngine/ThreadParallelEngine.cs

    r121 r122  
    188188    //}
    189189    public override void Populate(XmlReader reader, IDictionary<Guid, IStorable> restoredObjects) {
     190      myWorkers = int.Parse(reader["Workers"]);
    190191      base.Populate(reader, restoredObjects);
    191       myWorkers = int.Parse(reader["Workers"]);
    192192    }
    193193    #endregion

  • branches/XmlTextReaderBranch/HeuristicLab/UpdateLocalInstallation.cmd

    r45 r122  
    1 set target=C:\Program Files\HeuristicLab 3.0
     1set target=G:\Program Files\HeuristicLab 3.0
    22
    33copy "HeuristicLab.exe" "%target%"
Note: See TracChangeset for help on using the changeset viewer.