Changeset 16573


Ignore:
Timestamp:
01/28/19 18:10:11 (3 weeks ago)
Author:
gkronber
Message:

#2520: changed HeuristicLab.FLA addon to compile with new HL.Persistence

Location:
addons/HeuristicLab.FitnessLandscapeAnalysis
Files:
1 added
72 edited

Legend:

Unmodified
Added
Removed
  • addons/HeuristicLab.FitnessLandscapeAnalysis

    • Property svn:ignore
      •  

        old new  
        33*.user
        44*.suo
         5packages
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape.Views/HeuristicLab.Analysis.FitnessLandscape.Views.csproj

    r15691 r16573  
    11<?xml version="1.0" encoding="utf-8"?>
    2 <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
     2<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    33  <PropertyGroup>
    44    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     
    1111    <RootNamespace>HeuristicLab.Analysis.FitnessLandscape.Views</RootNamespace>
    1212    <AssemblyName>HeuristicLab.Analysis.FitnessLandscape.Views-3.3</AssemblyName>
    13     <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
     13    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
    1414    <FileAlignment>512</FileAlignment>
    1515    <TargetFrameworkProfile />
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Algorithms/EvolvabilityAnalyzer.cs

    r7128 r16573  
    1010using HeuristicLab.Parameters;
    1111using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     12using HEAL.Attic;
    1213
    1314namespace HeuristicLab.Analysis.FitnessLandscape.Algorithms {
    1415
    1516  [Item("EvolvabilityAnalyzer", "Analyzes and consolidates repeated (very short) trails to evolvability metrics.")]
    16   [StorableClass]
     17  [StorableType("446A5494-B5EE-4C52-B6AE-B1B37E3E5E4D")]
    1718  public class EvolvabilityAnalyzer : SingleSuccessorOperator, IRepeatsAnalyzer {
    1819
     
    4950    #region Construction & Cloning
    5051    [StorableConstructor]
    51     protected EvolvabilityAnalyzer(bool deserializing) : base(deserializing) { }
     52    protected EvolvabilityAnalyzer(StorableConstructorFlag _) : base(_) { }
    5253    protected EvolvabilityAnalyzer(EvolvabilityAnalyzer original, Cloner cloner) : base(original, cloner) { }
    5354    public EvolvabilityAnalyzer() {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Algorithms/LocalAnalysis.cs

    r8172 r16573  
    3131using HeuristicLab.PluginInfrastructure;
    3232using HeuristicLab.Random;
     33using HEAL.Attic;
    3334
    3435namespace HeuristicLab.Analysis.FitnessLandscape {
    3536  [Item("Local Analysis", "A local analysis algorithm.")]
    3637  [Creatable("Algorithms")]
    37   [StorableClass]
     38  [StorableType("533E9F86-9195-4C03-972A-B8C49E1C15BD")]
    3839  public sealed class LocalAnalysis : HeuristicOptimizationEngineAlgorithm, IStorableContent {
    3940    public string Filename { get; set; }
     
    9091
    9192    [StorableConstructor]
    92     private LocalAnalysis(bool deserializing) : base(deserializing) { }
     93    private LocalAnalysis(StorableConstructorFlag _) : base(_) { }
    9394    private LocalAnalysis(LocalAnalysis original, Cloner cloner)
    9495      : base(original, cloner) {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Algorithms/LocalAnalysisMainLoop.cs

    r7128 r16573  
    2929using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    3030using HeuristicLab.Selection;
     31using HEAL.Attic;
    3132
    3233namespace HeuristicLab.Analysis.FitnessLandscape {
     
    3536  /// </summary>
    3637  [Item("LocalAnalysisMainLoop", "An operator which represents the main loop of a best improvement local search (if only a single move is generated in each iteration it is a first improvement local search).")]
    37   [StorableClass]
     38  [StorableType("D1B3518C-6A0A-4123-893E-0D4C89DA056C")]
    3839  public class LocalAnalysisMainLoop : AlgorithmOperator {
    3940
     
    7273
    7374    [StorableConstructor]
    74     protected LocalAnalysisMainLoop(bool deserializing) : base(deserializing) { }
     75    protected LocalAnalysisMainLoop(StorableConstructorFlag _) : base(_) { }
    7576    protected LocalAnalysisMainLoop(LocalAnalysisMainLoop original, Cloner cloner) : base(original, cloner) { }
    7677    public LocalAnalysisMainLoop()
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Algorithms/RepeatMultiAnalyzer.cs

    r10299 r16573  
    2828using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2929using HeuristicLab.PluginInfrastructure;
     30using HEAL.Attic;
     31
    3032namespace HeuristicLab.Analysis.FitnessLandscape {
    3133
    3234  [Item("RepeatMultiAnalyzer", "A collection of analyzers for consolidating repeats.")]
    33   [StorableClass]
     35  [StorableType("D65FCC67-534C-4C05-85DE-1D837D0D8F11")]
    3436  public class RepeatMultiAnalyzer : CheckedMultiOperator<IRepeatsAnalyzer>, IAnalyzer {
    3537    public bool EnabledByDefault {
     
    4244
    4345    [StorableConstructor]
    44     protected RepeatMultiAnalyzer(bool deserializing) : base(deserializing) { }
     46    protected RepeatMultiAnalyzer(StorableConstructorFlag _) : base(_) { }
    4547    protected RepeatMultiAnalyzer(RepeatMultiAnalyzer original, Cloner cloner) : base(original, cloner) { }
    4648
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Algorithms/RepeatedInformationAnalyzer.cs

    r7128 r16573  
    1010using HeuristicLab.Parameters;
    1111using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     12using HEAL.Attic;
    1213
    1314namespace HeuristicLab.Analysis.FitnessLandscape.Algorithms {
    1415
    1516  [Item("RepeatedInformationAnalyzer", "Analyzes and consolidates repeated information analyses.")]
    16   [StorableClass]
     17  [StorableType("A53A3F9B-BC38-47E9-B435-42DEA10A4ABC")]
    1718  public class RepeatedInformationAnalyzer : SingleSuccessorOperator, IRepeatsAnalyzer {
    1819
     
    4445    #region Construction & Cloning
    4546    [StorableConstructor]
    46     protected RepeatedInformationAnalyzer(bool deserializing) : base(deserializing) { }
     47    protected RepeatedInformationAnalyzer(StorableConstructorFlag _) : base(_) { }
    4748    protected RepeatedInformationAnalyzer(RepeatedInformationAnalyzer original, Cloner cloner) : base(original, cloner) { }
    4849    public RepeatedInformationAnalyzer() {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Algorithms/RepeatedLocalAnalysis.cs

    r8172 r16573  
    3333using HeuristicLab.PluginInfrastructure;
    3434using HeuristicLab.Random;
     35using HEAL.Attic;
    3536
    3637namespace HeuristicLab.Analysis.FitnessLandscape {
    3738  [Item("Repeated Local Analysis", "A local analysis algorithm restarted several times.")]
    3839  [Creatable("Algorithms")]
    39   [StorableClass]
     40  [StorableType("F70D7A4D-821A-4D2F-9A15-C18628D2060F")]
    4041  public sealed class RepeatedLocalAnalysis : HeuristicOptimizationEngineAlgorithm, IStorableContent {
    4142    public string Filename { get; set; }
     
    107108
    108109    [StorableConstructor]
    109     private RepeatedLocalAnalysis(bool deserializing) : base(deserializing) { }
     110    private RepeatedLocalAnalysis(StorableConstructorFlag _) : base(_) { }
    110111    private RepeatedLocalAnalysis(RepeatedLocalAnalysis original, Cloner cloner)
    111112      : base(original, cloner) {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Algorithms/RepeatedRuggednessAnalyzer.cs

    r7128 r16573  
    99using HeuristicLab.Parameters;
    1010using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     11using HEAL.Attic;
    1112
    1213namespace HeuristicLab.Analysis.FitnessLandscape.Algorithms {
     
    1415
    1516  [Item("RepeatedRuggednessAnalyzer", "Analyzes and consolidates repeated ruggedness analyses.")]
    16   [StorableClass]
     17  [StorableType("CB5A6876-CC84-4D00-9E1C-65A537A3EC92")]
    1718  public class RepeatedRuggednessAnalyzer : SingleSuccessorOperator, IRepeatsAnalyzer {
    1819
     
    6162    #region Construction & Cloning
    6263    [StorableConstructor]
    63     protected RepeatedRuggednessAnalyzer(bool deserializing) : base(deserializing) { }
     64    protected RepeatedRuggednessAnalyzer(StorableConstructorFlag _) : base(_) { }
    6465    protected RepeatedRuggednessAnalyzer(RepeatedRuggednessAnalyzer original, Cloner cloner) : base(original, cloner) { }
    6566    public RepeatedRuggednessAnalyzer() {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Algorithms/RepeatedUpDownWalkAnalyzer.cs

    r9143 r16573  
    99using HeuristicLab.Parameters;
    1010using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     11using HEAL.Attic;
    1112
    1213namespace HeuristicLab.Analysis.FitnessLandscape.Algorithms {
    1314
    1415  [Item("RepeatedUpDownWalkAnalyzer", "Analyzes and consolidates repeated up down walk analyses.")]
    15   [StorableClass]
     16  [StorableType("1B832D9F-7D75-41AB-94D1-D638F4067CC0")]
    1617  public class RepeatedUpDownWalkAnalyzer : SingleSuccessorOperator, IRepeatsAnalyzer {
    1718
     
    4849    #region Construction & Cloning
    4950    [StorableConstructor]
    50     protected RepeatedUpDownWalkAnalyzer(bool deserializing) : base(deserializing) { }
     51    protected RepeatedUpDownWalkAnalyzer(StorableConstructorFlag _) : base(_) { }
    5152    protected RepeatedUpDownWalkAnalyzer(RepeatedUpDownWalkAnalyzer original, Cloner cloner) : base(original, cloner) { }
    5253    public RepeatedUpDownWalkAnalyzer() {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Algorithms/ScopeDuplicator.cs

    r7128 r16573  
    66using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    77using HeuristicLab.Optimization;
     8using HEAL.Attic;
    89
    910namespace HeuristicLab.Analysis.FitnessLandscape.Algorithms {
    1011
    1112  [Item("ScopeDuplicator", "Places clones of the first sub-scope as sub-scopes into n newly created scopes.")]
    12   [StorableClass]
     13  [StorableType("99032F61-ACCD-4312-8602-71C7D8787391")]
    1314  public class ScopeDuplicator : SingleSuccessorOperator {
    1415
     
    2728    #region Construction & Cloning
    2829    [StorableConstructor]
    29     protected ScopeDuplicator(bool deserializing) : base(deserializing) { }
     30    protected ScopeDuplicator(StorableConstructorFlag _) : base(_) { }
    3031    protected ScopeDuplicator(ScopeDuplicator original, Cloner cloner) : base(original, cloner) { }
    3132    public ScopeDuplicator()
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/Aggregators/Aggregator.cs

    r7202 r16573  
    77using HeuristicLab.Optimization;
    88using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     9using HEAL.Attic;
    910
    1011namespace HeuristicLab.Analysis.FitnessLandscape {
    1112
    1213  [Item("Aggregator", "Base class of aggreagtors that aggregate results collected from several trajectories.")]
    13   [StorableClass]
     14  [StorableType("9C6131AD-6544-4792-9223-9DABA3E52074")]
    1415  public abstract class Aggregator<T> : NamedItem, IAggregator where T : class, IItem {
    1516
     
    2021
    2122    [StorableConstructor]
    22     protected Aggregator(bool deserializing) : base(deserializing) { }
     23    protected Aggregator(StorableConstructorFlag _) : base(_) { }
    2324    protected Aggregator(Aggregator<T> original, Cloner cloner)
    2425      : base(original, cloner) {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/Aggregators/AutoCorrelationAggregator.cs

    r7128 r16573  
    1212using System.Drawing;
    1313using HeuristicLab.Analysis.FitnessLandscape.Analysis;
     14using HEAL.Attic;
    1415
    1516namespace HeuristicLab.Analysis.FitnessLandscape {
    1617
    1718  [Item("Auto Correlation Aggregator", "Aggregates auto correlation analyses.")]
    18   [StorableClass]
     19  [StorableType("969A27FA-5E06-4945-BCA2-87FD869F02A4")]
    1920  public class AutoCorrelationAggregator : Aggregator<AutoCorrelationTable> {
    2021
    2122    [StorableConstructor]
    22     protected AutoCorrelationAggregator(bool deserializing) : base(deserializing) { }
     23    protected AutoCorrelationAggregator(StorableConstructorFlag _) : base(_) { }
    2324    protected AutoCorrelationAggregator(AutoCorrelationAggregator original, Cloner cloner) : base(original, cloner) { }
    2425    public AutoCorrelationAggregator() { }
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/Aggregators/BoundingBoxAggregator.cs

    r7128 r16573  
    66using HeuristicLab.Optimization;
    77using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     8using HEAL.Attic;
    89
    910namespace HeuristicLab.Analysis.FitnessLandscape {
    1011
    1112  [Item("BoundingBox Aggregator", "Aggregates bounding boxes")]
    12   [StorableClass]
     13  [StorableType("E6E3FEEA-AEA5-4B6B-87CF-A0AFEF26D9FD")]
    1314  public class BoundingBoxAggregator : Aggregator<DoubleMatrix> {
    1415
    1516    [StorableConstructor]
    16     protected BoundingBoxAggregator(bool deserializing) : base(deserializing) { }
     17    protected BoundingBoxAggregator(StorableConstructorFlag _) : base(_) { }
    1718    protected BoundingBoxAggregator(BoundingBoxAggregator original, Cloner cloner) : base(original, cloner) { }
    1819    public BoundingBoxAggregator() { }
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/Aggregators/EvolvabilityAggregator.cs

    r7202 r16573  
    99using HeuristicLab.Data;
    1010using HeuristicLab.Common.Resources;
     11using HEAL.Attic;
    1112
    1213namespace HeuristicLab.Analysis.FitnessLandscape {
    1314
    1415  [Item("Evolvability Aggregator", "Aggregates evolvability values into an evolvability portrait.")]
    15   [StorableClass]
     16  [StorableType("B1471271-C89E-47A9-A0A1-4F0D64468F39")]
    1617  public class EvolvabilityAggregator : NamedItem, IAggregator {
    1718
     
    4041    #region Construction and Cloning
    4142    [StorableConstructor]
    42     protected EvolvabilityAggregator(bool deserializing) : base(deserializing) { }
     43    protected EvolvabilityAggregator(StorableConstructorFlag _) : base(_) { }
    4344    protected EvolvabilityAggregator(EvolvabilityAggregator original, Cloner cloner)
    4445      : base(original, cloner) {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/Aggregators/InformationAnalysisAggregator.cs

    r7128 r16573  
    88using HeuristicLab.Optimization;
    99using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     10using HEAL.Attic;
    1011
    1112namespace HeuristicLab.Analysis.FitnessLandscape {
    1213
    1314  [Item("InformationAnalysis Aggregator", "Aggregates information anlyses.")]
    14   [StorableClass]
     15  [StorableType("30A0DDD6-CF94-4061-95C2-5717617EB7C1")]
    1516  public class InformationAnalysisAggregator : Aggregator<InformationAnalysisTable> {
    1617
    1718    [StorableConstructor]
    18     protected InformationAnalysisAggregator(bool deserializing) : base(deserializing) { }
     19    protected InformationAnalysisAggregator(StorableConstructorFlag _) : base(_) { }
    1920    protected InformationAnalysisAggregator(InformationAnalysisAggregator original, Cloner cloner) : base(original, cloner) { }
    2021    public InformationAnalysisAggregator() { }
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/Aggregators/InformationAnalysisPeakAggregator.cs

    r7128 r16573  
    99using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    1010using HeuristicLab.Data;
     11using HEAL.Attic;
    1112
    1213namespace HeuristicLab.Analysis.FitnessLandscape {
    1314
    1415  [Item("InformationAnalysis Peak Aggregator", "Aggregates peak information anlyses.")]
    15   [StorableClass]
     16  [StorableType("BDB8568B-EBF5-437C-81C2-C68F77C3FCEF")]
    1617  public class InformationAnalysisPeakAggregator : Aggregator<InformationAnalysisTable> {
    1718
    1819    [StorableConstructor]
    19     protected InformationAnalysisPeakAggregator(bool deserializing) : base(deserializing) { }
     20    protected InformationAnalysisPeakAggregator(StorableConstructorFlag _) : base(_) { }
    2021    protected InformationAnalysisPeakAggregator(InformationAnalysisPeakAggregator original, Cloner cloner) : base(original, cloner) { }
    2122    public InformationAnalysisPeakAggregator() { }
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/Aggregators/InformationAnalysisValueAggregator.cs

    r7202 r16573  
    1010using HeuristicLab.Data;
    1111using HeuristicLab.Common.Resources;
     12using HEAL.Attic;
    1213
    1314namespace HeuristicLab.Analysis.FitnessLandscape {
    1415
    1516  [Item("InformationAnalysisValue Aggregator", "Aggregates information anlysis values.")]
    16   [StorableClass]
     17  [StorableType("829CDE87-6290-42AE-93EF-5095B52AD6FF")]
    1718  public class InformationAnalysisValueAggregator : NamedItem, IAggregator {
    1819
     
    3536    #region Construction and Cloning
    3637    [StorableConstructor]
    37     protected InformationAnalysisValueAggregator(bool deserializing) : base(deserializing) { }
     38    protected InformationAnalysisValueAggregator(StorableConstructorFlag _) : base(_) { }
    3839    protected InformationAnalysisValueAggregator(InformationAnalysisValueAggregator original, Cloner cloner)
    3940      : base(original, cloner) {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/Aggregators/InformationStabilityAggregator.cs

    r7128 r16573  
    1212using System.Drawing;
    1313using HeuristicLab.Analysis.FitnessLandscape.Analysis;
     14using HEAL.Attic;
    1415
    1516namespace HeuristicLab.Analysis.FitnessLandscape {
    1617
    1718  [Item("Information Stability Aggregator", "Aggregates information stability analyses.")]
    18   [StorableClass]
     19  [StorableType("0E2319B7-EB74-4363-A89F-26A3517CB7F7")]
    1920  public class InformationStabilityAggregator : Aggregator<InformationStabilityTable> {
    2021
    2122    [StorableConstructor]
    22     protected InformationStabilityAggregator(bool deserializing) : base(deserializing) { }
     23    protected InformationStabilityAggregator(StorableConstructorFlag _) : base(_) { }
    2324    protected InformationStabilityAggregator(InformationStabilityAggregator original, Cloner cloner) : base(original, cloner) { }
    2425    public InformationStabilityAggregator() { }
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/Aggregators/QualityTrailSummaryAggregator.cs

    r7128 r16573  
    55using HeuristicLab.Optimization;
    66using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     7using HEAL.Attic;
    78
    89namespace HeuristicLab.Analysis.FitnessLandscape {
    910
    1011  [Item("QualityTrailSummary Aggregator", "Aggregates quality trail summaries.")]
    11   [StorableClass]
     12  [StorableType("B07DD0C5-AAA2-46C4-8BF2-64EB07951985")]
    1213  public class QualityTrailSummaryAggregator : Aggregator<QualityTrailSummaryTable> {
    1314
    1415    [StorableConstructor]
    15     protected QualityTrailSummaryAggregator(bool deserializing) : base(deserializing) { }
     16    protected QualityTrailSummaryAggregator(StorableConstructorFlag _) : base(_) { }
    1617    protected QualityTrailSummaryAggregator(QualityTrailSummaryAggregator original, Cloner cloner) : base(original, cloner) { }
    1718    public QualityTrailSummaryAggregator() { }
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/Aggregators/RuggednessAggregator.cs

    r7202 r16573  
    1212using System.Drawing;
    1313using HeuristicLab.Analysis.FitnessLandscape.Analysis;
     14using HEAL.Attic;
    1415
    1516namespace HeuristicLab.Analysis.FitnessLandscape {
    1617
    1718  [Item("Ruggedness Aggregator", "Aggregates scalar ruggedness analyses.")]
    18   [StorableClass]
     19  [StorableType("03C63217-F50F-4111-B978-DF83ADC5DDBE")]
    1920  public class RuggednessAggregator : NamedItem, IAggregator {
    2021
     
    2728    #region Construction & Cloning
    2829    [StorableConstructor]
    29     protected RuggednessAggregator(bool deserializing) : base(deserializing) { }
     30    protected RuggednessAggregator(StorableConstructorFlag _) : base(_) { }
    3031    protected RuggednessAggregator(RuggednessAggregator original, Cloner cloner) : base(original, cloner) {
    3132      autocorrelations = original.autocorrelations.ToList();
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/Aggregators/UpDownAggregatorAggregator.cs

    r9143 r16573  
    1212using System.Drawing;
    1313using HeuristicLab.Analysis.FitnessLandscape.Analysis;
     14using HEAL.Attic;
    1415
    1516namespace HeuristicLab.Analysis.FitnessLandscape {
    1617
    1718  [Item("Up Down Aggregator", "Aggregates scalar up down analyses.")]
    18   [StorableClass]
     19  [StorableType("597E3537-ADE8-4B7A-A34B-AD6AF105493F")]
    1920  public class UpDownAggregator : NamedItem, IAggregator {
    2021
     
    3334    #region Construction & Cloning
    3435    [StorableConstructor]
    35     protected UpDownAggregator(bool deserializing) : base(deserializing) { }
     36    protected UpDownAggregator(StorableConstructorFlag _) : base(_) { }
    3637    protected UpDownAggregator(UpDownAggregator original, Cloner cloner) : base(original, cloner) {
    3738      downWalkLengths = original.downWalkLengths.ToList();
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/FitnessCloudAnalyzer.cs

    r7176 r16573  
    2727using HeuristicLab.Parameters;
    2828using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     29using HEAL.Attic;
    2930
    3031namespace HeuristicLab.Analysis.FitnessLandscape.Analysis {
    3132
    32   [StorableClass]
     33  [StorableType("4156976F-4E61-48BA-B598-FEA872F2E948")]
    3334  public class FitnessCloudAnalyzer : AlgorithmOperator, IQualityTrailAnalyzer {
    3435    public bool EnabledByDefault {
     
    4950
    5051    [StorableConstructor]
    51     protected FitnessCloudAnalyzer(bool deserializing) : base(deserializing) { }
     52    protected FitnessCloudAnalyzer(StorableConstructorFlag _) : base(_) { }
    5253    protected FitnessCloudAnalyzer(FitnessCloudAnalyzer original, Cloner cloner) : base(original, cloner) { }
    5354
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/InformationAnalysisCalculator.cs

    r8744 r16573  
    66using HeuristicLab.Parameters;
    77using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     8using HEAL.Attic;
    89
    910namespace HeuristicLab.Analysis.FitnessLandscape.Analysis {
    1011  [Item("InformationAnalysisCalculator", "Performs an information analysis on a quality trail as described in Vassilev et al. (2000) Evol Comput 8:31–60")]
    11   [StorableClass]
     12  [StorableType("20A6AC5F-6CD1-46B5-B025-0F8C58685918")]
    1213  public class InformationAnalysisCalculator : SingleSuccessorOperator {
    1314
     
    5051    #region Constructors & Cloning
    5152    [StorableConstructor]
    52     protected InformationAnalysisCalculator(bool deserializing) : base(deserializing) { }
     53    protected InformationAnalysisCalculator(StorableConstructorFlag _) : base(_) { }
    5354    public InformationAnalysisCalculator() {
    5455      Parameters.Add(new LookupParameter<DataTable>("QualityTrail", "Historical quality trail of a walk over a fitness landscape."));
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/InformationAnalyzer.cs

    r9142 r16573  
    3030using HeuristicLab.Parameters;
    3131using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     32using HEAL.Attic;
    3233
    3334namespace HeuristicLab.Analysis.FitnessLandscape.Analysis {
    3435
    35   [StorableClass]
     36  [StorableType("57803A7A-E1A7-4AD8-9F32-D97F5983ACBD")]
    3637  public class InformationAnalyzer : AlgorithmOperator, IQualityTrailAnalyzer {
    3738    public bool EnabledByDefault {
     
    119120
    120121    [StorableConstructor]
    121     protected InformationAnalyzer(bool deserializing) : base(deserializing) { }
     122    protected InformationAnalyzer(StorableConstructorFlag _) : base(_) { }
    122123    protected InformationAnalyzer(InformationAnalyzer original, Cloner cloner) : base(original, cloner) { }
    123124
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/NeutralityAnalyzer.cs

    r7783 r16573  
    3131using HeuristicLab.Optimization;
    3232using System.Collections.Generic;
     33using HEAL.Attic;
    3334
    3435namespace HeuristicLab.Analysis.FitnessLandscape.Analysis {
    3536
    3637  [Item("Neutrality Analzyer", "Analyzes neutral parts of a trajectory")]
    37   [StorableClass]
     38  [StorableType("FA1F7D1C-4567-49F2-A977-07AA50A11F50")]
    3839  public class NeutralityAnalyzer : AlgorithmOperator, IAnalyzer {
    3940    public bool EnabledByDefault {
     
    8485
    8586    [StorableConstructor]
    86     protected NeutralityAnalyzer(bool deserializing) : base(deserializing) { }
     87    protected NeutralityAnalyzer(StorableConstructorFlag _) : base(_) { }
    8788    protected NeutralityAnalyzer(NeutralityAnalyzer original, Cloner cloner) : base(original, cloner) { }
    8889
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/QualityTrailMultiAnalyzer.cs

    r10299 r16573  
    3131using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    3232using HeuristicLab.PluginInfrastructure;
     33using HEAL.Attic;
     34
    3335namespace HeuristicLab.Analysis.FitnessLandscape {
    3436
    3537  [Item("QualityTrailAnalyzer", "An analyzer that creates a quality trail which can be further analyzed by several analyzers.")]
    36   [StorableClass]
     38  [StorableType("E02FC8FB-85AD-42AB-8E14-EA509579C8BE")]
    3739  public class QualityTrailMultiAnalyzer : CheckedMultiOperator<IQualityTrailAnalyzer>, IAnalyzer {
    3840    public bool EnabledByDefault {
     
    7577
    7678    [StorableConstructor]
    77     protected QualityTrailMultiAnalyzer(bool deserializing) : base(deserializing) { }
     79    protected QualityTrailMultiAnalyzer(StorableConstructorFlag _) : base(_) { }
    7880    protected QualityTrailMultiAnalyzer(QualityTrailMultiAnalyzer original, Cloner cloner) : base(original, cloner) { }
    7981
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/QualityTrailSummarizer.cs

    r7176 r16573  
    3030using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    3131using System;
     32using HEAL.Attic;
    3233
    3334namespace HeuristicLab.Analysis.FitnessLandscape.Analysis {
    3435
    35   [StorableClass]
     36  [StorableType("78C1D578-7752-45B4-9174-DF30D38A7E8A")]
    3637  public class QualityTrailSummarizer : AlgorithmOperator, IQualityTrailAnalyzer {
    3738    public bool EnabledByDefault {
     
    5354    #region Construction & Cloning
    5455    [StorableConstructor]
    55     protected QualityTrailSummarizer(bool deserializing) : base(deserializing) { }
     56    protected QualityTrailSummarizer(StorableConstructorFlag _) : base(_) { }
    5657    protected QualityTrailSummarizer(QualityTrailSummarizer original, Cloner cloner) : base(original, cloner) { }
    5758
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/RealVectorBoundingBoxUpdater.cs

    r7128 r16573  
    1010using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    1111using HeuristicLab.Common;
     12using HEAL.Attic;
    1213
    1314namespace HeuristicLab.Analysis.FitnessLandscape {
    1415 
    1516  [Item("RealVectorBoundingBoxUpdater", "Updates a bounding box using a real vector to be enclosed.")]
    16   [StorableClass]
     17  [StorableType("1EBAC56C-83F0-41C1-8E42-365E7187EA0D")]
    1718  public class RealVectorBoundingBoxUpdater : SingleSuccessorOperator {
    1819
     
    3940
    4041    [StorableConstructor]
    41     protected RealVectorBoundingBoxUpdater(bool deserializing) : base(deserializing) { }
     42    protected RealVectorBoundingBoxUpdater(StorableConstructorFlag _) : base(_) { }
    4243    protected RealVectorBoundingBoxUpdater(RealVectorBoundingBoxUpdater original, Cloner cloner)
    4344      : base(original, cloner) {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/RepeatAggregator.cs

    r7128 r16573  
    99using HeuristicLab.Parameters;
    1010using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     11using HEAL.Attic;
    1112
    1213namespace HeuristicLab.Analysis.FitnessLandscape.Analysis {
    1314
    1415  [Item("RepeatAggregator", "Aggregates analysis results from repeated runs on the same starting point.")]
    15   [StorableClass]
     16  [StorableType("1AFD7B2D-E0AF-4E48-9633-4C17A70D323C")]
    1617  public class RepeatAggregator : SingleSuccessorOperator {
    1718
     
    2425    #region Construction & Cloning
    2526    [StorableConstructor]
    26     protected RepeatAggregator(bool deserializing) : base(deserializing) { }
     27    protected RepeatAggregator(StorableConstructorFlag _) : base(_) { }
    2728    protected RepeatAggregator(RepeatAggregator original, Cloner cloner) : base(original, cloner) { }
    2829    public RepeatAggregator() {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/RuggednessAnalyzer.cs

    r7176 r16573  
    2929using HeuristicLab.Parameters;
    3030using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     31using HEAL.Attic;
    3132
    3233namespace HeuristicLab.Analysis.FitnessLandscape.Analysis {
    3334
    34   [StorableClass]
     35  [StorableType("F018AA6C-B392-4D10-8817-D058D7678149")]
    3536  public class RuggednessAnalyzer : AlgorithmOperator, IQualityTrailAnalyzer {
    3637    public bool EnabledByDefault {
     
    6061
    6162    [StorableConstructor]
    62     protected RuggednessAnalyzer(bool deserializing) : base(deserializing) { }
     63    protected RuggednessAnalyzer(StorableConstructorFlag _) : base(_) { }
    6364    protected RuggednessAnalyzer(RuggednessAnalyzer original, Cloner cloner) : base(original, cloner) { }
    6465
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/RuggednessCalculator.cs

    r7128 r16573  
    88using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    99using System.Collections.Generic;
     10using HEAL.Attic;
    1011
    1112namespace HeuristicLab.Analysis.FitnessLandscape.Analysis {
    1213  [Item("Ruggedness Calculator", "Calculates ruggedness descriptors froma given quality trail.")]
    13   [StorableClass]
     14  [StorableType("1739820A-DC44-4371-A912-E44C1DD46940")]
    1415  public class RuggednessCalculator : SingleSuccessorOperator {
    1516
     
    2930    #region Constructors & Cloning
    3031    [StorableConstructor]
    31     protected RuggednessCalculator(bool deserializing) : base(deserializing) { }
     32    protected RuggednessCalculator(StorableConstructorFlag _) : base(_) { }
    3233    protected RuggednessCalculator(RuggednessCalculator original, Cloner cloner) : base(original, cloner) { }
    3334    public RuggednessCalculator() {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/UpDownWalkAnalyzer.cs

    r15100 r16573  
    3131using HeuristicLab.Parameters;
    3232using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     33using HEAL.Attic;
    3334
    3435namespace HeuristicLab.Analysis.FitnessLandscape.Analysis {
    3536
    36   [StorableClass]
     37  [StorableType("0D054A87-A040-4DC5-A722-0952EE96C924")]
    3738  public class UpDownWalkAnalyzer : AlgorithmOperator, IQualityTrailAnalyzer {
    3839    public bool EnabledByDefault {
     
    8081
    8182    [StorableConstructor]
    82     protected UpDownWalkAnalyzer(bool deserializing) : base(deserializing) { }
     83    protected UpDownWalkAnalyzer(StorableConstructorFlag _) : base(_) { }
    8384    protected UpDownWalkAnalyzer(UpDownWalkAnalyzer original, Cloner cloner) : base(original, cloner) { }
    8485
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/BestWorstSelector.cs

    r7128 r16573  
    88using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    99using HeuristicLab.Selection;
     10using HEAL.Attic;
    1011
    1112namespace HeuristicLab.Analysis.FitnessLandscape {
    1213  [Item("BestOrWorstSelector", "A selection operator that moves towards the next local optimum, when found reverses direction and so on.")]
    13   [StorableClass]
     14  [StorableType("79C66FA1-AF32-468D-9836-4B48BAC84316")]
    1415  public class BestWorstSelector : SingleObjectiveSelector, ISingleObjectiveSelector {
    1516
     
    2930
    3031    [StorableConstructor]
    31     protected BestWorstSelector(bool deserializing) : base(deserializing) { }
     32    protected BestWorstSelector(StorableConstructorFlag _) : base(_) { }
    3233    protected BestWorstSelector(BestWorstSelector original, Cloner cloner) : base(original, cloner) { }
    3334    public BestWorstSelector() {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/BoxChart/BitmapItem.cs

    r7128 r16573  
    55using HeuristicLab.Core;
    66using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     7using HEAL.Attic;
    78
    89namespace HeuristicLab.Analysis.FitnessLandscape.BoxCharts {
    910
    10   [StorableClass]
     11  [StorableType("58401951-FA4A-4D64-87DD-0B42DC00991F")]
    1112  public class BitmapItem : Item {
    1213
     
    3334
    3435    [StorableConstructor]
    35     protected BitmapItem(bool deserializing) : base(deserializing) { }
     36    protected BitmapItem(StorableConstructorFlag _) : base(_) { }
    3637    protected BitmapItem(BitmapItem original, Cloner cloner) : base(original, cloner) {
    3738      Image = (Bitmap)original.Image.Clone();
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/BoxChart/BoxChartCreator.cs

    r11661 r16573  
    1313using HeuristicLab.Parameters;
    1414using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     15using HEAL.Attic;
    1516
    1617namespace HeuristicLab.Analysis.FitnessLandscape.BoxCharts {
    1718
    1819  [Item("Box Chart Creator", "Visualizes essential run information by creating an overview chart.")]
    19   [StorableClass]
     20  [StorableType("C6897D24-4E02-411E-B92D-43CC055D7C9C")]
    2021  public class BoxChartCreator : ParameterizedNamedItem, IRunCollectionModifier {
    2122
     
    5859    #region Construction & Cloning
    5960    [StorableConstructor]
    60     protected BoxChartCreator(bool deserializing) : base(deserializing) { }
     61    protected BoxChartCreator(StorableConstructorFlag _) : base(_) { }
    6162    protected BoxChartCreator(BoxChartCreator original, Cloner cloner)
    6263      : base(original, cloner) {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/BoxChart/ColorValue.cs

    r7202 r16573  
    99using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    1010using HeuristicLab.Common.Resources;
     11using HEAL.Attic;
    1112
    1213namespace HeuristicLab.Analysis.FitnessLandscape.BoxChart {
    1314
    1415  [Item("Color", "A color")]
    15   [StorableClass]
     16  [StorableType("E4C70605-7105-4ADC-90BC-A0C3994B061B")]
    1617  public class ColorValue : NamedItem {
    1718
     
    135136    #region Construction & Cloning
    136137    [StorableConstructor]
    137     protected ColorValue(bool deserializing) : base(deserializing) { }
     138    protected ColorValue(StorableConstructorFlag _) : base(_) { }
    138139    protected ColorValue(ColorValue original, Cloner cloner) : base (original, cloner) {
    139140      h = original.h;
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/BoxChart/DiscreteValueBoxChartElementGenerator.cs

    r7128 r16573  
    1212using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    1313using HeuristicLab.Analysis.FitnessLandscape.BoxChart;
     14using HEAL.Attic;
    1415
    1516namespace HeuristicLab.Analysis.FitnessLandscape.BoxCharts {
    1617
    17   [StorableClass]
     18  [StorableType("70DD55A7-03E3-495E-8D7A-1FA3FB0801B0")]
    1819  public class DiscreteValueBoxChartElementGenerator : EmptyBoxChartElementGenerator {
    1920
     
    3940
    4041    [StorableConstructor]
    41     protected DiscreteValueBoxChartElementGenerator(bool deserializing) : base(deserializing) { }
     42    protected DiscreteValueBoxChartElementGenerator(StorableConstructorFlag _) : base(_) { }
    4243    protected DiscreteValueBoxChartElementGenerator(DiscreteValueBoxChartElementGenerator original, Cloner cloner)
    4344      : base(original, cloner) {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/BoxChart/EmptyBoxChartElementGenerator.cs

    r7210 r16573  
    1111using HeuristicLab.Parameters;
    1212using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     13using HEAL.Attic;
    1314
    1415namespace HeuristicLab.Analysis.FitnessLandscape.BoxCharts {
    1516 
    16   [StorableClass]
     17  [StorableType("A3B05023-AFF2-4550-A78C-F0513F308316")]
    1718  public class EmptyBoxChartElementGenerator : ParameterizedNamedItem, IBoxChartElementGenerator {
    1819
     
    4950    #region Construction & Cloning
    5051    [StorableConstructor]
    51     protected EmptyBoxChartElementGenerator(bool deserializing) : base(deserializing) { }
     52    protected EmptyBoxChartElementGenerator(StorableConstructorFlag _) : base(_) { }
    5253    protected EmptyBoxChartElementGenerator(EmptyBoxChartElementGenerator original, Cloner cloner) : base(original, cloner) {
    5354      RegisterEvents();
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/BoxChart/ResultNamesCollector.cs

    r7211 r16573  
    88using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    99using HeuristicLab.Data;
     10using HEAL.Attic;
    1011
    1112namespace HeuristicLab.Analysis.FitnessLandscape.BoxChart {
    1213  [Item("Result Names Collector", "Collects all occuring names of parameters and results in the currenly visible runs")]
    13   [StorableClass]
     14  [StorableType("90ADFC82-D508-4532-8F5E-690EB4F3F60F")]
    1415  public class ResultNamesCollector : ParameterizedNamedItem, IRunCollectionModifier {
    1516
     
    1718
    1819    [StorableConstructor]
    19     protected ResultNamesCollector(bool deserializing) : base(deserializing) {}
     20    protected ResultNamesCollector(StorableConstructorFlag _) : base(_) { }
    2021
    2122    protected ResultNamesCollector(ResultNamesCollector original, Cloner cloner) : base(original, cloner) {}
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/BoxChart/RunCollectionMultiDiscretizer.cs

    r7212 r16573  
    99using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    1010using HeuristicLab.Data;
     11using HEAL.Attic;
    1112
    1213namespace HeuristicLab.Optimization.RunModification {
     
    1516    "Creates several levels from the distribution of several results accross a run collection and " +
    1617    "assigns a discretized value. Non-existing numbers as well as NaN and infinities are excluded from the caluclation.")]
    17   [StorableClass]
     18  [StorableType("74B90692-F3F2-4E0B-AA17-C3CDD710D009")]
    1819  public class RunCollectionMultiDiscretizer : ParameterizedNamedItem, IRunCollectionModifier {
    1920
     
    4748      #region Construction & Cloning
    4849    [StorableConstructor]
    49     protected RunCollectionMultiDiscretizer(bool deserializing) : base(deserializing) { }
     50    protected RunCollectionMultiDiscretizer(StorableConstructorFlag _) : base(_) { }
    5051    protected RunCollectionMultiDiscretizer(RunCollectionMultiDiscretizer original, Cloner cloner) : base(original, cloner) { }
    5152    public RunCollectionMultiDiscretizer() {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/BoxChart/StringConstantBoxChartElementGenerator.cs

    r7128 r16573  
    1111using HeuristicLab.Parameters;
    1212using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     13using HEAL.Attic;
    1314
    1415namespace HeuristicLab.Analysis.FitnessLandscape.BoxCharts {
    1516
    16   [StorableClass]
     17  [StorableType("29AED0E8-1190-4DFC-92FC-0AC69FE4DBC1")]
    1718  public class StringConstantBoxChartElementGenerator : EmptyBoxChartElementGenerator {
    1819
     
    2930    #region Construction & Cloning
    3031    [StorableConstructor]
    31     protected StringConstantBoxChartElementGenerator(bool deserializing) : base(deserializing) { }
     32    protected StringConstantBoxChartElementGenerator(StorableConstructorFlag _) : base(_) { }
    3233    protected StringConstantBoxChartElementGenerator(StringConstantBoxChartElementGenerator original, Cloner cloner) : base(original, cloner) {
    3334      RegisterEvents();
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/BoxChart/StringValueBoxChartElementGenerator.cs

    r7128 r16573  
    1111using HeuristicLab.Parameters;
    1212using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     13using HEAL.Attic;
    1314
    1415namespace HeuristicLab.Analysis.FitnessLandscape.BoxCharts {
    1516
    16   [StorableClass]
     17  [StorableType("E04F26F6-E8CF-4EF1-96AC-B3FFF38E4ACE")]
    1718  public class StringValueBoxChartElementGenerator : EmptyBoxChartElementGenerator {
    1819
     
    3031
    3132    [StorableConstructor]
    32     protected StringValueBoxChartElementGenerator(bool deserializing) : base(deserializing) { }
     33    protected StringValueBoxChartElementGenerator(StorableConstructorFlag _) : base(_) { }
    3334    protected StringValueBoxChartElementGenerator(StringValueBoxChartElementGenerator original, Cloner cloner) : base(original, cloner) {
    3435      RegisterEvents();
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/DataTables/AutoCorrelationTable.cs

    r7128 r16573  
    33using HeuristicLab.Core;
    44using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     5using HEAL.Attic;
     6
    57namespace HeuristicLab.Analysis.FitnessLandscape.DataTables {
    68
    79  [Item("AutoCorrelationTable", "DataTable that contains a series with the auto correlation function")]
    8   [StorableClass]
     10  [StorableType("FD034211-02CD-418F-B45C-D6C35F8C0651")]
    911  public class AutoCorrelationTable : DataTable {
    1012
     
    1214
    1315    [StorableConstructor]
    14     protected AutoCorrelationTable(bool deserializing) : base(deserializing) { }
     16    protected AutoCorrelationTable(StorableConstructorFlag _) : base(_) { }
    1517    protected AutoCorrelationTable(AutoCorrelationTable original, Cloner cloner) : base(original, cloner) { }
    1618    public AutoCorrelationTable() : base() { }
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/DataTables/InformationAnalysisTable.cs

    r7128 r16573  
    33using HeuristicLab.Core;
    44using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     5using HEAL.Attic;
     6
    57namespace HeuristicLab.Analysis.FitnessLandscape.DataTables {
    68
    79  [Item("InformationAnalysisTable", "DataTable that contains series with results of an information analysis")]
    8   [StorableClass]
     10  [StorableType("6E9BB524-0ECA-4796-AB6D-4D6B4A083FB8")]
    911  public class InformationAnalysisTable : DataTable {
    1012
     
    1214
    1315    [StorableConstructor]
    14     protected InformationAnalysisTable(bool deserializing) : base(deserializing) { }
     16    protected InformationAnalysisTable(StorableConstructorFlag _) : base(_) { }
    1517    protected InformationAnalysisTable(InformationAnalysisTable original, Cloner cloner) : base(original, cloner) { }
    1618    public InformationAnalysisTable() : base() { }
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/DataTables/InformationStabilityTable.cs

    r7128 r16573  
    33using HeuristicLab.Core;
    44using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     5using HEAL.Attic;
     6
    57namespace HeuristicLab.Analysis.FitnessLandscape.DataTables {
    68
    79  [Item("InformationStabiliyTable", "DataTable that contains a series with the development of information stability over time.")]
    8   [StorableClass]
     10  [StorableType("004EF230-DB82-413F-B6B0-8FB68C3901BB")]
    911  public class InformationStabilityTable : DataTable {
    1012
     
    1214
    1315    [StorableConstructor]
    14     protected InformationStabilityTable(bool deserializing) : base(deserializing) { }
     16    protected InformationStabilityTable(StorableConstructorFlag _) : base(_) { }
    1517    protected InformationStabilityTable(InformationStabilityTable original, Cloner cloner) : base(original, cloner) { }
    1618    public InformationStabilityTable() : base() { }
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/DataTables/QualityTrailSummaryTable.cs

    r7128 r16573  
    33using HeuristicLab.Core;
    44using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     5using HEAL.Attic;
     6
    57namespace HeuristicLab.Analysis.FitnessLandscape.DataTables {
    68
    79  [Item("QualityTrailSummaryTable", "DataTable that contains a compact description of the quality trail.")]
    8   [StorableClass]
     10  [StorableType("CF7B9594-9A6E-4756-987E-66019366586A")]
    911  public class QualityTrailSummaryTable : DataTable {
    1012
     
    1214
    1315    [StorableConstructor]
    14     protected QualityTrailSummaryTable(bool deserializing) : base(deserializing) { }
     16    protected QualityTrailSummaryTable(StorableConstructorFlag _) : base(_) { }
    1517    protected QualityTrailSummaryTable(QualityTrailSummaryTable original, Cloner cloner) : base(original, cloner) { }
    1618    public QualityTrailSummaryTable() : base() { }
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/DistanceCalculators/BinaryVectorDistanceCalculator.cs

    r7202 r16573  
    99using HeuristicLab.Encodings.BinaryVectorEncoding;
    1010using System.Drawing;
     11using HEAL.Attic;
    1112
    1213namespace HeuristicLab.Analysis.FitnessLandscape.DistanceCalculators {
    1314
    1415  [Item("BinaryVectorDistanceCalculator", "Calculates the hamming distance of two binary vectors")]
    15   [StorableClass]
     16  [StorableType("BB6A8FD8-22B1-41CC-B38D-C8C9A2B79C83")]
    1617  public class BinaryVectorDistanceCalculator : NamedItem, IItemDistanceCalculator {
    1718
     
    2728
    2829    [StorableConstructor]
    29     protected BinaryVectorDistanceCalculator(bool deserializing) : base(deserializing) { }
     30    protected BinaryVectorDistanceCalculator(StorableConstructorFlag _) : base(_) { }
    3031
    3132    protected BinaryVectorDistanceCalculator(BinaryVectorDistanceCalculator original, Cloner cloner)
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/DistanceCalculators/PermutationDistanceCalculator.cs

    r7202 r16573  
    1010using HeuristicLab.Encodings.PermutationEncoding;
    1111using System.Drawing;
     12using HEAL.Attic;
    1213
    1314namespace HeuristicLab.Analysis.FitnessLandscape.DistanceCalculators {
    1415
    1516  [Item("PermutationDistanceCalculator", "Calculates the distance of two permutations")]
    16   [StorableClass]
     17  [StorableType("F2B93749-3059-4D37-91A5-FAE2DC9DB794")]
    1718  public class PermutationDistanceCalculator : NamedItem, IItemDistanceCalculator {
    1819
     
    2829
    2930    [StorableConstructor]
    30     protected PermutationDistanceCalculator(bool deserializing) : base(deserializing) { }
     31    protected PermutationDistanceCalculator(StorableConstructorFlag _) : base(_) { }
    3132
    3233    protected PermutationDistanceCalculator(PermutationDistanceCalculator original, Cloner cloner)
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/DistanceCalculators/RealVectorDistanceCalculator.cs

    r12575 r16573  
    1010using System.Drawing;
    1111using HeuristicLab.Encodings.RealVectorEncoding;
     12using HEAL.Attic;
    1213
    1314namespace HeuristicLab.Analysis.FitnessLandscape.DistanceCalculators {
    1415
    1516  [Item("RealVectorDistanceCalculator", "Calculates the Euclidian distance of two real vectors")]
    16   [StorableClass]
     17  [StorableType("26271DB0-0868-4363-84AE-46CF583276F0")]
    1718  public class RealVectorDistanceCalculator: NamedItem, IItemDistanceCalculator {
    1819
     
    2829
    2930    [StorableConstructor]
    30     protected RealVectorDistanceCalculator(bool deserializing) : base(deserializing) { }
     31    protected RealVectorDistanceCalculator(StorableConstructorFlag _) : base(_) { }
    3132
    3233    protected RealVectorDistanceCalculator(RealVectorDistanceCalculator original, Cloner cloner)
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/EngineAlgorithm/EngineAlgorithmOperator.cs

    r7128 r16573  
    66using HeuristicLab.Parameters;
    77using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     8using HEAL.Attic;
    89
    910namespace HeuristicLab.Operators {
    1011
    1112  [Item("EngineAlgorithmOperator", "An operator the encapsulates a complete algorithm.")]
    12   [StorableClass]
     13  [StorableType("8BEF3D75-7DA3-4683-95C5-AF7B6AC0A810")]
    1314  public class EngineAlgorithmOperator : AlgorithmOperator {
    1415
     
    132133    #region Construction & Cloning
    133134    [StorableConstructor]
    134     protected EngineAlgorithmOperator(bool deserializing) : base(deserializing) { }
     135    protected EngineAlgorithmOperator(StorableConstructorFlag _) : base(_) { }
    135136    protected EngineAlgorithmOperator(EngineAlgorithmOperator original, Cloner cloner)
    136137      : base(original, cloner) {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Evolvability/EvolvabilityAnalyzer.cs

    r7176 r16573  
    33using System.Drawing;
    44using System.Linq;
     5using HEAL.Attic;
    56using HeuristicLab.Common;
    67using HeuristicLab.Core;
     
    1516
    1617  [Item("Evolvability Analyzer", "Compares two sets of scopes containing the original population and the evolved population generating several evolvability measures.")]
     18  [StorableType("6B05CC43-161A-45C6-9B08-A4CC2235A96B")]
    1719  public class EvolvabilityAnalyzer : AlgorithmOperator, IAnalyzer {
    1820
    19     public bool EnabledByDefault {
     21    public bool EnabledByDefault
     22    {
    2023      get { return false; }
    2124    }
    2225
    2326    #region Parameters
    24     public LookupParameter<DoubleValue> QualityParameter {
     27    public LookupParameter<DoubleValue> QualityParameter
     28    {
    2529      get { return (LookupParameter<DoubleValue>)Parameters["Quality"]; }
    2630    }
    27     public LookupParameter<IntValue> SampleSizeParameter {
     31    public LookupParameter<IntValue> SampleSizeParameter
     32    {
    2833      get { return (LookupParameter<IntValue>)Parameters["SampleSize"]; }
    2934    }
    30     public LookupParameter<HeatMap> EvolvabilityPlotParameter {
     35    public LookupParameter<HeatMap> EvolvabilityPlotParameter
     36    {
    3137      get { return (LookupParameter<HeatMap>)Parameters["EvolvabilityPlot"]; }
    3238    }
    33     public LookupParameter<VariableCollection> ResultsParameter {
     39    public LookupParameter<VariableCollection> ResultsParameter
     40    {
    3441      get { return (LookupParameter<VariableCollection>)Parameters["Results"]; }
    3542    }
    36     public LookupParameter<ScatterPlot> FitnessCloudParameter {
     43    public LookupParameter<ScatterPlot> FitnessCloudParameter
     44    {
    3745      get { return (LookupParameter<ScatterPlot>)Parameters["FitnessCloud"]; }
    3846    }
    39     public LookupParameter<DataTable> EvolvabilityPortraitParameter {
     47    public LookupParameter<DataTable> EvolvabilityPortraitParameter
     48    {
    4049      get { return (LookupParameter<DataTable>)Parameters["EvolvabilityPortrait"]; }
    4150    }
    42     public ValueLookupParameter<IntValue> NrOfBinsParameter {
     51    public ValueLookupParameter<IntValue> NrOfBinsParameter
     52    {
    4353      get { return (ValueLookupParameter<IntValue>)Parameters["NrOfBins"]; }
    4454    }
    45     public ScopeParameter ScopeParameter {
     55    public ScopeParameter ScopeParameter
     56    {
    4657      get { return (ScopeParameter)Parameters["Scope"]; }
    4758    }
     
    6980
    7081    [StorableConstructor]
    71     protected EvolvabilityAnalyzer(bool deserializing) : base(deserializing) { }
     82    protected EvolvabilityAnalyzer(StorableConstructorFlag _) : base(_) { }
    7283
    7384    protected EvolvabilityAnalyzer(EvolvabilityAnalyzer original, Cloner cloner)
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Exhaustive/PermutationEnumerationManipulator.cs

    r7128 r16573  
    2727using HeuristicLab.Parameters;
    2828using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     29using HEAL.Attic;
    2930
    3031namespace HeuristicLab.Analysis.FitnessLandscape {
    3132
    3233  [Item("PermutationEnumerationManipulator", "An operator that generates the next permutation based on lexicographic ordering.")]
    33   [StorableClass]
     34  [StorableType("081A2A92-462E-4BA9-A643-D40F776BA14B")]
    3435  public class PermutationEnumerationManipulator : PermutationManipulator {
    3536
     
    3940
    4041    [StorableConstructor]
    41     protected PermutationEnumerationManipulator(bool deserializing) : base(deserializing) { }
     42    protected PermutationEnumerationManipulator(StorableConstructorFlag _) : base(_) { }
    4243    protected PermutationEnumerationManipulator(PermutationEnumerationManipulator original, Cloner cloner) : base(original, cloner) { }
    4344    public PermutationEnumerationManipulator() {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/FDC/BinaryVectorFitnessDistanceCorrelationAnalyzer.cs

    r7128 r16573  
    2828using HeuristicLab.Parameters;
    2929using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     30using HEAL.Attic;
    3031
    3132namespace HeuristicLab.Analysis.FitnessLandscape {
    3233
    3334  [Item("BinaryVectorFitnessDistanceCorrelationAnalyzer", "An operator that analyzes the correlation between fitness and distance to the best know solution for binary vector encoding")]
    34   [StorableClass]
     35  [StorableType("BE5474B1-9D8E-4AA0-9236-85C192712A96")]
    3536  public class BinaryVectorFitnessDistanceCorrelationAnalyzer : FitnessDistanceCorrelationAnalyzer, IBinaryVectorOperator {
    3637
     
    4546
    4647    [StorableConstructor]
    47     protected BinaryVectorFitnessDistanceCorrelationAnalyzer(bool deserializing) : base(deserializing) { }
     48    protected BinaryVectorFitnessDistanceCorrelationAnalyzer(StorableConstructorFlag _) : base(_) { }
    4849    protected BinaryVectorFitnessDistanceCorrelationAnalyzer(BinaryVectorFitnessDistanceCorrelationAnalyzer original, Cloner cloner) : base(original, cloner) { }
    4950
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/FDC/FitnessDistanceCorrelationAnalyzer.cs

    r7176 r16573  
    3131using HeuristicLab.Parameters;
    3232using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     33using HEAL.Attic;
    3334
    3435namespace HeuristicLab.Analysis.FitnessLandscape {
    3536
    36   [StorableClass]
     37  [StorableType("A603BC77-CAA7-468B-9206-500A196691E7")]
    3738  public abstract class FitnessDistanceCorrelationAnalyzer : AlgorithmOperator, IAnalyzer {
    3839    public bool EnabledByDefault {
     
    5354
    5455    [StorableConstructor]
    55     protected FitnessDistanceCorrelationAnalyzer(bool deserializing) : base(deserializing) { }
     56    protected FitnessDistanceCorrelationAnalyzer(StorableConstructorFlag _) : base(_) { }
    5657    protected FitnessDistanceCorrelationAnalyzer(FitnessDistanceCorrelationAnalyzer original, Cloner cloner)
    5758      : base(original, cloner) { }
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/FDC/HeatMap.cs

    r7202 r16573  
    2727using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2828using HeuristicLab.Common.Resources;
     29using HEAL.Attic;
    2930
    3031namespace HeuristicLab.Analysis.FitnessLandscape {
    3132
    3233  [Item("HeatMap", "A heat map of 2D data")]
    33   [StorableClass]
     34  [StorableType("F37D5082-48E9-495C-9489-F63C7C76E33A")]
    3435  public class HeatMap : NamedItem {
    3536
     
    7374
    7475    [StorableConstructor]
    75     protected HeatMap(bool deserializing) : base(deserializing) { }
     76    protected HeatMap(StorableConstructorFlag _) : base(_) { }
    7677    protected HeatMap(HeatMap original, Cloner cloner)
    7778      : base(original, cloner) {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/FDC/PermutationFitnessDistanceCorrelationAnalyzer.cs

    r7128 r16573  
    2929using HeuristicLab.Parameters;
    3030using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     31using HEAL.Attic;
    3132
    3233namespace HeuristicLab.Analysis.FitnessLandscape {
    3334
    3435  [Item("PermutationFitnessDistanceCorrelationAnalyzer", "An operator that analyzes the correlation between fitness and distance to the best know solution for permutation encoding")]
    35   [StorableClass]
     36  [StorableType("2021A1AA-FE98-4D42-8730-23C5EA552B21")]
    3637  public class PermutationFitnessDistanceCorrelationAnalyzer : FitnessDistanceCorrelationAnalyzer, IPermutationOperator {
    3738
     
    4647
    4748    [StorableConstructor]
    48     protected PermutationFitnessDistanceCorrelationAnalyzer(bool deserializing) : base(deserializing) { }
     49    protected PermutationFitnessDistanceCorrelationAnalyzer(StorableConstructorFlag _) : base(_) { }
    4950    protected PermutationFitnessDistanceCorrelationAnalyzer(PermutationFitnessDistanceCorrelationAnalyzer original, Cloner cloner) : base(original, cloner) { }
    5051
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/FDC/QAPPermutationFitnessDistanceCorrelationAnalyzer.cs

    r7128 r16573  
    2828using HeuristicLab.Parameters;
    2929using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     30using HEAL.Attic;
    3031
    3132namespace HeuristicLab.Analysis.FitnessLandscape {
    3233
    3334  [Item("QAPPermutationFitnessDistanceCorrelationAnalyzer", "An operator that analyzes the correlation between fitness and distance to the best know solution for permutation encoding")]
    34   [StorableClass]
     35  [StorableType("31823F7B-55FB-4D57-80EE-89F4D90B6412")]
    3536  public class QAPPermutationFitnessDistanceCorrelationAnalyzer : FitnessDistanceCorrelationAnalyzer, IPermutationOperator {
    3637
     
    5152
    5253    [StorableConstructor]
    53     protected QAPPermutationFitnessDistanceCorrelationAnalyzer(bool deserializing) : base(deserializing) { }
     54    protected QAPPermutationFitnessDistanceCorrelationAnalyzer(StorableConstructorFlag _) : base(_) { }
    5455    protected QAPPermutationFitnessDistanceCorrelationAnalyzer(QAPPermutationFitnessDistanceCorrelationAnalyzer original, Cloner cloner) : base(original, cloner) { }
    5556
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/FDC/RealVectorFitnessDistanceCorrelationAnalyzer.cs

    r7128 r16573  
    2828using HeuristicLab.Parameters;
    2929using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     30using HEAL.Attic;
    3031
    3132namespace HeuristicLab.Analysis.FitnessLandscape {
    3233
    3334  [Item("RealVectorFitnessDistanceCorrelationAnalyzer", "An operator that analyzes the correlation between fitness and distance to the best know solution for real vector encoding")]
    34   [StorableClass]
     35  [StorableType("84EA2C55-F847-4CF9-B966-0E7B9DD8903C")]
    3536  public class RealVectorFitnessDistanceCorrelationAnalyzer : FitnessDistanceCorrelationAnalyzer, IRealVectorOperator {
    3637
     
    4546
    4647    [StorableConstructor]
    47     protected RealVectorFitnessDistanceCorrelationAnalyzer(bool deserializing) : base(deserializing) { }
     48    protected RealVectorFitnessDistanceCorrelationAnalyzer(StorableConstructorFlag _) : base(_) { }
    4849    protected RealVectorFitnessDistanceCorrelationAnalyzer(RealVectorFitnessDistanceCorrelationAnalyzer original, Cloner cloner) : base(original, cloner) { }
    4950
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/FDC/ScatterPlot.cs

    r7291 r16573  
    2828using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2929using HeuristicLab.Common.Resources;
     30using HEAL.Attic;
    3031
    3132namespace HeuristicLab.Analysis.FitnessLandscape {
     
    3940
    4041  [Item("ScatterPlot", "A scatter plot of 2D data")]
    41   [StorableClass]
     42  [StorableType("317254F8-A1D9-4675-8292-5CDF078B53BD")]
    4243  public class ScatterPlot : NamedItem {
    4344
     
    121122
    122123    [StorableConstructor]
    123     protected ScatterPlot(bool deserializing) : base(deserializing) { }
     124    protected ScatterPlot(StorableConstructorFlag _) : base(_) { }
    124125    protected ScatterPlot(ScatterPlot original, Cloner cloner)
    125126      : base(original, cloner) {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/HeuristicLab.Analysis.FitnessLandscape.csproj

    r15691 r16573  
    11<?xml version="1.0" encoding="utf-8"?>
    2 <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
     2<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    33  <PropertyGroup>
    44    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     
    1111    <RootNamespace>HeuristicLab.Analysis.FitnessLandscape</RootNamespace>
    1212    <AssemblyName>HeuristicLab.Analysis.FitnessLandscape-3.3</AssemblyName>
    13     <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
     13    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
    1414    <FileAlignment>512</FileAlignment>
    1515    <SignAssembly>true</SignAssembly>
     
    9595      <HintPath>..\..\..\trunk\bin\ALGLIB-3.7.0.dll</HintPath>
    9696    </Reference>
     97    <Reference Include="Google.Protobuf, Version=3.6.1.0, Culture=neutral, PublicKeyToken=a7d26565bac4d604, processorArchitecture=MSIL">
     98      <HintPath>..\packages\Google.Protobuf.3.6.1\lib\net45\Google.Protobuf.dll</HintPath>
     99    </Reference>
     100    <Reference Include="HEAL.Attic, Version=1.0.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
     101      <HintPath>..\packages\HEAL.Attic.1.0.0-pre02\lib\net461\HEAL.Attic.dll</HintPath>
     102    </Reference>
    97103    <Reference Include="HeuristicLab.Analysis-3.3">
    98104      <HintPath>..\..\..\trunk\bin\HeuristicLab.Analysis-3.3.dll</HintPath>
     
    157163    </Reference>
    158164    <Reference Include="System.Drawing" />
     165    <Reference Include="System.Drawing.Common, Version=4.0.0.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
     166      <HintPath>..\packages\System.Drawing.Common.4.5.1\lib\net461\System.Drawing.Common.dll</HintPath>
     167    </Reference>
    159168    <Reference Include="System.IO.Compression" />
    160169    <Reference Include="System.Windows.Forms" />
     
    249258    <Compile Include="TestFunctions\CustomAdditiveMoveEvaluator.cs" />
    250259    <Compile Include="TestFunctions\CustomEvaluator.cs" />
     260    <None Include="packages.config" />
    251261    <None Include="Properties\AssemblyInfo.cs.frame" />
    252262    <Compile Include="Properties\AssemblyInfo.cs" />
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/MultiTrajectory/GridRealVectorsCreator.cs

    r7128 r16573  
    3030using HeuristicLab.Parameters;
    3131using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     32using HEAL.Attic;
    3233
    3334namespace HeuristicLab.Analysis.FitnessLandscape {
    3435
    3536  [Item("GridRealVectorsCreator", "An operator that creates solutions on a grid accross the whole solution space.")]
    36   [StorableClass]
     37  [StorableType("B6DB3FBB-C87A-484A-B967-5D934A7CAD75")]
    3738  public sealed class GridRealVectorCreator : SingleSuccessorOperator {
    3839
     
    7879    #region Construction & Cloning
    7980    [StorableConstructor]
    80     private GridRealVectorCreator(bool deserializing) : base(deserializing) { }
     81    private GridRealVectorCreator(StorableConstructorFlag _) : base(_) { }
    8182    private GridRealVectorCreator(GridRealVectorCreator original, Cloner cloner) : base(original, cloner) { }
    8283    public GridRealVectorCreator()
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/MultiTrajectory/MultiTrajectoryAnalysis.cs

    r15290 r16573  
    1515using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    1616using HeuristicLab.PluginInfrastructure;
     17using HEAL.Attic;
    1718
    1819namespace HeuristicLab.Analysis.FitnessLandscape.MultiTrajectory {
     
    2021  [Item("Multi Trajectory Analysis", "Host for performing and aggregating several algorithm runs for an overarching analysis.")]
    2122  [Creatable("Analysis")]
    22   [StorableClass]
     23  [StorableType("DC98F804-66D9-44C2-9FC5-0FAB799D20A7")]
    2324  public class MultiTrajectoryAnalysis : ParameterizedNamedItem, IAlgorithm, IStorableContent {
    2425
     
    7374    #region Construction and Cloning
    7475    [StorableConstructor]
    75     protected MultiTrajectoryAnalysis(bool deserializing)
    76       : base(deserializing) {
     76    protected MultiTrajectoryAnalysis(StorableConstructorFlag _) : base(_) {
    7777      RegisterEvents();
    7878    }
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/MultiTrajectory/PreassignedBinaryVectorCreator.cs

    r7128 r16573  
    55using HeuristicLab.Parameters;
    66using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     7using HEAL.Attic;
    78
    89namespace HeuristicLab.Analysis.FitnessLandscape.MultiTrajectory {
    910
    10   [StorableClass]
     11  [StorableType("FCB228DA-7A69-4987-BDBF-CE86027C09C5")]
    1112  public class PreassignedBinaryVectorCreator : PreassignedSolutionCreator, IBinaryVectorCreator {
    1213
     
    2021
    2122    [StorableConstructor]
    22     protected PreassignedBinaryVectorCreator(bool deserializing) : base(deserializing) { }
     23    protected PreassignedBinaryVectorCreator(StorableConstructorFlag _) : base(_) { }
    2324    protected PreassignedBinaryVectorCreator(PreassignedBinaryVectorCreator original, Cloner cloner)
    2425      : base(original, cloner) {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/MultiTrajectory/PreassignedPermutationCreator.cs

    r7128 r16573  
    66using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    77using HeuristicLab.Encodings.PermutationEncoding;
     8using HEAL.Attic;
    89
    910namespace HeuristicLab.Analysis.FitnessLandscape.MultiTrajectory {
    1011
    11   [StorableClass]
     12  [StorableType("4653B893-A98F-4FF4-A280-C402848F8A06")]
    1213  public class PreassignePermutationCreator : PreassignedSolutionCreator, IPermutationCreator {
    1314
     
    2526
    2627    [StorableConstructor]
    27     protected PreassignePermutationCreator(bool deserializing) : base(deserializing) { }
     28    protected PreassignePermutationCreator(StorableConstructorFlag _) : base(_) { }
    2829    protected PreassignePermutationCreator(PreassignePermutationCreator original, Cloner cloner)
    2930      : base(original, cloner) {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/MultiTrajectory/PreassignedRealVectorCreator.cs

    r7128 r16573  
    55using HeuristicLab.Parameters;
    66using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     7using HEAL.Attic;
    78
    89namespace HeuristicLab.Analysis.FitnessLandscape.MultiTrajectory {
    910
    10   [StorableClass]
     11  [StorableType("A690FC7E-A8B1-4CAB-AABD-18401330F01D")]
    1112  public class PreassignedRealVectorCreator : PreassignedSolutionCreator, IRealVectorCreator {
    1213
     
    2223
    2324    [StorableConstructor]
    24     protected PreassignedRealVectorCreator(bool deserializing) : base(deserializing) { }
     25    protected PreassignedRealVectorCreator(StorableConstructorFlag _) : base(_) { }
    2526    protected PreassignedRealVectorCreator(PreassignedRealVectorCreator original, Cloner cloner)
    2627      : base(original, cloner) {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/MultiTrajectory/PreassignedSolutionCreator.cs

    r7128 r16573  
    66using HeuristicLab.Parameters;
    77using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     8using HEAL.Attic;
    89
    910namespace HeuristicLab.Analysis.FitnessLandscape.MultiTrajectory {
    1011
    11   [StorableClass]
     12  [StorableType("1F8136F9-FBED-40F7-ACA3-E3D05F623A28")]
    1213  public abstract class PreassignedSolutionCreator : SingleSuccessorOperator, ISolutionCreator {
    1314
     
    4041
    4142    [StorableConstructor]
    42     protected PreassignedSolutionCreator(bool deserializing) : base(deserializing) { }
     43    protected PreassignedSolutionCreator(StorableConstructorFlag _) : base(_) { }
    4344
    4445    protected PreassignedSolutionCreator(PreassignedSolutionCreator original, Cloner cloner)
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/NeutralSelector.cs

    r8172 r16573  
    1111using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    1212using HeuristicLab.PluginInfrastructure;
     13using HEAL.Attic;
    1314
    1415namespace HeuristicLab.Analysis.FitnessLandscape {
    1516  [Item("NeutralSelector", "A selection operator that explores neutral areas.")]
    16   [StorableClass]
     17  [StorableType("36A053AF-DA26-4878-ADA3-E61CD200D753")]
    1718  public class NeutralSelector : SingleSuccessorOperator, ISingleObjectiveSelector {
    1819
     
    9697    #region Construction & Cloning
    9798    [StorableConstructor]
    98     protected NeutralSelector(bool deserializing) : base(deserializing) { }
     99    protected NeutralSelector(StorableConstructorFlag _) : base(_) { }
    99100    protected NeutralSelector(NeutralSelector original, Cloner cloner) : base(original, cloner) { }
    100101    public NeutralSelector() {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/PopDist/PopulationDistributionAnalyzer.cs

    r8172 r16573  
    3131using HeuristicLab.Parameters;
    3232using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     33using HEAL.Attic;
    3334
    3435namespace HeuristicLab.Analysis.FitnessLandscape {
    3536
    3637  [Item("PopulationDistributionAnalyzer", "An operator that analyzes the distribution of fitness values")]
    37   [StorableClass]
     38  [StorableType("B2AD2ACD-FCEA-4D05-856B-63D88F521642")]
    3839  public class PopulationDistributionAnalyzer : AlgorithmOperator, IAnalyzer {
    3940    public bool EnabledByDefault {
     
    7273
    7374    [StorableConstructor]
    74     protected PopulationDistributionAnalyzer(bool deserializing) : base(deserializing) { }
     75    protected PopulationDistributionAnalyzer(StorableConstructorFlag _) : base(_) { }
    7576    protected PopulationDistributionAnalyzer(PopulationDistributionAnalyzer original, Cloner cloner) : base(original, cloner) { }
    7677
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/ScopePathLookupParameter.cs

    r7128 r16573  
    44using HeuristicLab.Core;
    55using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     6using HEAL.Attic;
    67
    78namespace HeuristicLab.Parameters {
    89
    910  [Item("ScopePathLookupParameter", "Start parameter lookup after freely navigating the scope tree using a path string.")]
    10   [StorableClass]
     11  [StorableType("3E5F3D67-61FD-427C-A822-6C623C0AA3DA")]
    1112  public class ScopePathLookupParameter<T> : LookupParameter<T>, ILookupParameter<T> where T : class, IItem {
    1213
     
    3536
    3637    [StorableConstructor]
    37     protected ScopePathLookupParameter(bool deserializing) : base(deserializing) { }
     38    protected ScopePathLookupParameter(StorableConstructorFlag _) : base(_) { }
    3839    protected ScopePathLookupParameter(ScopePathLookupParameter<T> original, Cloner cloner)
    3940      : base(original, cloner) {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/TestFunctions/CustomAdditiveMoveEvaluator.cs

    r9407 r16573  
    2828using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2929using HeuristicLab.Problems.TestFunctions.Evaluators;
     30using HEAL.Attic;
    3031
    3132namespace HeuristicLab.Problems.TestFunctions {
    3233  [Item("CustomAdditiveMoveEvaluator", "Class for evaluating an additive move on a custom test function.")]
    33   [StorableClass]
     34  [StorableType("F50ACE87-C3E0-42BA-B70C-57EEEEF2DF42")]
    3435  public class CustomAdditiveMoveEvaluator : AdditiveMoveEvaluator {
    3536    public LookupParameter<ISingleObjectiveTestFunctionProblemEvaluator> EvaluatorParameter {
     
    3839
    3940    [StorableConstructor]
    40     protected CustomAdditiveMoveEvaluator(bool deserializing) : base(deserializing) { }
     41    protected CustomAdditiveMoveEvaluator(StorableConstructorFlag _) : base(_) { }
    4142    protected CustomAdditiveMoveEvaluator(CustomAdditiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
    4243    public CustomAdditiveMoveEvaluator() {
  • addons/HeuristicLab.FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/TestFunctions/CustomEvaluator.cs

    r9984 r16573  
    2626using HeuristicLab.Encodings.RealVectorEncoding;
    2727using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     28using HEAL.Attic;
    2829
    2930namespace HeuristicLab.Problems.TestFunctions.Evaluators {
    3031  [Item("CustomEvaluator", "Evaluates a custom test fuction.")]
    31   [StorableClass]
     32  [StorableType("75C946CC-11DA-4B26-9242-38EB7A40A844")]
    3233  public class CustomEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
    3334
     
    3738
    3839    [StorableConstructor]
    39     protected CustomEvaluator(bool deserializing) : base(deserializing) { }
     40    protected CustomEvaluator(StorableConstructorFlag _) : base(_) { }
    4041    protected CustomEvaluator(CustomEvaluator original, Cloner cloner) : base(original, cloner) { }
    4142    public CustomEvaluator() { }
Note: See TracChangeset for help on using the changeset viewer.