Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
05/04/17 17:19:35 (8 years ago)
Author:
gkronber
Message:

#2520: changed all usages of StorableClass to use StorableType with an auto-generated GUID (did not add StorableType to other type definitions yet)

Location:
branches/PersistenceReintegration/HeuristicLab.Persistence/3.3/Default/Xml
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • branches/PersistenceReintegration/HeuristicLab.Persistence/3.3/Default/Xml/Compact/ByteArray2XmlSerializer.cs

    r14185 r14927  
    3636  internal sealed class Bytet2DArray2XmlSerializer : ByteArray2XmlSerializer<byte[,]> { }
    3737
    38   internal sealed class Byte3DArray2XmlSerializer : ByteArray2XmlSerializer<byte[, ,]> { }
     38  internal sealed class Byte3DArray2XmlSerializer : ByteArray2XmlSerializer<byte[,,]> { }
    3939}

  • branches/PersistenceReintegration/HeuristicLab.Persistence/3.3/Default/Xml/Compact/DoubleArray2XmlSerializer.cs

    r14185 r14927  
    3939  internal sealed class Double2DArray2XmlSerializer : DoubleArray2XmlSerializerBase<double[,]> { }
    4040
    41   internal sealed class Double3DArray2XmlSerializer : DoubleArray2XmlSerializerBase<double[, ,]> { }
     41  internal sealed class Double3DArray2XmlSerializer : DoubleArray2XmlSerializerBase<double[,,]> { }
    4242
    4343}

  • branches/PersistenceReintegration/HeuristicLab.Persistence/3.3/Default/Xml/Compact/DoubleList2XmlSerializer.cs

    r14185 r14927  
    4646        }
    4747        return list;
    48       }
    49       catch (InvalidCastException e) {
     48      } catch (InvalidCastException e) {
    5049        throw new PersistenceException("Invalid element data during reconstruction of List<double>.", e);
    51       }
    52       catch (OverflowException e) {
     50      } catch (OverflowException e) {
    5351        throw new PersistenceException("Overflow during element parsing while trying to reconstruct List<double>.", e);
    5452      }

  • branches/PersistenceReintegration/HeuristicLab.Persistence/3.3/Default/Xml/Compact/IntArray2XmlSerializer.cs

    r14185 r14927  
    3838  internal class Int2DArray2XmlSerializer : IntArray2XmlSerializerBase<int[,]> { }
    3939
    40   internal class Int3DArray2XmlSerializer : IntArray2XmlSerializerBase<int[, ,]> { }
     40  internal class Int3DArray2XmlSerializer : IntArray2XmlSerializerBase<int[,,]> { }
    4141
    4242}

  • branches/PersistenceReintegration/HeuristicLab.Persistence/3.3/Default/Xml/Compact/NumberArray2XmlSerializerBase.cs

    r14185 r14927  
    2727using HeuristicLab.Persistence.Auxiliary;
    2828using HeuristicLab.Persistence.Core;
    29 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     29using HeuristicLab.Persistence;
    3030
    3131namespace HeuristicLab.Persistence.Default.Xml.Compact {
    3232
    33   [StorableClass]
     33  [StorableType("ed511bc6-4889-4be1-bb57-c819d3e9e7be")]
    3434  internal abstract class NumberArray2XmlSerializerBase<T> : CompactXmlSerializerBase<T> where T : class {
    3535
    … …  
    108108          throw new PersistenceException("Insufficient number of elements while trying to fill number array.");
    109109        return (T)(object)a;
    110       }
    111       catch (InvalidOperationException e) {
     110      } catch (InvalidOperationException e) {
    112111        throw new PersistenceException("Insufficient information to rebuild number array.", e);
    113       }
    114       catch (InvalidCastException e) {
     112      } catch (InvalidCastException e) {
    115113        throw new PersistenceException("Invalid element data or meta data to reconstruct number array.", e);
    116       }
    117       catch (OverflowException e) {
     114      } catch (OverflowException e) {
    118115        throw new PersistenceException("Overflow during element parsing while trying to reconstruct number array.", e);
    119116      }

  • branches/PersistenceReintegration/HeuristicLab.Persistence/3.3/Default/Xml/Compact/NumberEnumeration2XmlSerializerBase.cs

    r14185 r14927  
    2525using HeuristicLab.Persistence.Auxiliary;
    2626using HeuristicLab.Persistence.Core;
    27 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     27using HeuristicLab.Persistence;
    2828
    2929namespace HeuristicLab.Persistence.Default.Xml.Compact {
    3030
    31   [StorableClass]
     31  [StorableType("a0910e86-de41-4862-abf5-82bbed54de70")]
    3232  internal abstract class NumberEnumeration2XmlSerializerBase<T> : CompactXmlSerializerBase<T> where T : IEnumerable {
    3333
    … …  
    5454        }
    5555        return (T)enumeration;
    56       }
    57       catch (InvalidCastException e) {
     56      } catch (InvalidCastException e) {
    5857        throw new PersistenceException("Invalid element data during reconstruction of number enumerable.", e);
    59       }
    60       catch (OverflowException e) {
     58      } catch (OverflowException e) {
    6159        throw new PersistenceException("Overflow during element parsing while trying to reconstruct number enumerable.", e);
    6260      }

  • branches/PersistenceReintegration/HeuristicLab.Persistence/3.3/Default/Xml/EasyXmlGenerator.cs

    r14185 r14927  
    154154        File.Copy(tempfile, filename, true);
    155155        File.Delete(tempfile);
    156       }
    157       catch (Exception) {
     156      } catch (Exception) {
    158157        Logger.Warn("Exception caught, no data has been written.");
    159158        throw;
    … …  
    181180      try {
    182181        using (StreamWriter writer = new StreamWriter(stream)) {
    183           Serializer serializer = new Serializer(obj, config);
     182          var serializer = new HeuristicLab.Persistence.Core.Serializer(obj, config);
    184183          serializer.InterleaveTypeInformation = true;
    185184          ReadableXmlGenerator generator = new ReadableXmlGenerator();
    … …  
    190189          writer.Flush();
    191190        }
    192       }
    193       catch (PersistenceException) {
     191      } catch (PersistenceException) {
    194192        throw;
    195       }
    196       catch (Exception e) {
     193      } catch (Exception e) {
    197194        throw new PersistenceException("Unexpected exception during Serialization.", e);
    198195      }

  • branches/PersistenceReintegration/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/Char2XmlFormatter.cs

    r14185 r14927  
    3737
    3838    private static string ToBase64String(char c) {
    39       return string.Format("<Base64>{0}</Base64>", Convert.ToBase64String(Encoding.ASCII.GetBytes(new[] {c})));
     39      return string.Format("<Base64>{0}</Base64>", Convert.ToBase64String(Encoding.ASCII.GetBytes(new[] { c })));
    4040    }
    4141

  • branches/PersistenceReintegration/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/DateTime2XmlSerializer.cs

    r14185 r14927  
    3434      try {
    3535        return new DateTime(long.Parse(x.Data));
    36       }
    37       catch (Exception e) {
     36      } catch (Exception e) {
    3837        throw new PersistenceException("Exception caugth while trying to reconstruct DateTime object.", e);
    3938      }

  • branches/PersistenceReintegration/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/Guid2XmlSerializer.cs

    r14185 r14927  
    3636      try {
    3737        return new Guid(t.Data);
    38       }
    39       catch (FormatException x) {
     38      } catch (FormatException x) {
    4039        throw new PersistenceException("Cannot parse Guid string representation.", x);
    41       }
    42       catch (OverflowException x) {
     40      } catch (OverflowException x) {
    4341        throw new PersistenceException("Overflow during Guid parsing.", x);
    4442      }

  • branches/PersistenceReintegration/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/SimpleNumber2XmlSerializerBase.cs

    r14185 r14927  
    4444      try {
    4545        return (T)ParseMethod.Invoke(null, new[] { x.Data });
    46       }
    47       catch (Exception e) {
     46      } catch (Exception e) {
    4847        throw new PersistenceException("Could not parse simple number.", e);
    4948      }

  • branches/PersistenceReintegration/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/System.Drawing/Bitmap2XmlSerializer.cs

    r14185 r14927  
    2828  internal sealed class Bitmap2XmlSerializer : PrimitiveXmlSerializerBase<Bitmap> {
    2929
    30     public override XmlString Format(Bitmap o) {     
     30    public override XmlString Format(Bitmap o) {
    3131      MemoryStream stream = new MemoryStream();
    3232      lock (o)

  • branches/PersistenceReintegration/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/TimeSpan2XmlSerializer.cs

    r14185 r14927  
    3535      try {
    3636        return TimeSpan.Parse(t.Data);
    37       }
    38       catch (FormatException x) {
     37      } catch (FormatException x) {
    3938        throw new PersistenceException("Cannot parse TimeSpan string representation.", x);
    40       }
    41       catch (OverflowException x) {
     39      } catch (OverflowException x) {
    4240        throw new PersistenceException("Overflow during TimeSpan parsing.", x);
    4341      }

  • branches/PersistenceReintegration/HeuristicLab.Persistence/3.3/Default/Xml/XmlFormat.cs

    r14185 r14927  
    2020#endregion
    2121
    22 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     22using HeuristicLab.Persistence;
    2323using HeuristicLab.Persistence.Interfaces;
    2424
    … …  
    2929  /// or save to a file.
    3030  /// </summary>
    31   [StorableClass]
     31  [StorableType("8c79e9a6-02d6-471c-8787-43d96d61c1db")]
    3232  public class XmlFormat : FormatBase<XmlString> {
    3333    /// <summary>

  • branches/PersistenceReintegration/HeuristicLab.Persistence/3.3/Default/Xml/XmlGenerator.cs

    r14185 r14927  
    6161    }
    6262
    63     protected enum NodeType { Start, End, Inline } ;
     63    protected enum NodeType { Start, End, Inline };
    6464
    6565    protected static void AddXmlTagContent(StringBuilder sb, string name, Dictionary<string, string> attributes) {
    … …  
    256256          {"typeName", lastTypeToken.TypeName },
    257257          {"serializer", lastTypeToken.Serializer }});
    258       }
    259       finally {
     258      } finally {
    260259        lastTypeToken = null;
    261260      }
    … …  
    313312    private static void Serialize(object obj, Stream stream, Configuration config, bool includeAssemblies
    314313   , CompressionLevel compression) {
    315       Serializer serializer = new Serializer(obj, config);
     314      var serializer = new HeuristicLab.Persistence.Core.Serializer(obj, config);
    316315      Serialize(stream, includeAssemblies, compression, serializer);
    317316    }
    318317
    319     private static void Serialize(Stream stream, bool includeAssemblies, CompressionLevel compression, Serializer serializer) {
     318    private static void Serialize(Stream stream, bool includeAssemblies, CompressionLevel compression, HeuristicLab.Persistence.Core.Serializer serializer) {
    320319      try {
    321320        DateTime start = DateTime.Now;
    … …  
    360359        Logger.Info(String.Format("serialization took {0} seconds with compression level {1}",
    361360          (DateTime.Now - start).TotalSeconds, compression));
    362       }
    363       catch (Exception) {
     361      } catch (Exception) {
    364362        Logger.Warn("Exception caught, no data has been serialized.");
    365363        throw;
    … …  
    385383        File.Copy(tempfile, filename, true);
    386384        File.Delete(tempfile);
    387       }
    388       catch (Exception) {
     385      } catch (Exception) {
    389386        Logger.Warn("Exception caught, no data has been written.");
    390387        throw;
    … …  
    426423                                 CompressionType compressionType = CompressionType.GZip) {
    427424      try {
    428         Serializer serializer = new Serializer(obj, config);
     425        var serializer = new HeuristicLab.Persistence.Core.Serializer(obj, config);
    429426        if (compressionType == CompressionType.Zip) {
    430427          Serialize(obj, stream, config, includeAssemblies, CompressionLevel.Optimal);
    … …  
    432429          Serialize(stream, serializer);
    433430        }
    434       }
    435       catch (PersistenceException) {
     431      } catch (PersistenceException) {
    436432        throw;
    437       }
    438       catch (Exception e) {
     433      } catch (Exception e) {
    439434        throw new PersistenceException("Unexpected exception during Serialization.", e);
    440435      }
    … …  
    453448                                 CompressionType compressionType = CompressionType.GZip) {
    454449      try {
    455         Serializer serializer = new Serializer(obj, config);
     450        var serializer = new HeuristicLab.Persistence.Core.Serializer(obj, config);
    456451        if (compressionType == CompressionType.Zip) {
    457452          Serialize(stream, includeAssemblies, CompressionLevel.Optimal, serializer);
    … …  
    460455        }
    461456        types = serializer.SerializedTypes;
    462       }
    463       catch (PersistenceException) {
     457      } catch (PersistenceException) {
    464458        throw;
    465       }
    466       catch (Exception e) {
     459      } catch (Exception e) {
    467460        throw new PersistenceException("Unexpected exception during Serialization.", e);
    468461      }
    469462    }
    470463
    471     private static void Serialize(Stream stream, Serializer serializer) {
     464    private static void Serialize(Stream stream, HeuristicLab.Persistence.Core.Serializer serializer) {
    472465      using (StreamWriter writer = new StreamWriter(new GZipStream(stream, CompressionMode.Compress))) {
    473466        serializer.InterleaveTypeInformation = true;

  • branches/PersistenceReintegration/HeuristicLab.Persistence/3.3/Default/Xml/XmlParser.cs

    r14185 r14927  
    8181        try {
    8282          iterator = handlers[reader.Name].Invoke();
    83         }
    84         catch (KeyNotFoundException) {
     83        } catch (KeyNotFoundException) {
    8584          throw new PersistenceException(String.Format(
    8685            "Invalid XML tag \"{0}\" in persistence file.",
    … …  
    182181        }
    183182        return typeCache;
    184       }
    185       catch (PersistenceException) {
     183      } catch (PersistenceException) {
    186184        throw;
    187       }
    188       catch (Exception e) {
     185      } catch (Exception e) {
    189186        throw new PersistenceException("Unexpected exception during type cache parsing.", e);
    190187      }
    … …  
    204201          }
    205202        }
    206       }
    207       finally {
     203      } finally {
    208204        TimeSpan end = System.Diagnostics.Process.GetCurrentProcess().TotalProcessorTime;
    209205        Tracing.Logger.Info(string.Format(
    … …  
    251247            return deserializer.Deserialize(parser);
    252248          }
    253         }
    254         catch (PersistenceException) {
     249        } catch (PersistenceException) {
    255250          throw;
    256         }
    257         catch (Exception x) {
     251        } catch (Exception x) {
    258252          throw new PersistenceException("Unexpected exception during deserialization", x);
    259253        }
    … …  
    279273
    280274        return result;
    281       }
    282       catch (PersistenceException) {
     275      } catch (PersistenceException) {
    283276        throw;
    284       }
    285       catch (Exception e) {
     277      } catch (Exception e) {
    286278        throw new PersistenceException("Unexpected exception during deserialization", e);
    287279      }

  • branches/PersistenceReintegration/HeuristicLab.Persistence/3.3/Default/Xml/XmlString.cs

    r14185 r14927  
    2121
    2222using System.Text;
    23 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     23using HeuristicLab.Persistence;
    2424using HeuristicLab.Persistence.Interfaces;
    2525
    … …  
    2929  /// XML friendly encapsulation of string data.
    3030  /// </summary>
    31   [StorableClass]
     31  [StorableType("a358bb95-a494-4512-b1fe-53c66c77423c")]
    3232  public class XmlString : ISerialData {
    3333
Note: See TracChangeset for help on using the changeset viewer.