source: trunk/sources/HeuristicLab.Services.OKB.DataAccess/3.3/OKB.generated.cs @ 4381

#pragma warning disable 1591
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by LINQ to SQL template for T4 C#
//     Generated at 09/12/2010 03:47:59
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.ComponentModel;
using System.Data.Linq;
using System.Data.Linq.Mapping;
using System.Runtime.Serialization;

namespace HeuristicLab.Services.OKB.DataAccess
{
  [DatabaseAttribute(Name=@"OKB")]
  public partial class OKBDataContext : DataContext
  {
    private static MappingSource mappingSource = new AttributeMappingSource();
    
    #region Extensibility Method Definitions
    partial void OnCreated();
    partial void InsertAlgorithmClass(AlgorithmClass instance);
    partial void UpdateAlgorithmClass(AlgorithmClass instance);
    partial void DeleteAlgorithmClass(AlgorithmClass instance);
    partial void InsertAlgorithm(Algorithm instance);
    partial void UpdateAlgorithm(Algorithm instance);
    partial void DeleteAlgorithm(Algorithm instance);
    partial void InsertProblem(Problem instance);
    partial void UpdateProblem(Problem instance);
    partial void DeleteProblem(Problem instance);
    partial void InsertProblemClass(ProblemClass instance);
    partial void UpdateProblemClass(ProblemClass instance);
    partial void DeleteProblemClass(ProblemClass instance);
    partial void InsertExperiment(Experiment instance);
    partial void UpdateExperiment(Experiment instance);
    partial void DeleteExperiment(Experiment instance);
    partial void InsertAlgorithmParameter(AlgorithmParameter instance);
    partial void UpdateAlgorithmParameter(AlgorithmParameter instance);
    partial void DeleteAlgorithmParameter(AlgorithmParameter instance);
    partial void InsertProblemParameter(ProblemParameter instance);
    partial void UpdateProblemParameter(ProblemParameter instance);
    partial void DeleteProblemParameter(ProblemParameter instance);
    partial void InsertAlgorithmParameterBlobValue(AlgorithmParameterBlobValue instance);
    partial void UpdateAlgorithmParameterBlobValue(AlgorithmParameterBlobValue instance);
    partial void DeleteAlgorithmParameterBlobValue(AlgorithmParameterBlobValue instance);
    partial void InsertProblemParameterBlobValue(ProblemParameterBlobValue instance);
    partial void UpdateProblemParameterBlobValue(ProblemParameterBlobValue instance);
    partial void DeleteProblemParameterBlobValue(ProblemParameterBlobValue instance);
    partial void InsertAlgorithmParameterBoolValue(AlgorithmParameterBoolValue instance);
    partial void UpdateAlgorithmParameterBoolValue(AlgorithmParameterBoolValue instance);
    partial void DeleteAlgorithmParameterBoolValue(AlgorithmParameterBoolValue instance);
    partial void InsertAlgorithmParameterFloatValue(AlgorithmParameterFloatValue instance);
    partial void UpdateAlgorithmParameterFloatValue(AlgorithmParameterFloatValue instance);
    partial void DeleteAlgorithmParameterFloatValue(AlgorithmParameterFloatValue instance);
    partial void InsertAlgorithmParameterIntValue(AlgorithmParameterIntValue instance);
    partial void UpdateAlgorithmParameterIntValue(AlgorithmParameterIntValue instance);
    partial void DeleteAlgorithmParameterIntValue(AlgorithmParameterIntValue instance);
    partial void InsertAlgorithmParameterStringValue(AlgorithmParameterStringValue instance);
    partial void UpdateAlgorithmParameterStringValue(AlgorithmParameterStringValue instance);
    partial void DeleteAlgorithmParameterStringValue(AlgorithmParameterStringValue instance);
    partial void InsertProblemParameterBoolValue(ProblemParameterBoolValue instance);
    partial void UpdateProblemParameterBoolValue(ProblemParameterBoolValue instance);
    partial void DeleteProblemParameterBoolValue(ProblemParameterBoolValue instance);
    partial void InsertProblemParameterFloatValue(ProblemParameterFloatValue instance);
    partial void UpdateProblemParameterFloatValue(ProblemParameterFloatValue instance);
    partial void DeleteProblemParameterFloatValue(ProblemParameterFloatValue instance);
    partial void InsertProblemParameterIntValue(ProblemParameterIntValue instance);
    partial void UpdateProblemParameterIntValue(ProblemParameterIntValue instance);
    partial void DeleteProblemParameterIntValue(ProblemParameterIntValue instance);
    partial void InsertProblemParameterStringValue(ProblemParameterStringValue instance);
    partial void UpdateProblemParameterStringValue(ProblemParameterStringValue instance);
    partial void DeleteProblemParameterStringValue(ProblemParameterStringValue instance);
    partial void InsertAlgorithmData(AlgorithmData instance);
    partial void UpdateAlgorithmData(AlgorithmData instance);
    partial void DeleteAlgorithmData(AlgorithmData instance);
    partial void InsertUser(User instance);
    partial void UpdateUser(User instance);
    partial void DeleteUser(User instance);
    partial void InsertProblemData(ProblemData instance);
    partial void UpdateProblemData(ProblemData instance);
    partial void DeleteProblemData(ProblemData instance);
    partial void InsertAlgorithmUser(AlgorithmUser instance);
    partial void UpdateAlgorithmUser(AlgorithmUser instance);
    partial void DeleteAlgorithmUser(AlgorithmUser instance);
    partial void InsertProblemUser(ProblemUser instance);
    partial void UpdateProblemUser(ProblemUser instance);
    partial void DeleteProblemUser(ProblemUser instance);
    partial void InsertPlatform(Platform instance);
    partial void UpdatePlatform(Platform instance);
    partial void DeletePlatform(Platform instance);
    partial void InsertSolutionRepresentation(SolutionRepresentation instance);
    partial void UpdateSolutionRepresentation(SolutionRepresentation instance);
    partial void DeleteSolutionRepresentation(SolutionRepresentation instance);
    partial void InsertRun(Run instance);
    partial void UpdateRun(Run instance);
    partial void DeleteRun(Run instance);
    partial void InsertResult(Result instance);
    partial void UpdateResult(Result instance);
    partial void DeleteResult(Result instance);
    partial void InsertResultBlobValue(ResultBlobValue instance);
    partial void UpdateResultBlobValue(ResultBlobValue instance);
    partial void DeleteResultBlobValue(ResultBlobValue instance);
    partial void InsertResultBoolValue(ResultBoolValue instance);
    partial void UpdateResultBoolValue(ResultBoolValue instance);
    partial void DeleteResultBoolValue(ResultBoolValue instance);
    partial void InsertResultFloatValue(ResultFloatValue instance);
    partial void UpdateResultFloatValue(ResultFloatValue instance);
    partial void DeleteResultFloatValue(ResultFloatValue instance);
    partial void InsertResultIntValue(ResultIntValue instance);
    partial void UpdateResultIntValue(ResultIntValue instance);
    partial void DeleteResultIntValue(ResultIntValue instance);
    partial void InsertResultStringValue(ResultStringValue instance);
    partial void UpdateResultStringValue(ResultStringValue instance);
    partial void DeleteResultStringValue(ResultStringValue instance);
    partial void InsertClient(Client instance);
    partial void UpdateClient(Client instance);
    partial void DeleteClient(Client instance);
    partial void InsertDataType(DataType instance);
    partial void UpdateDataType(DataType instance);
    partial void DeleteDataType(DataType instance);
    partial void InsertProblemCharacteristic(ProblemCharacteristic instance);
    partial void UpdateProblemCharacteristic(ProblemCharacteristic instance);
    partial void DeleteProblemCharacteristic(ProblemCharacteristic instance);
    partial void InsertProblemCharacteristicFloatValue(ProblemCharacteristicFloatValue instance);
    partial void UpdateProblemCharacteristicFloatValue(ProblemCharacteristicFloatValue instance);
    partial void DeleteProblemCharacteristicFloatValue(ProblemCharacteristicFloatValue instance);
    partial void InsertProblemCharacteristicIntValue(ProblemCharacteristicIntValue instance);
    partial void UpdateProblemCharacteristicIntValue(ProblemCharacteristicIntValue instance);
    partial void DeleteProblemCharacteristicIntValue(ProblemCharacteristicIntValue instance);
    partial void InsertProblemCharacteristicStringValue(ProblemCharacteristicStringValue instance);
    partial void UpdateProblemCharacteristicStringValue(ProblemCharacteristicStringValue instance);
    partial void DeleteProblemCharacteristicStringValue(ProblemCharacteristicStringValue instance);
    #endregion
    
    #region Construction
    public OKBDataContext() :
      base(global::HeuristicLab.Services.OKB.DataAccess.Properties.Settings.Default.OKBConnectionString, mappingSource)
    {
      OnCreated();
    }
  
    public OKBDataContext(string connection) :
      base(connection, mappingSource)
    {
      OnCreated();
    }
    
    public OKBDataContext(System.Data.IDbConnection connection) :
      base(connection, mappingSource)
    {
      OnCreated();
    }
    
    public OKBDataContext(string connection, MappingSource mappingSource) :
      base(connection, mappingSource)
    {
      OnCreated();
    }
    
    public OKBDataContext(System.Data.IDbConnection connection, MappingSource mappingSource) :
      base(connection, mappingSource)
    {
      OnCreated();
    }
    #endregion
    
    #region Tables
    public Table<AlgorithmClass> AlgorithmClasses
    {
      get { return GetTable<AlgorithmClass>(); }
    }
    
    public Table<Algorithm> Algorithms
    {
      get { return GetTable<Algorithm>(); }
    }
    
    public Table<Problem> Problems
    {
      get { return GetTable<Problem>(); }
    }
    
    public Table<ProblemClass> ProblemClasses
    {
      get { return GetTable<ProblemClass>(); }
    }
    
    public Table<Experiment> Experiments
    {
      get { return GetTable<Experiment>(); }
    }
    
    public Table<AlgorithmParameter> AlgorithmParameters
    {
      get { return GetTable<AlgorithmParameter>(); }
    }
    
    public Table<ProblemParameter> ProblemParameters
    {
      get { return GetTable<ProblemParameter>(); }
    }
    
    public Table<AlgorithmParameterBlobValue> AlgorithmParameterBlobValues
    {
      get { return GetTable<AlgorithmParameterBlobValue>(); }
    }
    
    public Table<ProblemParameterBlobValue> ProblemParameterBlobValues
    {
      get { return GetTable<ProblemParameterBlobValue>(); }
    }
    
    public Table<AlgorithmParameterBoolValue> AlgorithmParameterBoolValues
    {
      get { return GetTable<AlgorithmParameterBoolValue>(); }
    }
    
    public Table<AlgorithmParameterFloatValue> AlgorithmParameterFloatValues
    {
      get { return GetTable<AlgorithmParameterFloatValue>(); }
    }
    
    public Table<AlgorithmParameterIntValue> AlgorithmParameterIntValues
    {
      get { return GetTable<AlgorithmParameterIntValue>(); }
    }
    
    public Table<AlgorithmParameterStringValue> AlgorithmParameterStringValues
    {
      get { return GetTable<AlgorithmParameterStringValue>(); }
    }
    
    public Table<ProblemParameterBoolValue> ProblemParameterBoolValues
    {
      get { return GetTable<ProblemParameterBoolValue>(); }
    }
    
    public Table<ProblemParameterFloatValue> ProblemParameterFloatValues
    {
      get { return GetTable<ProblemParameterFloatValue>(); }
    }
    
    public Table<ProblemParameterIntValue> ProblemParameterIntValues
    {
      get { return GetTable<ProblemParameterIntValue>(); }
    }
    
    public Table<ProblemParameterStringValue> ProblemParameterStringValues
    {
      get { return GetTable<ProblemParameterStringValue>(); }
    }
    
    public Table<AlgorithmData> AlgorithmDatas
    {
      get { return GetTable<AlgorithmData>(); }
    }
    
    public Table<User> Users
    {
      get { return GetTable<User>(); }
    }
    
    public Table<ProblemData> ProblemDatas
    {
      get { return GetTable<ProblemData>(); }
    }
    
    public Table<AlgorithmUser> AlgorithmUsers
    {
      get { return GetTable<AlgorithmUser>(); }
    }
    
    public Table<ProblemUser> ProblemUsers
    {
      get { return GetTable<ProblemUser>(); }
    }
    
    public Table<Platform> Platforms
    {
      get { return GetTable<Platform>(); }
    }
    
    public Table<SolutionRepresentation> SolutionRepresentations
    {
      get { return GetTable<SolutionRepresentation>(); }
    }
    
    public Table<Run> Runs
    {
      get { return GetTable<Run>(); }
    }
    
    public Table<Result> Results
    {
      get { return GetTable<Result>(); }
    }
    
    public Table<ResultBlobValue> ResultBlobValues
    {
      get { return GetTable<ResultBlobValue>(); }
    }
    
    public Table<ResultBoolValue> ResultBoolValues
    {
      get { return GetTable<ResultBoolValue>(); }
    }
    
    public Table<ResultFloatValue> ResultFloatValues
    {
      get { return GetTable<ResultFloatValue>(); }
    }
    
    public Table<ResultIntValue> ResultIntValues
    {
      get { return GetTable<ResultIntValue>(); }
    }
    
    public Table<ResultStringValue> ResultStringValues
    {
      get { return GetTable<ResultStringValue>(); }
    }
    
    public Table<Client> Clients
    {
      get { return GetTable<Client>(); }
    }
    
    public Table<DataType> DataTypes
    {
      get { return GetTable<DataType>(); }
    }
    
    public Table<ProblemCharacteristic> ProblemCharacteristics
    {
      get { return GetTable<ProblemCharacteristic>(); }
    }
    
    public Table<ProblemCharacteristicFloatValue> ProblemCharacteristicFloatValues
    {
      get { return GetTable<ProblemCharacteristicFloatValue>(); }
    }
    
    public Table<ProblemCharacteristicIntValue> ProblemCharacteristicIntValues
    {
      get { return GetTable<ProblemCharacteristicIntValue>(); }
    }
    
    public Table<ProblemCharacteristicStringValue> ProblemCharacteristicStringValues
    {
      get { return GetTable<ProblemCharacteristicStringValue>(); }
    }
    
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.AlgorithmClass")]
[KnownType(typeof(AlgorithmClass))] public partial class AlgorithmClass : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public AlgorithmClass()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Algorithms = new EntitySet<Algorithm>(attach_Algorithms, detach_Algorithms);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnIdChanging(long value);
    partial void OnIdChanged();
    private long _Id;
    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long Id
    {
      get { return _Id; }
      set {
        if (_Id != value) {
          OnIdChanging(value);
          SendPropertyChanging();
          _Id = value;
          SendPropertyChanged("Id");
          OnIdChanged();
        }
      }
    }
    
    partial void OnNameChanging(string value);
    partial void OnNameChanged();
    private string _Name;
    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
    [DataMember(Order=2)]
    public string Name
    {
      get { return _Name; }
      set {
        if (_Name != value) {
          OnNameChanging(value);
          SendPropertyChanging();
          _Name = value;
          SendPropertyChanged("Name");
          OnNameChanged();
        }
      }
    }
    
    partial void OnDescriptionChanging(string value);
    partial void OnDescriptionChanged();
    private string _Description;
    [Column(Storage=@"_Description", DbType=@"NVarChar(MAX)")]
    [DataMember(Order=3)]
    public string Description
    {
      get { return _Description; }
      set {
        if (_Description != value) {
          OnDescriptionChanging(value);
          SendPropertyChanging();
          _Description = value;
          SendPropertyChanged("Description");
          OnDescriptionChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntitySet<Algorithm> _Algorithms;
    [Association(Name=@"AlgorithmClass_Algorithm", Storage=@"_Algorithms", ThisKey=@"Id", OtherKey=@"AlgorithmClassId")]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public EntitySet<Algorithm> Algorithms
    {
      get {
        if (serializing && !_Algorithms.HasLoadedOrAssignedValues) {
          return null;
        }
        return _Algorithms;
      }
      set {
        _Algorithms.Assign(value);
      }
    }

    private void attach_Algorithms(Algorithm entity)
    {
      SendPropertyChanging();
      entity.AlgorithmClass = this;
    }
    
    private void detach_Algorithms(Algorithm entity)
    {
      SendPropertyChanging();
      entity.AlgorithmClass = null;
    }
    #endregion
    
    #region Serialization
    private bool serializing;
    
    [OnSerializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerializing(StreamingContext context)
    {
      serializing = true;
    }
    
    [OnSerialized()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerialized(StreamingContext context)
    {
      serializing = false;
    }
    
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.Algorithm")]
[KnownType(typeof(Algorithm))]  public partial class Algorithm : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public Algorithm()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Experiments = new EntitySet<Experiment>(attach_Experiments, detach_Experiments);
      _AlgorithmParameters = new EntitySet<AlgorithmParameter>(attach_AlgorithmParameters, detach_AlgorithmParameters);
      _AlgorithmData = default(EntityRef<AlgorithmData>);
      _AlgorithmUsers = new EntitySet<AlgorithmUser>(attach_AlgorithmUsers, detach_AlgorithmUsers);
      _Results = new EntitySet<Result>(attach_Results, detach_Results);
      _AlgorithmClass = default(EntityRef<AlgorithmClass>);
      _Platform = default(EntityRef<Platform>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnIdChanging(long value);
    partial void OnIdChanged();
    private long _Id;
    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long Id
    {
      get { return _Id; }
      set {
        if (_Id != value) {
          OnIdChanging(value);
          SendPropertyChanging();
          _Id = value;
          SendPropertyChanged("Id");
          OnIdChanged();
        }
      }
    }
    
    partial void OnAlgorithmClassIdChanging(long value);
    partial void OnAlgorithmClassIdChanged();
    private long _AlgorithmClassId;
    [Column(Storage=@"_AlgorithmClassId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
    [DataMember(Order=2)]
    public long AlgorithmClassId
    {
      get { return _AlgorithmClassId; }
      set {
        if (_AlgorithmClassId != value) {
          if (_AlgorithmClass.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnAlgorithmClassIdChanging(value);
          SendPropertyChanging();
          _AlgorithmClassId = value;
          SendPropertyChanged("AlgorithmClassId");
          OnAlgorithmClassIdChanged();
        }
      }
    }
    
    partial void OnPlatformIdChanging(long value);
    partial void OnPlatformIdChanged();
    private long _PlatformId;
    [Column(Storage=@"_PlatformId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public long PlatformId
    {
      get { return _PlatformId; }
      set {
        if (_PlatformId != value) {
          if (_Platform.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnPlatformIdChanging(value);
          SendPropertyChanging();
          _PlatformId = value;
          SendPropertyChanged("PlatformId");
          OnPlatformIdChanged();
        }
      }
    }
    
    partial void OnNameChanging(string value);
    partial void OnNameChanged();
    private string _Name;
    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
    [DataMember(Order=4)]
    public string Name
    {
      get { return _Name; }
      set {
        if (_Name != value) {
          OnNameChanging(value);
          SendPropertyChanging();
          _Name = value;
          SendPropertyChanged("Name");
          OnNameChanged();
        }
      }
    }
    
    partial void OnDescriptionChanging(string value);
    partial void OnDescriptionChanged();
    private string _Description;
    [Column(Storage=@"_Description", DbType=@"NVarChar(MAX)")]
    [DataMember(Order=5)]
    public string Description
    {
      get { return _Description; }
      set {
        if (_Description != value) {
          OnDescriptionChanging(value);
          SendPropertyChanging();
          _Description = value;
          SendPropertyChanged("Description");
          OnDescriptionChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntitySet<Experiment> _Experiments;
    [Association(Name=@"Algorithm_Experiment", Storage=@"_Experiments", ThisKey=@"Id", OtherKey=@"AlgorithmId")]
    [DataMember(Order=6, EmitDefaultValue=false)]
    public EntitySet<Experiment> Experiments
    {
      get {
        if (serializing && !_Experiments.HasLoadedOrAssignedValues) {
          return null;
        }
        return _Experiments;
      }
      set {
        _Experiments.Assign(value);
      }
    }

    private void attach_Experiments(Experiment entity)
    {
      SendPropertyChanging();
      entity.Algorithm = this;
    }
    
    private void detach_Experiments(Experiment entity)
    {
      SendPropertyChanging();
      entity.Algorithm = null;
    }
    private EntitySet<AlgorithmParameter> _AlgorithmParameters;
    [Association(Name=@"Algorithm_AlgorithmParameter", Storage=@"_AlgorithmParameters", ThisKey=@"Id", OtherKey=@"AlgorithmId")]
    [DataMember(Order=7, EmitDefaultValue=false)]
    public EntitySet<AlgorithmParameter> AlgorithmParameters
    {
      get {
        if (serializing && !_AlgorithmParameters.HasLoadedOrAssignedValues) {
          return null;
        }
        return _AlgorithmParameters;
      }
      set {
        _AlgorithmParameters.Assign(value);
      }
    }

    private void attach_AlgorithmParameters(AlgorithmParameter entity)
    {
      SendPropertyChanging();
      entity.Algorithm = this;
    }
    
    private void detach_AlgorithmParameters(AlgorithmParameter entity)
    {
      SendPropertyChanging();
      entity.Algorithm = null;
    }
    private EntityRef<AlgorithmData> _AlgorithmData;
    [Association(Name=@"Algorithm_AlgorithmData", Storage=@"_AlgorithmData", ThisKey=@"Id", OtherKey=@"AlgorithmId", IsUnique=true, IsForeignKey=false)]
    [DataMember(Order=8, EmitDefaultValue=false)]
    public AlgorithmData AlgorithmData
    {
      get {
        if (serializing && !_AlgorithmData.HasLoadedOrAssignedValue) {
          return null;
        }
        return _AlgorithmData.Entity;
      }
      set {
        AlgorithmData previousValue = _AlgorithmData.Entity;
        if ((previousValue != value) || (!_AlgorithmData.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _AlgorithmData.Entity = null;
            previousValue.Algorithm = null;
          }
          _AlgorithmData.Entity = value;
          if (value != null) {
            value.Algorithm = this;
          }
          SendPropertyChanged("AlgorithmData");
        }
      }
    }

    private EntitySet<AlgorithmUser> _AlgorithmUsers;
    [Association(Name=@"Algorithm_AlgorithmUser", Storage=@"_AlgorithmUsers", ThisKey=@"Id", OtherKey=@"AlgorithmId")]
    [DataMember(Order=9, EmitDefaultValue=false)]
    public EntitySet<AlgorithmUser> AlgorithmUsers
    {
      get {
        if (serializing && !_AlgorithmUsers.HasLoadedOrAssignedValues) {
          return null;
        }
        return _AlgorithmUsers;
      }
      set {
        _AlgorithmUsers.Assign(value);
      }
    }

    private void attach_AlgorithmUsers(AlgorithmUser entity)
    {
      SendPropertyChanging();
      entity.Algorithm = this;
    }
    
    private void detach_AlgorithmUsers(AlgorithmUser entity)
    {
      SendPropertyChanging();
      entity.Algorithm = null;
    }
    private EntitySet<Result> _Results;
    [Association(Name=@"Algorithm_Result", Storage=@"_Results", ThisKey=@"Id", OtherKey=@"AlgorithmId")]
    [DataMember(Order=10, EmitDefaultValue=false)]
    public EntitySet<Result> Results
    {
      get {
        if (serializing && !_Results.HasLoadedOrAssignedValues) {
          return null;
        }
        return _Results;
      }
      set {
        _Results.Assign(value);
      }
    }

    private void attach_Results(Result entity)
    {
      SendPropertyChanging();
      entity.Algorithm = this;
    }
    
    private void detach_Results(Result entity)
    {
      SendPropertyChanging();
      entity.Algorithm = null;
    }
    private EntityRef<AlgorithmClass> _AlgorithmClass;
    [Association(Name=@"AlgorithmClass_Algorithm", Storage=@"_AlgorithmClass", ThisKey=@"AlgorithmClassId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=11, EmitDefaultValue=false)]
    public AlgorithmClass AlgorithmClass
    {
      get {
        if (serializing && !_AlgorithmClass.HasLoadedOrAssignedValue) {
          return null;
        }
        return _AlgorithmClass.Entity;
      }
      set {
        AlgorithmClass previousValue = _AlgorithmClass.Entity;
        if ((previousValue != value) || (!_AlgorithmClass.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _AlgorithmClass.Entity = null;
            previousValue.Algorithms.Remove(this);
          }
          _AlgorithmClass.Entity = value;
          if (value != null) {
            value.Algorithms.Add(this);
            _AlgorithmClassId = value.Id;
          }
          else {
            _AlgorithmClassId = default(long);
          }
          SendPropertyChanged("AlgorithmClass");
        }
      }
    }

    private EntityRef<Platform> _Platform;
    [Association(Name=@"Platform_Algorithm", Storage=@"_Platform", ThisKey=@"PlatformId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=12, EmitDefaultValue=false)]
    public Platform Platform
    {
      get {
        if (serializing && !_Platform.HasLoadedOrAssignedValue) {
          return null;
        }
        return _Platform.Entity;
      }
      set {
        Platform previousValue = _Platform.Entity;
        if ((previousValue != value) || (!_Platform.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Platform.Entity = null;
            previousValue.Algorithms.Remove(this);
          }
          _Platform.Entity = value;
          if (value != null) {
            value.Algorithms.Add(this);
            _PlatformId = value.Id;
          }
          else {
            _PlatformId = default(long);
          }
          SendPropertyChanged("Platform");
        }
      }
    }

    #endregion
    
    #region Serialization
    private bool serializing;
    
    [OnSerializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerializing(StreamingContext context)
    {
      serializing = true;
    }
    
    [OnSerialized()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerialized(StreamingContext context)
    {
      serializing = false;
    }
    
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.Problem")]
[KnownType(typeof(Problem))]  public partial class Problem : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public Problem()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Experiments = new EntitySet<Experiment>(attach_Experiments, detach_Experiments);
      _ProblemParameters = new EntitySet<ProblemParameter>(attach_ProblemParameters, detach_ProblemParameters);
      _ProblemData = default(EntityRef<ProblemData>);
      _ProblemUsers = new EntitySet<ProblemUser>(attach_ProblemUsers, detach_ProblemUsers);
      _ProblemCharacteristicFloatValues = new EntitySet<ProblemCharacteristicFloatValue>(attach_ProblemCharacteristicFloatValues, detach_ProblemCharacteristicFloatValues);
      _ProblemCharacteristicIntValues = new EntitySet<ProblemCharacteristicIntValue>(attach_ProblemCharacteristicIntValues, detach_ProblemCharacteristicIntValues);
      _ProblemCharacteristicStringValues = new EntitySet<ProblemCharacteristicStringValue>(attach_ProblemCharacteristicStringValues, detach_ProblemCharacteristicStringValues);
      _ProblemClass = default(EntityRef<ProblemClass>);
      _Platform = default(EntityRef<Platform>);
      _SolutionRepresentation = default(EntityRef<SolutionRepresentation>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnIdChanging(long value);
    partial void OnIdChanged();
    private long _Id;
    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long Id
    {
      get { return _Id; }
      set {
        if (_Id != value) {
          OnIdChanging(value);
          SendPropertyChanging();
          _Id = value;
          SendPropertyChanged("Id");
          OnIdChanged();
        }
      }
    }
    
    partial void OnProblemClassIdChanging(long value);
    partial void OnProblemClassIdChanged();
    private long _ProblemClassId;
    [Column(Storage=@"_ProblemClassId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
    [DataMember(Order=2)]
    public long ProblemClassId
    {
      get { return _ProblemClassId; }
      set {
        if (_ProblemClassId != value) {
          if (_ProblemClass.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnProblemClassIdChanging(value);
          SendPropertyChanging();
          _ProblemClassId = value;
          SendPropertyChanged("ProblemClassId");
          OnProblemClassIdChanged();
        }
      }
    }
    
    partial void OnPlatformIdChanging(long value);
    partial void OnPlatformIdChanged();
    private long _PlatformId;
    [Column(Storage=@"_PlatformId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public long PlatformId
    {
      get { return _PlatformId; }
      set {
        if (_PlatformId != value) {
          if (_Platform.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnPlatformIdChanging(value);
          SendPropertyChanging();
          _PlatformId = value;
          SendPropertyChanged("PlatformId");
          OnPlatformIdChanged();
        }
      }
    }
    
    partial void OnSolutionRepresentationIdChanging(long value);
    partial void OnSolutionRepresentationIdChanged();
    private long _SolutionRepresentationid;
    [Column(Storage=@"_SolutionRepresentationid", DbType=@"BigInt NOT NULL", CanBeNull=false)]
    [DataMember(Order=4)]
    public long SolutionRepresentationId
    {
      get { return _SolutionRepresentationid; }
      set {
        if (_SolutionRepresentationid != value) {
          if (_SolutionRepresentation.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnSolutionRepresentationIdChanging(value);
          SendPropertyChanging();
          _SolutionRepresentationid = value;
          SendPropertyChanged("SolutionRepresentationId");
          OnSolutionRepresentationIdChanged();
        }
      }
    }
    
    partial void OnNameChanging(string value);
    partial void OnNameChanged();
    private string _Name;
    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
    [DataMember(Order=5)]
    public string Name
    {
      get { return _Name; }
      set {
        if (_Name != value) {
          OnNameChanging(value);
          SendPropertyChanging();
          _Name = value;
          SendPropertyChanged("Name");
          OnNameChanged();
        }
      }
    }
    
    partial void OnDescriptionChanging(string value);
    partial void OnDescriptionChanged();
    private string _Description;
    [Column(Storage=@"_Description", DbType=@"NVarChar(MAX)")]
    [DataMember(Order=6)]
    public string Description
    {
      get { return _Description; }
      set {
        if (_Description != value) {
          OnDescriptionChanging(value);
          SendPropertyChanging();
          _Description = value;
          SendPropertyChanged("Description");
          OnDescriptionChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntitySet<Experiment> _Experiments;
    [Association(Name=@"Problem_Experiment", Storage=@"_Experiments", ThisKey=@"Id", OtherKey=@"ProblemId")]
    [DataMember(Order=7, EmitDefaultValue=false)]
    public EntitySet<Experiment> Experiments
    {
      get {
        if (serializing && !_Experiments.HasLoadedOrAssignedValues) {
          return null;
        }
        return _Experiments;
      }
      set {
        _Experiments.Assign(value);
      }
    }

    private void attach_Experiments(Experiment entity)
    {
      SendPropertyChanging();
      entity.Problem = this;
    }
    
    private void detach_Experiments(Experiment entity)
    {
      SendPropertyChanging();
      entity.Problem = null;
    }
    private EntitySet<ProblemParameter> _ProblemParameters;
    [Association(Name=@"Problem_ProblemParameter", Storage=@"_ProblemParameters", ThisKey=@"Id", OtherKey=@"ProblemId")]
    [DataMember(Order=8, EmitDefaultValue=false)]
    public EntitySet<ProblemParameter> ProblemParameters
    {
      get {
        if (serializing && !_ProblemParameters.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemParameters;
      }
      set {
        _ProblemParameters.Assign(value);
      }
    }

    private void attach_ProblemParameters(ProblemParameter entity)
    {
      SendPropertyChanging();
      entity.Problem = this;
    }
    
    private void detach_ProblemParameters(ProblemParameter entity)
    {
      SendPropertyChanging();
      entity.Problem = null;
    }
    private EntityRef<ProblemData> _ProblemData;
    [Association(Name=@"Problem_ProblemData", Storage=@"_ProblemData", ThisKey=@"Id", OtherKey=@"ProblemId", IsUnique=true, IsForeignKey=false)]
    [DataMember(Order=9, EmitDefaultValue=false)]
    public ProblemData ProblemData
    {
      get {
        if (serializing && !_ProblemData.HasLoadedOrAssignedValue) {
          return null;
        }
        return _ProblemData.Entity;
      }
      set {
        ProblemData previousValue = _ProblemData.Entity;
        if ((previousValue != value) || (!_ProblemData.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _ProblemData.Entity = null;
            previousValue.Problem = null;
          }
          _ProblemData.Entity = value;
          if (value != null) {
            value.Problem = this;
          }
          SendPropertyChanged("ProblemData");
        }
      }
    }

    private EntitySet<ProblemUser> _ProblemUsers;
    [Association(Name=@"Problem_ProblemUser", Storage=@"_ProblemUsers", ThisKey=@"Id", OtherKey=@"ProblemId")]
    [DataMember(Order=10, EmitDefaultValue=false)]
    public EntitySet<ProblemUser> ProblemUsers
    {
      get {
        if (serializing && !_ProblemUsers.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemUsers;
      }
      set {
        _ProblemUsers.Assign(value);
      }
    }

    private void attach_ProblemUsers(ProblemUser entity)
    {
      SendPropertyChanging();
      entity.Problem = this;
    }
    
    private void detach_ProblemUsers(ProblemUser entity)
    {
      SendPropertyChanging();
      entity.Problem = null;
    }
    private EntitySet<ProblemCharacteristicFloatValue> _ProblemCharacteristicFloatValues;
    [Association(Name=@"Problem_ProblemCharacteristicFloatValue", Storage=@"_ProblemCharacteristicFloatValues", ThisKey=@"Id", OtherKey=@"ProblemId")]
    [DataMember(Order=11, EmitDefaultValue=false)]
    public EntitySet<ProblemCharacteristicFloatValue> ProblemCharacteristicFloatValues
    {
      get {
        if (serializing && !_ProblemCharacteristicFloatValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemCharacteristicFloatValues;
      }
      set {
        _ProblemCharacteristicFloatValues.Assign(value);
      }
    }

    private void attach_ProblemCharacteristicFloatValues(ProblemCharacteristicFloatValue entity)
    {
      SendPropertyChanging();
      entity.Problem = this;
    }
    
    private void detach_ProblemCharacteristicFloatValues(ProblemCharacteristicFloatValue entity)
    {
      SendPropertyChanging();
      entity.Problem = null;
    }
    private EntitySet<ProblemCharacteristicIntValue> _ProblemCharacteristicIntValues;
    [Association(Name=@"Problem_ProblemCharacteristicIntValue", Storage=@"_ProblemCharacteristicIntValues", ThisKey=@"Id", OtherKey=@"ProblemId")]
    [DataMember(Order=12, EmitDefaultValue=false)]
    public EntitySet<ProblemCharacteristicIntValue> ProblemCharacteristicIntValues
    {
      get {
        if (serializing && !_ProblemCharacteristicIntValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemCharacteristicIntValues;
      }
      set {
        _ProblemCharacteristicIntValues.Assign(value);
      }
    }

    private void attach_ProblemCharacteristicIntValues(ProblemCharacteristicIntValue entity)
    {
      SendPropertyChanging();
      entity.Problem = this;
    }
    
    private void detach_ProblemCharacteristicIntValues(ProblemCharacteristicIntValue entity)
    {
      SendPropertyChanging();
      entity.Problem = null;
    }
    private EntitySet<ProblemCharacteristicStringValue> _ProblemCharacteristicStringValues;
    [Association(Name=@"Problem_ProblemCharacteristicStringValue", Storage=@"_ProblemCharacteristicStringValues", ThisKey=@"Id", OtherKey=@"ProblemId")]
    [DataMember(Order=13, EmitDefaultValue=false)]
    public EntitySet<ProblemCharacteristicStringValue> ProblemCharacteristicStringValues
    {
      get {
        if (serializing && !_ProblemCharacteristicStringValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemCharacteristicStringValues;
      }
      set {
        _ProblemCharacteristicStringValues.Assign(value);
      }
    }

    private void attach_ProblemCharacteristicStringValues(ProblemCharacteristicStringValue entity)
    {
      SendPropertyChanging();
      entity.Problem = this;
    }
    
    private void detach_ProblemCharacteristicStringValues(ProblemCharacteristicStringValue entity)
    {
      SendPropertyChanging();
      entity.Problem = null;
    }
    private EntityRef<ProblemClass> _ProblemClass;
    [Association(Name=@"ProblemClass_Problem", Storage=@"_ProblemClass", ThisKey=@"ProblemClassId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=14, EmitDefaultValue=false)]
    public ProblemClass ProblemClass
    {
      get {
        if (serializing && !_ProblemClass.HasLoadedOrAssignedValue) {
          return null;
        }
        return _ProblemClass.Entity;
      }
      set {
        ProblemClass previousValue = _ProblemClass.Entity;
        if ((previousValue != value) || (!_ProblemClass.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _ProblemClass.Entity = null;
            previousValue.Problems.Remove(this);
          }
          _ProblemClass.Entity = value;
          if (value != null) {
            value.Problems.Add(this);
            _ProblemClassId = value.Id;
          }
          else {
            _ProblemClassId = default(long);
          }
          SendPropertyChanged("ProblemClass");
        }
      }
    }

    private EntityRef<Platform> _Platform;
    [Association(Name=@"Platform_Problem", Storage=@"_Platform", ThisKey=@"PlatformId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=15, EmitDefaultValue=false)]
    public Platform Platform
    {
      get {
        if (serializing && !_Platform.HasLoadedOrAssignedValue) {
          return null;
        }
        return _Platform.Entity;
      }
      set {
        Platform previousValue = _Platform.Entity;
        if ((previousValue != value) || (!_Platform.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Platform.Entity = null;
            previousValue.Problems.Remove(this);
          }
          _Platform.Entity = value;
          if (value != null) {
            value.Problems.Add(this);
            _PlatformId = value.Id;
          }
          else {
            _PlatformId = default(long);
          }
          SendPropertyChanged("Platform");
        }
      }
    }

    private EntityRef<SolutionRepresentation> _SolutionRepresentation;
    [Association(Name=@"SolutionRepresentation_Problem", Storage=@"_SolutionRepresentation", ThisKey=@"SolutionRepresentationId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=16, EmitDefaultValue=false)]
    public SolutionRepresentation SolutionRepresentation
    {
      get {
        if (serializing && !_SolutionRepresentation.HasLoadedOrAssignedValue) {
          return null;
        }
        return _SolutionRepresentation.Entity;
      }
      set {
        SolutionRepresentation previousValue = _SolutionRepresentation.Entity;
        if ((previousValue != value) || (!_SolutionRepresentation.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _SolutionRepresentation.Entity = null;
            previousValue.Problems.Remove(this);
          }
          _SolutionRepresentation.Entity = value;
          if (value != null) {
            value.Problems.Add(this);
            _SolutionRepresentationid = value.Id;
          }
          else {
            _SolutionRepresentationid = default(long);
          }
          SendPropertyChanged("SolutionRepresentation");
        }
      }
    }

    #endregion
    
    #region Serialization
    private bool serializing;
    
    [OnSerializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerializing(StreamingContext context)
    {
      serializing = true;
    }
    
    [OnSerialized()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerialized(StreamingContext context)
    {
      serializing = false;
    }
    
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.ProblemClass")]
[KnownType(typeof(ProblemClass))] public partial class ProblemClass : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public ProblemClass()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Problems = new EntitySet<Problem>(attach_Problems, detach_Problems);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnIdChanging(long value);
    partial void OnIdChanged();
    private long _Id;
    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long Id
    {
      get { return _Id; }
      set {
        if (_Id != value) {
          OnIdChanging(value);
          SendPropertyChanging();
          _Id = value;
          SendPropertyChanged("Id");
          OnIdChanged();
        }
      }
    }
    
    partial void OnNameChanging(string value);
    partial void OnNameChanged();
    private string _Name;
    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
    [DataMember(Order=2)]
    public string Name
    {
      get { return _Name; }
      set {
        if (_Name != value) {
          OnNameChanging(value);
          SendPropertyChanging();
          _Name = value;
          SendPropertyChanged("Name");
          OnNameChanged();
        }
      }
    }
    
    partial void OnDescriptionChanging(string value);
    partial void OnDescriptionChanged();
    private string _Description;
    [Column(Storage=@"_Description", DbType=@"NVarChar(MAX)")]
    [DataMember(Order=3)]
    public string Description
    {
      get { return _Description; }
      set {
        if (_Description != value) {
          OnDescriptionChanging(value);
          SendPropertyChanging();
          _Description = value;
          SendPropertyChanged("Description");
          OnDescriptionChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntitySet<Problem> _Problems;
    [Association(Name=@"ProblemClass_Problem", Storage=@"_Problems", ThisKey=@"Id", OtherKey=@"ProblemClassId")]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public EntitySet<Problem> Problems
    {
      get {
        if (serializing && !_Problems.HasLoadedOrAssignedValues) {
          return null;
        }
        return _Problems;
      }
      set {
        _Problems.Assign(value);
      }
    }

    private void attach_Problems(Problem entity)
    {
      SendPropertyChanging();
      entity.ProblemClass = this;
    }
    
    private void detach_Problems(Problem entity)
    {
      SendPropertyChanging();
      entity.ProblemClass = null;
    }
    #endregion
    
    #region Serialization
    private bool serializing;
    
    [OnSerializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerializing(StreamingContext context)
    {
      serializing = true;
    }
    
    [OnSerialized()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerialized(StreamingContext context)
    {
      serializing = false;
    }
    
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.Experiment")]
[KnownType(typeof(Experiment))] public partial class Experiment : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public Experiment()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _AlgorithmParameterBlobValues = new EntitySet<AlgorithmParameterBlobValue>(attach_AlgorithmParameterBlobValues, detach_AlgorithmParameterBlobValues);
      _ProblemParameterBlobValues = new EntitySet<ProblemParameterBlobValue>(attach_ProblemParameterBlobValues, detach_ProblemParameterBlobValues);
      _AlgorithmParameterBoolValues = new EntitySet<AlgorithmParameterBoolValue>(attach_AlgorithmParameterBoolValues, detach_AlgorithmParameterBoolValues);
      _AlgorithmParameterFloatValues = new EntitySet<AlgorithmParameterFloatValue>(attach_AlgorithmParameterFloatValues, detach_AlgorithmParameterFloatValues);
      _AlgorithmParameterIntValues = new EntitySet<AlgorithmParameterIntValue>(attach_AlgorithmParameterIntValues, detach_AlgorithmParameterIntValues);
      _AlgorithmParameterStringValues = new EntitySet<AlgorithmParameterStringValue>(attach_AlgorithmParameterStringValues, detach_AlgorithmParameterStringValues);
      _ProblemParameterBoolValues = new EntitySet<ProblemParameterBoolValue>(attach_ProblemParameterBoolValues, detach_ProblemParameterBoolValues);
      _ProblemParameterFloatValues = new EntitySet<ProblemParameterFloatValue>(attach_ProblemParameterFloatValues, detach_ProblemParameterFloatValues);
      _ProblemParameterIntValues = new EntitySet<ProblemParameterIntValue>(attach_ProblemParameterIntValues, detach_ProblemParameterIntValues);
      _ProblemParameterStringValues = new EntitySet<ProblemParameterStringValue>(attach_ProblemParameterStringValues, detach_ProblemParameterStringValues);
      _Runs = new EntitySet<Run>(attach_Runs, detach_Runs);
      _Problem = default(EntityRef<Problem>);
      _Algorithm = default(EntityRef<Algorithm>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnIdChanging(long value);
    partial void OnIdChanged();
    private long _Id;
    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long Id
    {
      get { return _Id; }
      set {
        if (_Id != value) {
          OnIdChanging(value);
          SendPropertyChanging();
          _Id = value;
          SendPropertyChanged("Id");
          OnIdChanged();
        }
      }
    }
    
    partial void OnAlgorithmIdChanging(long value);
    partial void OnAlgorithmIdChanged();
    private long _AlgorithmId;
    [Column(Storage=@"_AlgorithmId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
    [DataMember(Order=2)]
    public long AlgorithmId
    {
      get { return _AlgorithmId; }
      set {
        if (_AlgorithmId != value) {
          if (_Algorithm.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnAlgorithmIdChanging(value);
          SendPropertyChanging();
          _AlgorithmId = value;
          SendPropertyChanged("AlgorithmId");
          OnAlgorithmIdChanged();
        }
      }
    }
    
    partial void OnProblemIdChanging(long value);
    partial void OnProblemIdChanged();
    private long _ProblemId;
    [Column(Storage=@"_ProblemId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public long ProblemId
    {
      get { return _ProblemId; }
      set {
        if (_ProblemId != value) {
          if (_Problem.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnProblemIdChanging(value);
          SendPropertyChanging();
          _ProblemId = value;
          SendPropertyChanged("ProblemId");
          OnProblemIdChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntitySet<AlgorithmParameterBlobValue> _AlgorithmParameterBlobValues;
    [Association(Name=@"Experiment_AlgorithmParameterBlobValue", Storage=@"_AlgorithmParameterBlobValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public EntitySet<AlgorithmParameterBlobValue> AlgorithmParameterBlobValues
    {
      get {
        if (serializing && !_AlgorithmParameterBlobValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _AlgorithmParameterBlobValues;
      }
      set {
        _AlgorithmParameterBlobValues.Assign(value);
      }
    }

    private void attach_AlgorithmParameterBlobValues(AlgorithmParameterBlobValue entity)
    {
      SendPropertyChanging();
      entity.Experiment = this;
    }
    
    private void detach_AlgorithmParameterBlobValues(AlgorithmParameterBlobValue entity)
    {
      SendPropertyChanging();
      entity.Experiment = null;
    }
    private EntitySet<ProblemParameterBlobValue> _ProblemParameterBlobValues;
    [Association(Name=@"Experiment_ProblemParameterBlobValue", Storage=@"_ProblemParameterBlobValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public EntitySet<ProblemParameterBlobValue> ProblemParameterBlobValues
    {
      get {
        if (serializing && !_ProblemParameterBlobValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemParameterBlobValues;
      }
      set {
        _ProblemParameterBlobValues.Assign(value);
      }
    }

    private void attach_ProblemParameterBlobValues(ProblemParameterBlobValue entity)
    {
      SendPropertyChanging();
      entity.Experiment = this;
    }
    
    private void detach_ProblemParameterBlobValues(ProblemParameterBlobValue entity)
    {
      SendPropertyChanging();
      entity.Experiment = null;
    }
    private EntitySet<AlgorithmParameterBoolValue> _AlgorithmParameterBoolValues;
    [Association(Name=@"Experiment_AlgorithmParameterBoolValue", Storage=@"_AlgorithmParameterBoolValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
    [DataMember(Order=6, EmitDefaultValue=false)]
    public EntitySet<AlgorithmParameterBoolValue> AlgorithmParameterBoolValues
    {
      get {
        if (serializing && !_AlgorithmParameterBoolValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _AlgorithmParameterBoolValues;
      }
      set {
        _AlgorithmParameterBoolValues.Assign(value);
      }
    }

    private void attach_AlgorithmParameterBoolValues(AlgorithmParameterBoolValue entity)
    {
      SendPropertyChanging();
      entity.Experiment = this;
    }
    
    private void detach_AlgorithmParameterBoolValues(AlgorithmParameterBoolValue entity)
    {
      SendPropertyChanging();
      entity.Experiment = null;
    }
    private EntitySet<AlgorithmParameterFloatValue> _AlgorithmParameterFloatValues;
    [Association(Name=@"Experiment_AlgorithmParameterFloatValue", Storage=@"_AlgorithmParameterFloatValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
    [DataMember(Order=7, EmitDefaultValue=false)]
    public EntitySet<AlgorithmParameterFloatValue> AlgorithmParameterFloatValues
    {
      get {
        if (serializing && !_AlgorithmParameterFloatValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _AlgorithmParameterFloatValues;
      }
      set {
        _AlgorithmParameterFloatValues.Assign(value);
      }
    }

    private void attach_AlgorithmParameterFloatValues(AlgorithmParameterFloatValue entity)
    {
      SendPropertyChanging();
      entity.Experiment = this;
    }
    
    private void detach_AlgorithmParameterFloatValues(AlgorithmParameterFloatValue entity)
    {
      SendPropertyChanging();
      entity.Experiment = null;
    }
    private EntitySet<AlgorithmParameterIntValue> _AlgorithmParameterIntValues;
    [Association(Name=@"Experiment_AlgorithmParameterIntValue", Storage=@"_AlgorithmParameterIntValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
    [DataMember(Order=8, EmitDefaultValue=false)]
    public EntitySet<AlgorithmParameterIntValue> AlgorithmParameterIntValues
    {
      get {
        if (serializing && !_AlgorithmParameterIntValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _AlgorithmParameterIntValues;
      }
      set {
        _AlgorithmParameterIntValues.Assign(value);
      }
    }

    private void attach_AlgorithmParameterIntValues(AlgorithmParameterIntValue entity)
    {
      SendPropertyChanging();
      entity.Experiment = this;
    }
    
    private void detach_AlgorithmParameterIntValues(AlgorithmParameterIntValue entity)
    {
      SendPropertyChanging();
      entity.Experiment = null;
    }
    private EntitySet<AlgorithmParameterStringValue> _AlgorithmParameterStringValues;
    [Association(Name=@"Experiment_AlgorithmParameterStringValue", Storage=@"_AlgorithmParameterStringValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
    [DataMember(Order=9, EmitDefaultValue=false)]
    public EntitySet<AlgorithmParameterStringValue> AlgorithmParameterStringValues
    {
      get {
        if (serializing && !_AlgorithmParameterStringValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _AlgorithmParameterStringValues;
      }
      set {
        _AlgorithmParameterStringValues.Assign(value);
      }
    }

    private void attach_AlgorithmParameterStringValues(AlgorithmParameterStringValue entity)
    {
      SendPropertyChanging();
      entity.Experiment = this;
    }
    
    private void detach_AlgorithmParameterStringValues(AlgorithmParameterStringValue entity)
    {
      SendPropertyChanging();
      entity.Experiment = null;
    }
    private EntitySet<ProblemParameterBoolValue> _ProblemParameterBoolValues;
    [Association(Name=@"Experiment_ProblemParameterBoolValue", Storage=@"_ProblemParameterBoolValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
    [DataMember(Order=10, EmitDefaultValue=false)]
    public EntitySet<ProblemParameterBoolValue> ProblemParameterBoolValues
    {
      get {
        if (serializing && !_ProblemParameterBoolValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemParameterBoolValues;
      }
      set {
        _ProblemParameterBoolValues.Assign(value);
      }
    }

    private void attach_ProblemParameterBoolValues(ProblemParameterBoolValue entity)
    {
      SendPropertyChanging();
      entity.Experiment = this;
    }
    
    private void detach_ProblemParameterBoolValues(ProblemParameterBoolValue entity)
    {
      SendPropertyChanging();
      entity.Experiment = null;
    }
    private EntitySet<ProblemParameterFloatValue> _ProblemParameterFloatValues;
    [Association(Name=@"Experiment_ProblemParameterFloatValue", Storage=@"_ProblemParameterFloatValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
    [DataMember(Order=11, EmitDefaultValue=false)]
    public EntitySet<ProblemParameterFloatValue> ProblemParameterFloatValues
    {
      get {
        if (serializing && !_ProblemParameterFloatValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemParameterFloatValues;
      }
      set {
        _ProblemParameterFloatValues.Assign(value);
      }
    }

    private void attach_ProblemParameterFloatValues(ProblemParameterFloatValue entity)
    {
      SendPropertyChanging();
      entity.Experiment = this;
    }
    
    private void detach_ProblemParameterFloatValues(ProblemParameterFloatValue entity)
    {
      SendPropertyChanging();
      entity.Experiment = null;
    }
    private EntitySet<ProblemParameterIntValue> _ProblemParameterIntValues;
    [Association(Name=@"Experiment_ProblemParameterIntValue", Storage=@"_ProblemParameterIntValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
    [DataMember(Order=12, EmitDefaultValue=false)]
    public EntitySet<ProblemParameterIntValue> ProblemParameterIntValues
    {
      get {
        if (serializing && !_ProblemParameterIntValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemParameterIntValues;
      }
      set {
        _ProblemParameterIntValues.Assign(value);
      }
    }

    private void attach_ProblemParameterIntValues(ProblemParameterIntValue entity)
    {
      SendPropertyChanging();
      entity.Experiment = this;
    }
    
    private void detach_ProblemParameterIntValues(ProblemParameterIntValue entity)
    {
      SendPropertyChanging();
      entity.Experiment = null;
    }
    private EntitySet<ProblemParameterStringValue> _ProblemParameterStringValues;
    [Association(Name=@"Experiment_ProblemParameterStringValue", Storage=@"_ProblemParameterStringValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
    [DataMember(Order=13, EmitDefaultValue=false)]
    public EntitySet<ProblemParameterStringValue> ProblemParameterStringValues
    {
      get {
        if (serializing && !_ProblemParameterStringValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemParameterStringValues;
      }
      set {
        _ProblemParameterStringValues.Assign(value);
      }
    }

    private void attach_ProblemParameterStringValues(ProblemParameterStringValue entity)
    {
      SendPropertyChanging();
      entity.Experiment = this;
    }
    
    private void detach_ProblemParameterStringValues(ProblemParameterStringValue entity)
    {
      SendPropertyChanging();
      entity.Experiment = null;
    }
    private EntitySet<Run> _Runs;
    [Association(Name=@"Experiment_Run", Storage=@"_Runs", ThisKey=@"Id", OtherKey=@"ExperimentId")]
    [DataMember(Order=14, EmitDefaultValue=false)]
    public EntitySet<Run> Runs
    {
      get {
        if (serializing && !_Runs.HasLoadedOrAssignedValues) {
          return null;
        }
        return _Runs;
      }
      set {
        _Runs.Assign(value);
      }
    }

    private void attach_Runs(Run entity)
    {
      SendPropertyChanging();
      entity.Experiment = this;
    }
    
    private void detach_Runs(Run entity)
    {
      SendPropertyChanging();
      entity.Experiment = null;
    }
    private EntityRef<Problem> _Problem;
    [Association(Name=@"Problem_Experiment", Storage=@"_Problem", ThisKey=@"ProblemId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=15, EmitDefaultValue=false)]
    public Problem Problem
    {
      get {
        if (serializing && !_Problem.HasLoadedOrAssignedValue) {
          return null;
        }
        return _Problem.Entity;
      }
      set {
        Problem previousValue = _Problem.Entity;
        if ((previousValue != value) || (!_Problem.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Problem.Entity = null;
            previousValue.Experiments.Remove(this);
          }
          _Problem.Entity = value;
          if (value != null) {
            value.Experiments.Add(this);
            _ProblemId = value.Id;
          }
          else {
            _ProblemId = default(long);
          }
          SendPropertyChanged("Problem");
        }
      }
    }

    private EntityRef<Algorithm> _Algorithm;
    [Association(Name=@"Algorithm_Experiment", Storage=@"_Algorithm", ThisKey=@"AlgorithmId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=16, EmitDefaultValue=false)]
    public Algorithm Algorithm
    {
      get {
        if (serializing && !_Algorithm.HasLoadedOrAssignedValue) {
          return null;
        }
        return _Algorithm.Entity;
      }
      set {
        Algorithm previousValue = _Algorithm.Entity;
        if ((previousValue != value) || (!_Algorithm.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Algorithm.Entity = null;
            previousValue.Experiments.Remove(this);
          }
          _Algorithm.Entity = value;
          if (value != null) {
            value.Experiments.Add(this);
            _AlgorithmId = value.Id;
          }
          else {
            _AlgorithmId = default(long);
          }
          SendPropertyChanged("Algorithm");
        }
      }
    }

    #endregion
    
    #region Serialization
    private bool serializing;
    
    [OnSerializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerializing(StreamingContext context)
    {
      serializing = true;
    }
    
    [OnSerialized()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerialized(StreamingContext context)
    {
      serializing = false;
    }
    
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.AlgorithmParameter")]
[KnownType(typeof(AlgorithmParameter))] public partial class AlgorithmParameter : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public AlgorithmParameter()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _AlgorithmParameterBlobValues = new EntitySet<AlgorithmParameterBlobValue>(attach_AlgorithmParameterBlobValues, detach_AlgorithmParameterBlobValues);
      _AlgorithmParameterBoolValues = new EntitySet<AlgorithmParameterBoolValue>(attach_AlgorithmParameterBoolValues, detach_AlgorithmParameterBoolValues);
      _AlgorithmParameterFloatValues = new EntitySet<AlgorithmParameterFloatValue>(attach_AlgorithmParameterFloatValues, detach_AlgorithmParameterFloatValues);
      _AlgorithmParameterIntValues = new EntitySet<AlgorithmParameterIntValue>(attach_AlgorithmParameterIntValues, detach_AlgorithmParameterIntValues);
      _AlgorithmParameterStringValues = new EntitySet<AlgorithmParameterStringValue>(attach_AlgorithmParameterStringValues, detach_AlgorithmParameterStringValues);
      _Algorithm = default(EntityRef<Algorithm>);
      _DataType = default(EntityRef<DataType>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnIdChanging(long value);
    partial void OnIdChanged();
    private long _Id;
    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long Id
    {
      get { return _Id; }
      set {
        if (_Id != value) {
          OnIdChanging(value);
          SendPropertyChanging();
          _Id = value;
          SendPropertyChanged("Id");
          OnIdChanged();
        }
      }
    }
    
    partial void OnAlgorithmIdChanging(long value);
    partial void OnAlgorithmIdChanged();
    private long _AlgorithmId;
    [Column(Storage=@"_AlgorithmId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
    [DataMember(Order=2)]
    public long AlgorithmId
    {
      get { return _AlgorithmId; }
      set {
        if (_AlgorithmId != value) {
          if (_Algorithm.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnAlgorithmIdChanging(value);
          SendPropertyChanging();
          _AlgorithmId = value;
          SendPropertyChanged("AlgorithmId");
          OnAlgorithmIdChanged();
        }
      }
    }
    
    partial void OnNameChanging(string value);
    partial void OnNameChanged();
    private string _Name;
    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public string Name
    {
      get { return _Name; }
      set {
        if (_Name != value) {
          OnNameChanging(value);
          SendPropertyChanging();
          _Name = value;
          SendPropertyChanged("Name");
          OnNameChanged();
        }
      }
    }
    
    partial void OnAliasChanging(string value);
    partial void OnAliasChanged();
    private string _Alias;
    [Column(Storage=@"_Alias", DbType=@"NVarChar(200)")]
    [DataMember(Order=4)]
    public string Alias
    {
      get { return _Alias; }
      set {
        if (_Alias != value) {
          OnAliasChanging(value);
          SendPropertyChanging();
          _Alias = value;
          SendPropertyChanged("Alias");
          OnAliasChanged();
        }
      }
    }
    
    partial void OnDescriptionChanging(string value);
    partial void OnDescriptionChanged();
    private string _Description;
    [Column(Storage=@"_Description", DbType=@"NVarChar(MAX)")]
    [DataMember(Order=5)]
    public string Description
    {
      get { return _Description; }
      set {
        if (_Description != value) {
          OnDescriptionChanging(value);
          SendPropertyChanging();
          _Description = value;
          SendPropertyChanged("Description");
          OnDescriptionChanged();
        }
      }
    }
    
    partial void OnDataTypeIdChanging(long value);
    partial void OnDataTypeIdChanged();
    private long _DataTypeId;
    [Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
    [DataMember(Order=6)]
    public long DataTypeId
    {
      get { return _DataTypeId; }
      set {
        if (_DataTypeId != value) {
          if (_DataType.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnDataTypeIdChanging(value);
          SendPropertyChanging();
          _DataTypeId = value;
          SendPropertyChanged("DataTypeId");
          OnDataTypeIdChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntitySet<AlgorithmParameterBlobValue> _AlgorithmParameterBlobValues;
    [Association(Name=@"AlgorithmParameter_AlgorithmParameterBlobValue", Storage=@"_AlgorithmParameterBlobValues", ThisKey=@"Id", OtherKey=@"AlgorithmParameterId")]
    [DataMember(Order=7, EmitDefaultValue=false)]
    public EntitySet<AlgorithmParameterBlobValue> AlgorithmParameterBlobValues
    {
      get {
        if (serializing && !_AlgorithmParameterBlobValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _AlgorithmParameterBlobValues;
      }
      set {
        _AlgorithmParameterBlobValues.Assign(value);
      }
    }

    private void attach_AlgorithmParameterBlobValues(AlgorithmParameterBlobValue entity)
    {
      SendPropertyChanging();
      entity.AlgorithmParameter = this;
    }
    
    private void detach_AlgorithmParameterBlobValues(AlgorithmParameterBlobValue entity)
    {
      SendPropertyChanging();
      entity.AlgorithmParameter = null;
    }
    private EntitySet<AlgorithmParameterBoolValue> _AlgorithmParameterBoolValues;
    [Association(Name=@"AlgorithmParameter_AlgorithmParameterBoolValue", Storage=@"_AlgorithmParameterBoolValues", ThisKey=@"Id", OtherKey=@"AlgorithmParameterId")]
    [DataMember(Order=8, EmitDefaultValue=false)]
    public EntitySet<AlgorithmParameterBoolValue> AlgorithmParameterBoolValues
    {
      get {
        if (serializing && !_AlgorithmParameterBoolValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _AlgorithmParameterBoolValues;
      }
      set {
        _AlgorithmParameterBoolValues.Assign(value);
      }
    }

    private void attach_AlgorithmParameterBoolValues(AlgorithmParameterBoolValue entity)
    {
      SendPropertyChanging();
      entity.AlgorithmParameter = this;
    }
    
    private void detach_AlgorithmParameterBoolValues(AlgorithmParameterBoolValue entity)
    {
      SendPropertyChanging();
      entity.AlgorithmParameter = null;
    }
    private EntitySet<AlgorithmParameterFloatValue> _AlgorithmParameterFloatValues;
    [Association(Name=@"AlgorithmParameter_AlgorithmParameterFloatValue", Storage=@"_AlgorithmParameterFloatValues", ThisKey=@"Id", OtherKey=@"AlgorithmParameterId")]
    [DataMember(Order=9, EmitDefaultValue=false)]
    public EntitySet<AlgorithmParameterFloatValue> AlgorithmParameterFloatValues
    {
      get {
        if (serializing && !_AlgorithmParameterFloatValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _AlgorithmParameterFloatValues;
      }
      set {
        _AlgorithmParameterFloatValues.Assign(value);
      }
    }

    private void attach_AlgorithmParameterFloatValues(AlgorithmParameterFloatValue entity)
    {
      SendPropertyChanging();
      entity.AlgorithmParameter = this;
    }
    
    private void detach_AlgorithmParameterFloatValues(AlgorithmParameterFloatValue entity)
    {
      SendPropertyChanging();
      entity.AlgorithmParameter = null;
    }
    private EntitySet<AlgorithmParameterIntValue> _AlgorithmParameterIntValues;
    [Association(Name=@"AlgorithmParameter_AlgorithmParameterIntValue", Storage=@"_AlgorithmParameterIntValues", ThisKey=@"Id", OtherKey=@"AlgorithmParameterId")]
    [DataMember(Order=10, EmitDefaultValue=false)]
    public EntitySet<AlgorithmParameterIntValue> AlgorithmParameterIntValues
    {
      get {
        if (serializing && !_AlgorithmParameterIntValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _AlgorithmParameterIntValues;
      }
      set {
        _AlgorithmParameterIntValues.Assign(value);
      }
    }

    private void attach_AlgorithmParameterIntValues(AlgorithmParameterIntValue entity)
    {
      SendPropertyChanging();
      entity.AlgorithmParameter = this;
    }
    
    private void detach_AlgorithmParameterIntValues(AlgorithmParameterIntValue entity)
    {
      SendPropertyChanging();
      entity.AlgorithmParameter = null;
    }
    private EntitySet<AlgorithmParameterStringValue> _AlgorithmParameterStringValues;
    [Association(Name=@"AlgorithmParameter_AlgorithmParameterStringValue", Storage=@"_AlgorithmParameterStringValues", ThisKey=@"Id", OtherKey=@"AlgorithmParameterId")]
    [DataMember(Order=11, EmitDefaultValue=false)]
    public EntitySet<AlgorithmParameterStringValue> AlgorithmParameterStringValues
    {
      get {
        if (serializing && !_AlgorithmParameterStringValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _AlgorithmParameterStringValues;
      }
      set {
        _AlgorithmParameterStringValues.Assign(value);
      }
    }

    private void attach_AlgorithmParameterStringValues(AlgorithmParameterStringValue entity)
    {
      SendPropertyChanging();
      entity.AlgorithmParameter = this;
    }
    
    private void detach_AlgorithmParameterStringValues(AlgorithmParameterStringValue entity)
    {
      SendPropertyChanging();
      entity.AlgorithmParameter = null;
    }
    private EntityRef<Algorithm> _Algorithm;
    [Association(Name=@"Algorithm_AlgorithmParameter", Storage=@"_Algorithm", ThisKey=@"AlgorithmId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=12, EmitDefaultValue=false)]
    public Algorithm Algorithm
    {
      get {
        if (serializing && !_Algorithm.HasLoadedOrAssignedValue) {
          return null;
        }
        return _Algorithm.Entity;
      }
      set {
        Algorithm previousValue = _Algorithm.Entity;
        if ((previousValue != value) || (!_Algorithm.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Algorithm.Entity = null;
            previousValue.AlgorithmParameters.Remove(this);
          }
          _Algorithm.Entity = value;
          if (value != null) {
            value.AlgorithmParameters.Add(this);
            _AlgorithmId = value.Id;
          }
          else {
            _AlgorithmId = default(long);
          }
          SendPropertyChanged("Algorithm");
        }
      }
    }

    private EntityRef<DataType> _DataType;
    [Association(Name=@"DataType_AlgorithmParameter", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=13, EmitDefaultValue=false)]
    public DataType DataType
    {
      get {
        if (serializing && !_DataType.HasLoadedOrAssignedValue) {
          return null;
        }
        return _DataType.Entity;
      }
      set {
        DataType previousValue = _DataType.Entity;
        if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _DataType.Entity = null;
            previousValue.AlgorithmParameters.Remove(this);
          }
          _DataType.Entity = value;
          if (value != null) {
            value.AlgorithmParameters.Add(this);
            _DataTypeId = value.Id;
          }
          else {
            _DataTypeId = default(long);
          }
          SendPropertyChanged("DataType");
        }
      }
    }

    #endregion
    
    #region Serialization
    private bool serializing;
    
    [OnSerializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerializing(StreamingContext context)
    {
      serializing = true;
    }
    
    [OnSerialized()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerialized(StreamingContext context)
    {
      serializing = false;
    }
    
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.ProblemParameter")]
[KnownType(typeof(ProblemParameter))] public partial class ProblemParameter : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public ProblemParameter()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _ProblemParameterBlobValues = new EntitySet<ProblemParameterBlobValue>(attach_ProblemParameterBlobValues, detach_ProblemParameterBlobValues);
      _ProblemParameterBoolValues = new EntitySet<ProblemParameterBoolValue>(attach_ProblemParameterBoolValues, detach_ProblemParameterBoolValues);
      _ProblemParameterFloatValues = new EntitySet<ProblemParameterFloatValue>(attach_ProblemParameterFloatValues, detach_ProblemParameterFloatValues);
      _ProblemParameterIntValues = new EntitySet<ProblemParameterIntValue>(attach_ProblemParameterIntValues, detach_ProblemParameterIntValues);
      _ProblemParameterStringValues = new EntitySet<ProblemParameterStringValue>(attach_ProblemParameterStringValues, detach_ProblemParameterStringValues);
      _Problem = default(EntityRef<Problem>);
      _DataType = default(EntityRef<DataType>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnIdChanging(long value);
    partial void OnIdChanged();
    private long _Id;
    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long Id
    {
      get { return _Id; }
      set {
        if (_Id != value) {
          OnIdChanging(value);
          SendPropertyChanging();
          _Id = value;
          SendPropertyChanged("Id");
          OnIdChanged();
        }
      }
    }
    
    partial void OnProblemIdChanging(long value);
    partial void OnProblemIdChanged();
    private long _ProblemId;
    [Column(Storage=@"_ProblemId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
    [DataMember(Order=2)]
    public long ProblemId
    {
      get { return _ProblemId; }
      set {
        if (_ProblemId != value) {
          if (_Problem.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnProblemIdChanging(value);
          SendPropertyChanging();
          _ProblemId = value;
          SendPropertyChanged("ProblemId");
          OnProblemIdChanged();
        }
      }
    }
    
    partial void OnNameChanging(string value);
    partial void OnNameChanged();
    private string _Name;
    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public string Name
    {
      get { return _Name; }
      set {
        if (_Name != value) {
          OnNameChanging(value);
          SendPropertyChanging();
          _Name = value;
          SendPropertyChanged("Name");
          OnNameChanged();
        }
      }
    }
    
    partial void OnAliasChanging(string value);
    partial void OnAliasChanged();
    private string _Alias;
    [Column(Storage=@"_Alias", DbType=@"NVarChar(200)")]
    [DataMember(Order=4)]
    public string Alias
    {
      get { return _Alias; }
      set {
        if (_Alias != value) {
          OnAliasChanging(value);
          SendPropertyChanging();
          _Alias = value;
          SendPropertyChanged("Alias");
          OnAliasChanged();
        }
      }
    }
    
    partial void OnDescriptionChanging(string value);
    partial void OnDescriptionChanged();
    private string _Description;
    [Column(Storage=@"_Description", DbType=@"NVarChar(MAX)")]
    [DataMember(Order=5)]
    public string Description
    {
      get { return _Description; }
      set {
        if (_Description != value) {
          OnDescriptionChanging(value);
          SendPropertyChanging();
          _Description = value;
          SendPropertyChanged("Description");
          OnDescriptionChanged();
        }
      }
    }
    
    partial void OnDataTypeIdChanging(long value);
    partial void OnDataTypeIdChanged();
    private long _DataTypeId;
    [Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
    [DataMember(Order=6)]
    public long DataTypeId
    {
      get { return _DataTypeId; }
      set {
        if (_DataTypeId != value) {
          if (_DataType.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnDataTypeIdChanging(value);
          SendPropertyChanging();
          _DataTypeId = value;
          SendPropertyChanged("DataTypeId");
          OnDataTypeIdChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntitySet<ProblemParameterBlobValue> _ProblemParameterBlobValues;
    [Association(Name=@"ProblemParameter_ProblemParameterBlobValue", Storage=@"_ProblemParameterBlobValues", ThisKey=@"Id", OtherKey=@"ProblemParameterId")]
    [DataMember(Order=7, EmitDefaultValue=false)]
    public EntitySet<ProblemParameterBlobValue> ProblemParameterBlobValues
    {
      get {
        if (serializing && !_ProblemParameterBlobValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemParameterBlobValues;
      }
      set {
        _ProblemParameterBlobValues.Assign(value);
      }
    }

    private void attach_ProblemParameterBlobValues(ProblemParameterBlobValue entity)
    {
      SendPropertyChanging();
      entity.ProblemParameter = this;
    }
    
    private void detach_ProblemParameterBlobValues(ProblemParameterBlobValue entity)
    {
      SendPropertyChanging();
      entity.ProblemParameter = null;
    }
    private EntitySet<ProblemParameterBoolValue> _ProblemParameterBoolValues;
    [Association(Name=@"ProblemParameter_ProblemParameterBoolValue", Storage=@"_ProblemParameterBoolValues", ThisKey=@"Id", OtherKey=@"ProblemParameterId")]
    [DataMember(Order=8, EmitDefaultValue=false)]
    public EntitySet<ProblemParameterBoolValue> ProblemParameterBoolValues
    {
      get {
        if (serializing && !_ProblemParameterBoolValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemParameterBoolValues;
      }
      set {
        _ProblemParameterBoolValues.Assign(value);
      }
    }

    private void attach_ProblemParameterBoolValues(ProblemParameterBoolValue entity)
    {
      SendPropertyChanging();
      entity.ProblemParameter = this;
    }
    
    private void detach_ProblemParameterBoolValues(ProblemParameterBoolValue entity)
    {
      SendPropertyChanging();
      entity.ProblemParameter = null;
    }
    private EntitySet<ProblemParameterFloatValue> _ProblemParameterFloatValues;
    [Association(Name=@"ProblemParameter_ProblemParameterFloatValue", Storage=@"_ProblemParameterFloatValues", ThisKey=@"Id", OtherKey=@"ProblemParameterId")]
    [DataMember(Order=9, EmitDefaultValue=false)]
    public EntitySet<ProblemParameterFloatValue> ProblemParameterFloatValues
    {
      get {
        if (serializing && !_ProblemParameterFloatValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemParameterFloatValues;
      }
      set {
        _ProblemParameterFloatValues.Assign(value);
      }
    }

    private void attach_ProblemParameterFloatValues(ProblemParameterFloatValue entity)
    {
      SendPropertyChanging();
      entity.ProblemParameter = this;
    }
    
    private void detach_ProblemParameterFloatValues(ProblemParameterFloatValue entity)
    {
      SendPropertyChanging();
      entity.ProblemParameter = null;
    }
    private EntitySet<ProblemParameterIntValue> _ProblemParameterIntValues;
    [Association(Name=@"ProblemParameter_ProblemParameterIntValue", Storage=@"_ProblemParameterIntValues", ThisKey=@"Id", OtherKey=@"ProblemParameterId")]
    [DataMember(Order=10, EmitDefaultValue=false)]
    public EntitySet<ProblemParameterIntValue> ProblemParameterIntValues
    {
      get {
        if (serializing && !_ProblemParameterIntValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemParameterIntValues;
      }
      set {
        _ProblemParameterIntValues.Assign(value);
      }
    }

    private void attach_ProblemParameterIntValues(ProblemParameterIntValue entity)
    {
      SendPropertyChanging();
      entity.ProblemParameter = this;
    }
    
    private void detach_ProblemParameterIntValues(ProblemParameterIntValue entity)
    {
      SendPropertyChanging();
      entity.ProblemParameter = null;
    }
    private EntitySet<ProblemParameterStringValue> _ProblemParameterStringValues;
    [Association(Name=@"ProblemParameter_ProblemParameterStringValue", Storage=@"_ProblemParameterStringValues", ThisKey=@"Id", OtherKey=@"ProblemParameterId")]
    [DataMember(Order=11, EmitDefaultValue=false)]
    public EntitySet<ProblemParameterStringValue> ProblemParameterStringValues
    {
      get {
        if (serializing && !_ProblemParameterStringValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemParameterStringValues;
      }
      set {
        _ProblemParameterStringValues.Assign(value);
      }
    }

    private void attach_ProblemParameterStringValues(ProblemParameterStringValue entity)
    {
      SendPropertyChanging();
      entity.ProblemParameter = this;
    }
    
    private void detach_ProblemParameterStringValues(ProblemParameterStringValue entity)
    {
      SendPropertyChanging();
      entity.ProblemParameter = null;
    }
    private EntityRef<Problem> _Problem;
    [Association(Name=@"Problem_ProblemParameter", Storage=@"_Problem", ThisKey=@"ProblemId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=12, EmitDefaultValue=false)]
    public Problem Problem
    {
      get {
        if (serializing && !_Problem.HasLoadedOrAssignedValue) {
          return null;
        }
        return _Problem.Entity;
      }
      set {
        Problem previousValue = _Problem.Entity;
        if ((previousValue != value) || (!_Problem.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Problem.Entity = null;
            previousValue.ProblemParameters.Remove(this);
          }
          _Problem.Entity = value;
          if (value != null) {
            value.ProblemParameters.Add(this);
            _ProblemId = value.Id;
          }
          else {
            _ProblemId = default(long);
          }
          SendPropertyChanged("Problem");
        }
      }
    }

    private EntityRef<DataType> _DataType;
    [Association(Name=@"DataType_ProblemParameter", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=13, EmitDefaultValue=false)]
    public DataType DataType
    {
      get {
        if (serializing && !_DataType.HasLoadedOrAssignedValue) {
          return null;
        }
        return _DataType.Entity;
      }
      set {
        DataType previousValue = _DataType.Entity;
        if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _DataType.Entity = null;
            previousValue.ProblemParameters.Remove(this);
          }
          _DataType.Entity = value;
          if (value != null) {
            value.ProblemParameters.Add(this);
            _DataTypeId = value.Id;
          }
          else {
            _DataTypeId = default(long);
          }
          SendPropertyChanged("DataType");
        }
      }
    }

    #endregion
    
    #region Serialization
    private bool serializing;
    
    [OnSerializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerializing(StreamingContext context)
    {
      serializing = true;
    }
    
    [OnSerialized()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerialized(StreamingContext context)
    {
      serializing = false;
    }
    
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.AlgorithmParameterBlobValue")]
[KnownType(typeof(AlgorithmParameterBlobValue))]  public partial class AlgorithmParameterBlobValue : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public AlgorithmParameterBlobValue()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _AlgorithmParameter = default(EntityRef<AlgorithmParameter>);
      _Experiment = default(EntityRef<Experiment>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnAlgorithmParameterIdChanging(long value);
    partial void OnAlgorithmParameterIdChanged();
    private long _AlgorithmParameterId;
    [Column(Storage=@"_AlgorithmParameterId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long AlgorithmParameterId
    {
      get { return _AlgorithmParameterId; }
      set {
        if (_AlgorithmParameterId != value) {
          if (_AlgorithmParameter.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnAlgorithmParameterIdChanging(value);
          SendPropertyChanging();
          _AlgorithmParameterId = value;
          SendPropertyChanged("AlgorithmParameterId");
          OnAlgorithmParameterIdChanged();
        }
      }
    }
    
    partial void OnExperimentIdChanging(long value);
    partial void OnExperimentIdChanged();
    private long _ExperimentId;
    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public long ExperimentId
    {
      get { return _ExperimentId; }
      set {
        if (_ExperimentId != value) {
          if (_Experiment.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnExperimentIdChanging(value);
          SendPropertyChanging();
          _ExperimentId = value;
          SendPropertyChanged("ExperimentId");
          OnExperimentIdChanged();
        }
      }
    }
    
    partial void OnValueChanging(Binary value);
    partial void OnValueChanged();
    private Binary _Value;
    [Column(Storage=@"_Value", DbType=@"VarBinary(MAX) NOT NULL", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=3)]
    public Binary Value
    {
      get { return _Value; }
      set {
        if (_Value != value) {
          OnValueChanging(value);
          SendPropertyChanging();
          _Value = value;
          SendPropertyChanged("Value");
          OnValueChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<AlgorithmParameter> _AlgorithmParameter;
    [Association(Name=@"AlgorithmParameter_AlgorithmParameterBlobValue", Storage=@"_AlgorithmParameter", ThisKey=@"AlgorithmParameterId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public AlgorithmParameter AlgorithmParameter
    {
      get {
        return _AlgorithmParameter.Entity;
      }
      set {
        AlgorithmParameter previousValue = _AlgorithmParameter.Entity;
        if ((previousValue != value) || (!_AlgorithmParameter.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _AlgorithmParameter.Entity = null;
            previousValue.AlgorithmParameterBlobValues.Remove(this);
          }
          _AlgorithmParameter.Entity = value;
          if (value != null) {
            value.AlgorithmParameterBlobValues.Add(this);
            _AlgorithmParameterId = value.Id;
          }
          else {
            _AlgorithmParameterId = default(long);
          }
          SendPropertyChanged("AlgorithmParameter");
        }
      }
    }

    private EntityRef<Experiment> _Experiment;
    [Association(Name=@"Experiment_AlgorithmParameterBlobValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public Experiment Experiment
    {
      get {
        return _Experiment.Entity;
      }
      set {
        Experiment previousValue = _Experiment.Entity;
        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Experiment.Entity = null;
            previousValue.AlgorithmParameterBlobValues.Remove(this);
          }
          _Experiment.Entity = value;
          if (value != null) {
            value.AlgorithmParameterBlobValues.Add(this);
            _ExperimentId = value.Id;
          }
          else {
            _ExperimentId = default(long);
          }
          SendPropertyChanged("Experiment");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.ProblemParameterBlobValue")]
[KnownType(typeof(ProblemParameterBlobValue))]  public partial class ProblemParameterBlobValue : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public ProblemParameterBlobValue()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Experiment = default(EntityRef<Experiment>);
      _ProblemParameter = default(EntityRef<ProblemParameter>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnProblemParameterIdChanging(long value);
    partial void OnProblemParameterIdChanged();
    private long _ProblemParameterId;
    [Column(Storage=@"_ProblemParameterId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long ProblemParameterId
    {
      get { return _ProblemParameterId; }
      set {
        if (_ProblemParameterId != value) {
          if (_ProblemParameter.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnProblemParameterIdChanging(value);
          SendPropertyChanging();
          _ProblemParameterId = value;
          SendPropertyChanged("ProblemParameterId");
          OnProblemParameterIdChanged();
        }
      }
    }
    
    partial void OnExperimentIdChanging(long value);
    partial void OnExperimentIdChanged();
    private long _ExperimentId;
    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public long ExperimentId
    {
      get { return _ExperimentId; }
      set {
        if (_ExperimentId != value) {
          if (_Experiment.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnExperimentIdChanging(value);
          SendPropertyChanging();
          _ExperimentId = value;
          SendPropertyChanged("ExperimentId");
          OnExperimentIdChanged();
        }
      }
    }
    
    partial void OnValueChanging(Binary value);
    partial void OnValueChanged();
    private Binary _Value;
    [Column(Storage=@"_Value", DbType=@"VarBinary(MAX) NOT NULL", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=3)]
    public Binary Value
    {
      get { return _Value; }
      set {
        if (_Value != value) {
          OnValueChanging(value);
          SendPropertyChanging();
          _Value = value;
          SendPropertyChanged("Value");
          OnValueChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<Experiment> _Experiment;
    [Association(Name=@"Experiment_ProblemParameterBlobValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public Experiment Experiment
    {
      get {
        return _Experiment.Entity;
      }
      set {
        Experiment previousValue = _Experiment.Entity;
        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Experiment.Entity = null;
            previousValue.ProblemParameterBlobValues.Remove(this);
          }
          _Experiment.Entity = value;
          if (value != null) {
            value.ProblemParameterBlobValues.Add(this);
            _ExperimentId = value.Id;
          }
          else {
            _ExperimentId = default(long);
          }
          SendPropertyChanged("Experiment");
        }
      }
    }

    private EntityRef<ProblemParameter> _ProblemParameter;
    [Association(Name=@"ProblemParameter_ProblemParameterBlobValue", Storage=@"_ProblemParameter", ThisKey=@"ProblemParameterId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public ProblemParameter ProblemParameter
    {
      get {
        return _ProblemParameter.Entity;
      }
      set {
        ProblemParameter previousValue = _ProblemParameter.Entity;
        if ((previousValue != value) || (!_ProblemParameter.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _ProblemParameter.Entity = null;
            previousValue.ProblemParameterBlobValues.Remove(this);
          }
          _ProblemParameter.Entity = value;
          if (value != null) {
            value.ProblemParameterBlobValues.Add(this);
            _ProblemParameterId = value.Id;
          }
          else {
            _ProblemParameterId = default(long);
          }
          SendPropertyChanged("ProblemParameter");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.AlgorithmParameterBoolValue")]
[KnownType(typeof(AlgorithmParameterBoolValue))]  public partial class AlgorithmParameterBoolValue : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public AlgorithmParameterBoolValue()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _AlgorithmParameter = default(EntityRef<AlgorithmParameter>);
      _Experiment = default(EntityRef<Experiment>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnAlgorithmParameterIdChanging(long value);
    partial void OnAlgorithmParameterIdChanged();
    private long _AlgorithmParameterId;
    [Column(Storage=@"_AlgorithmParameterId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long AlgorithmParameterId
    {
      get { return _AlgorithmParameterId; }
      set {
        if (_AlgorithmParameterId != value) {
          if (_AlgorithmParameter.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnAlgorithmParameterIdChanging(value);
          SendPropertyChanging();
          _AlgorithmParameterId = value;
          SendPropertyChanged("AlgorithmParameterId");
          OnAlgorithmParameterIdChanged();
        }
      }
    }
    
    partial void OnExperimentIdChanging(long value);
    partial void OnExperimentIdChanged();
    private long _ExperimentId;
    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public long ExperimentId
    {
      get { return _ExperimentId; }
      set {
        if (_ExperimentId != value) {
          if (_Experiment.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnExperimentIdChanging(value);
          SendPropertyChanging();
          _ExperimentId = value;
          SendPropertyChanged("ExperimentId");
          OnExperimentIdChanged();
        }
      }
    }
    
    partial void OnValueChanging(bool value);
    partial void OnValueChanged();
    private bool _Value;
    [Column(Storage=@"_Value", DbType=@"Bit NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public bool Value
    {
      get { return _Value; }
      set {
        if (_Value != value) {
          OnValueChanging(value);
          SendPropertyChanging();
          _Value = value;
          SendPropertyChanged("Value");
          OnValueChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<AlgorithmParameter> _AlgorithmParameter;
    [Association(Name=@"AlgorithmParameter_AlgorithmParameterBoolValue", Storage=@"_AlgorithmParameter", ThisKey=@"AlgorithmParameterId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public AlgorithmParameter AlgorithmParameter
    {
      get {
        return _AlgorithmParameter.Entity;
      }
      set {
        AlgorithmParameter previousValue = _AlgorithmParameter.Entity;
        if ((previousValue != value) || (!_AlgorithmParameter.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _AlgorithmParameter.Entity = null;
            previousValue.AlgorithmParameterBoolValues.Remove(this);
          }
          _AlgorithmParameter.Entity = value;
          if (value != null) {
            value.AlgorithmParameterBoolValues.Add(this);
            _AlgorithmParameterId = value.Id;
          }
          else {
            _AlgorithmParameterId = default(long);
          }
          SendPropertyChanged("AlgorithmParameter");
        }
      }
    }

    private EntityRef<Experiment> _Experiment;
    [Association(Name=@"Experiment_AlgorithmParameterBoolValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public Experiment Experiment
    {
      get {
        return _Experiment.Entity;
      }
      set {
        Experiment previousValue = _Experiment.Entity;
        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Experiment.Entity = null;
            previousValue.AlgorithmParameterBoolValues.Remove(this);
          }
          _Experiment.Entity = value;
          if (value != null) {
            value.AlgorithmParameterBoolValues.Add(this);
            _ExperimentId = value.Id;
          }
          else {
            _ExperimentId = default(long);
          }
          SendPropertyChanged("Experiment");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.AlgorithmParameterFloatValue")]
[KnownType(typeof(AlgorithmParameterFloatValue))] public partial class AlgorithmParameterFloatValue : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public AlgorithmParameterFloatValue()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _AlgorithmParameter = default(EntityRef<AlgorithmParameter>);
      _Experiment = default(EntityRef<Experiment>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnAlgorithmParameterIdChanging(long value);
    partial void OnAlgorithmParameterIdChanged();
    private long _AlgorithmParameterId;
    [Column(Storage=@"_AlgorithmParameterId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long AlgorithmParameterId
    {
      get { return _AlgorithmParameterId; }
      set {
        if (_AlgorithmParameterId != value) {
          if (_AlgorithmParameter.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnAlgorithmParameterIdChanging(value);
          SendPropertyChanging();
          _AlgorithmParameterId = value;
          SendPropertyChanged("AlgorithmParameterId");
          OnAlgorithmParameterIdChanged();
        }
      }
    }
    
    partial void OnExperimentIdChanging(long value);
    partial void OnExperimentIdChanged();
    private long _ExperimentId;
    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public long ExperimentId
    {
      get { return _ExperimentId; }
      set {
        if (_ExperimentId != value) {
          if (_Experiment.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnExperimentIdChanging(value);
          SendPropertyChanging();
          _ExperimentId = value;
          SendPropertyChanged("ExperimentId");
          OnExperimentIdChanged();
        }
      }
    }
    
    partial void OnValueChanging(double value);
    partial void OnValueChanged();
    private double _Value;
    [Column(Storage=@"_Value", DbType=@"Float NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public double Value
    {
      get { return _Value; }
      set {
        if (_Value != value) {
          OnValueChanging(value);
          SendPropertyChanging();
          _Value = value;
          SendPropertyChanged("Value");
          OnValueChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<AlgorithmParameter> _AlgorithmParameter;
    [Association(Name=@"AlgorithmParameter_AlgorithmParameterFloatValue", Storage=@"_AlgorithmParameter", ThisKey=@"AlgorithmParameterId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public AlgorithmParameter AlgorithmParameter
    {
      get {
        return _AlgorithmParameter.Entity;
      }
      set {
        AlgorithmParameter previousValue = _AlgorithmParameter.Entity;
        if ((previousValue != value) || (!_AlgorithmParameter.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _AlgorithmParameter.Entity = null;
            previousValue.AlgorithmParameterFloatValues.Remove(this);
          }
          _AlgorithmParameter.Entity = value;
          if (value != null) {
            value.AlgorithmParameterFloatValues.Add(this);
            _AlgorithmParameterId = value.Id;
          }
          else {
            _AlgorithmParameterId = default(long);
          }
          SendPropertyChanged("AlgorithmParameter");
        }
      }
    }

    private EntityRef<Experiment> _Experiment;
    [Association(Name=@"Experiment_AlgorithmParameterFloatValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public Experiment Experiment
    {
      get {
        return _Experiment.Entity;
      }
      set {
        Experiment previousValue = _Experiment.Entity;
        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Experiment.Entity = null;
            previousValue.AlgorithmParameterFloatValues.Remove(this);
          }
          _Experiment.Entity = value;
          if (value != null) {
            value.AlgorithmParameterFloatValues.Add(this);
            _ExperimentId = value.Id;
          }
          else {
            _ExperimentId = default(long);
          }
          SendPropertyChanged("Experiment");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.AlgorithmParameterIntValue")]
[KnownType(typeof(AlgorithmParameterIntValue))] public partial class AlgorithmParameterIntValue : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public AlgorithmParameterIntValue()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _AlgorithmParameter = default(EntityRef<AlgorithmParameter>);
      _Experiment = default(EntityRef<Experiment>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnAlgorithmParameterIdChanging(long value);
    partial void OnAlgorithmParameterIdChanged();
    private long _AlgorithmParameterId;
    [Column(Storage=@"_AlgorithmParameterId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long AlgorithmParameterId
    {
      get { return _AlgorithmParameterId; }
      set {
        if (_AlgorithmParameterId != value) {
          if (_AlgorithmParameter.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnAlgorithmParameterIdChanging(value);
          SendPropertyChanging();
          _AlgorithmParameterId = value;
          SendPropertyChanged("AlgorithmParameterId");
          OnAlgorithmParameterIdChanged();
        }
      }
    }
    
    partial void OnExperimentIdChanging(long value);
    partial void OnExperimentIdChanged();
    private long _ExperimentId;
    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public long ExperimentId
    {
      get { return _ExperimentId; }
      set {
        if (_ExperimentId != value) {
          if (_Experiment.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnExperimentIdChanging(value);
          SendPropertyChanging();
          _ExperimentId = value;
          SendPropertyChanged("ExperimentId");
          OnExperimentIdChanged();
        }
      }
    }
    
    partial void OnValueChanging(int value);
    partial void OnValueChanged();
    private int _Value;
    [Column(Storage=@"_Value", DbType=@"Int NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public int Value
    {
      get { return _Value; }
      set {
        if (_Value != value) {
          OnValueChanging(value);
          SendPropertyChanging();
          _Value = value;
          SendPropertyChanged("Value");
          OnValueChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<AlgorithmParameter> _AlgorithmParameter;
    [Association(Name=@"AlgorithmParameter_AlgorithmParameterIntValue", Storage=@"_AlgorithmParameter", ThisKey=@"AlgorithmParameterId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public AlgorithmParameter AlgorithmParameter
    {
      get {
        return _AlgorithmParameter.Entity;
      }
      set {
        AlgorithmParameter previousValue = _AlgorithmParameter.Entity;
        if ((previousValue != value) || (!_AlgorithmParameter.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _AlgorithmParameter.Entity = null;
            previousValue.AlgorithmParameterIntValues.Remove(this);
          }
          _AlgorithmParameter.Entity = value;
          if (value != null) {
            value.AlgorithmParameterIntValues.Add(this);
            _AlgorithmParameterId = value.Id;
          }
          else {
            _AlgorithmParameterId = default(long);
          }
          SendPropertyChanged("AlgorithmParameter");
        }
      }
    }

    private EntityRef<Experiment> _Experiment;
    [Association(Name=@"Experiment_AlgorithmParameterIntValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public Experiment Experiment
    {
      get {
        return _Experiment.Entity;
      }
      set {
        Experiment previousValue = _Experiment.Entity;
        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Experiment.Entity = null;
            previousValue.AlgorithmParameterIntValues.Remove(this);
          }
          _Experiment.Entity = value;
          if (value != null) {
            value.AlgorithmParameterIntValues.Add(this);
            _ExperimentId = value.Id;
          }
          else {
            _ExperimentId = default(long);
          }
          SendPropertyChanged("Experiment");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.AlgorithmParameterStringValue")]
[KnownType(typeof(AlgorithmParameterStringValue))]  public partial class AlgorithmParameterStringValue : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public AlgorithmParameterStringValue()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _AlgorithmParameter = default(EntityRef<AlgorithmParameter>);
      _Experiment = default(EntityRef<Experiment>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnAlgorithmParameterIdChanging(long value);
    partial void OnAlgorithmParameterIdChanged();
    private long _AlgorithmParameterId;
    [Column(Storage=@"_AlgorithmParameterId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long AlgorithmParameterId
    {
      get { return _AlgorithmParameterId; }
      set {
        if (_AlgorithmParameterId != value) {
          if (_AlgorithmParameter.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnAlgorithmParameterIdChanging(value);
          SendPropertyChanging();
          _AlgorithmParameterId = value;
          SendPropertyChanged("AlgorithmParameterId");
          OnAlgorithmParameterIdChanged();
        }
      }
    }
    
    partial void OnExperimentIdChanging(long value);
    partial void OnExperimentIdChanged();
    private long _ExperimentId;
    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public long ExperimentId
    {
      get { return _ExperimentId; }
      set {
        if (_ExperimentId != value) {
          if (_Experiment.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnExperimentIdChanging(value);
          SendPropertyChanging();
          _ExperimentId = value;
          SendPropertyChanged("ExperimentId");
          OnExperimentIdChanged();
        }
      }
    }
    
    partial void OnValueChanging(string value);
    partial void OnValueChanged();
    private string _Value;
    [Column(Storage=@"_Value", DbType=@"NVarChar(MAX) NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public string Value
    {
      get { return _Value; }
      set {
        if (_Value != value) {
          OnValueChanging(value);
          SendPropertyChanging();
          _Value = value;
          SendPropertyChanged("Value");
          OnValueChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<AlgorithmParameter> _AlgorithmParameter;
    [Association(Name=@"AlgorithmParameter_AlgorithmParameterStringValue", Storage=@"_AlgorithmParameter", ThisKey=@"AlgorithmParameterId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public AlgorithmParameter AlgorithmParameter
    {
      get {
        return _AlgorithmParameter.Entity;
      }
      set {
        AlgorithmParameter previousValue = _AlgorithmParameter.Entity;
        if ((previousValue != value) || (!_AlgorithmParameter.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _AlgorithmParameter.Entity = null;
            previousValue.AlgorithmParameterStringValues.Remove(this);
          }
          _AlgorithmParameter.Entity = value;
          if (value != null) {
            value.AlgorithmParameterStringValues.Add(this);
            _AlgorithmParameterId = value.Id;
          }
          else {
            _AlgorithmParameterId = default(long);
          }
          SendPropertyChanged("AlgorithmParameter");
        }
      }
    }

    private EntityRef<Experiment> _Experiment;
    [Association(Name=@"Experiment_AlgorithmParameterStringValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public Experiment Experiment
    {
      get {
        return _Experiment.Entity;
      }
      set {
        Experiment previousValue = _Experiment.Entity;
        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Experiment.Entity = null;
            previousValue.AlgorithmParameterStringValues.Remove(this);
          }
          _Experiment.Entity = value;
          if (value != null) {
            value.AlgorithmParameterStringValues.Add(this);
            _ExperimentId = value.Id;
          }
          else {
            _ExperimentId = default(long);
          }
          SendPropertyChanged("Experiment");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.ProblemParameterBoolValue")]
[KnownType(typeof(ProblemParameterBoolValue))]  public partial class ProblemParameterBoolValue : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public ProblemParameterBoolValue()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Experiment = default(EntityRef<Experiment>);
      _ProblemParameter = default(EntityRef<ProblemParameter>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnProblemParameterIdChanging(long value);
    partial void OnProblemParameterIdChanged();
    private long _ProblemParameterId;
    [Column(Storage=@"_ProblemParameterId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long ProblemParameterId
    {
      get { return _ProblemParameterId; }
      set {
        if (_ProblemParameterId != value) {
          if (_ProblemParameter.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnProblemParameterIdChanging(value);
          SendPropertyChanging();
          _ProblemParameterId = value;
          SendPropertyChanged("ProblemParameterId");
          OnProblemParameterIdChanged();
        }
      }
    }
    
    partial void OnExperimentIdChanging(long value);
    partial void OnExperimentIdChanged();
    private long _ExperimentId;
    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public long ExperimentId
    {
      get { return _ExperimentId; }
      set {
        if (_ExperimentId != value) {
          if (_Experiment.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnExperimentIdChanging(value);
          SendPropertyChanging();
          _ExperimentId = value;
          SendPropertyChanged("ExperimentId");
          OnExperimentIdChanged();
        }
      }
    }
    
    partial void OnValueChanging(bool value);
    partial void OnValueChanged();
    private bool _Value;
    [Column(Storage=@"_Value", DbType=@"Bit NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public bool Value
    {
      get { return _Value; }
      set {
        if (_Value != value) {
          OnValueChanging(value);
          SendPropertyChanging();
          _Value = value;
          SendPropertyChanged("Value");
          OnValueChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<Experiment> _Experiment;
    [Association(Name=@"Experiment_ProblemParameterBoolValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public Experiment Experiment
    {
      get {
        return _Experiment.Entity;
      }
      set {
        Experiment previousValue = _Experiment.Entity;
        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Experiment.Entity = null;
            previousValue.ProblemParameterBoolValues.Remove(this);
          }
          _Experiment.Entity = value;
          if (value != null) {
            value.ProblemParameterBoolValues.Add(this);
            _ExperimentId = value.Id;
          }
          else {
            _ExperimentId = default(long);
          }
          SendPropertyChanged("Experiment");
        }
      }
    }

    private EntityRef<ProblemParameter> _ProblemParameter;
    [Association(Name=@"ProblemParameter_ProblemParameterBoolValue", Storage=@"_ProblemParameter", ThisKey=@"ProblemParameterId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public ProblemParameter ProblemParameter
    {
      get {
        return _ProblemParameter.Entity;
      }
      set {
        ProblemParameter previousValue = _ProblemParameter.Entity;
        if ((previousValue != value) || (!_ProblemParameter.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _ProblemParameter.Entity = null;
            previousValue.ProblemParameterBoolValues.Remove(this);
          }
          _ProblemParameter.Entity = value;
          if (value != null) {
            value.ProblemParameterBoolValues.Add(this);
            _ProblemParameterId = value.Id;
          }
          else {
            _ProblemParameterId = default(long);
          }
          SendPropertyChanged("ProblemParameter");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.ProblemParameterFloatValue")]
[KnownType(typeof(ProblemParameterFloatValue))] public partial class ProblemParameterFloatValue : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public ProblemParameterFloatValue()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Experiment = default(EntityRef<Experiment>);
      _ProblemParameter = default(EntityRef<ProblemParameter>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnProblemParameterIdChanging(long value);
    partial void OnProblemParameterIdChanged();
    private long _ProblemParameterId;
    [Column(Storage=@"_ProblemParameterId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long ProblemParameterId
    {
      get { return _ProblemParameterId; }
      set {
        if (_ProblemParameterId != value) {
          if (_ProblemParameter.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnProblemParameterIdChanging(value);
          SendPropertyChanging();
          _ProblemParameterId = value;
          SendPropertyChanged("ProblemParameterId");
          OnProblemParameterIdChanged();
        }
      }
    }
    
    partial void OnExperimentIdChanging(long value);
    partial void OnExperimentIdChanged();
    private long _ExperimentId;
    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public long ExperimentId
    {
      get { return _ExperimentId; }
      set {
        if (_ExperimentId != value) {
          if (_Experiment.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnExperimentIdChanging(value);
          SendPropertyChanging();
          _ExperimentId = value;
          SendPropertyChanged("ExperimentId");
          OnExperimentIdChanged();
        }
      }
    }
    
    partial void OnValueChanging(double value);
    partial void OnValueChanged();
    private double _Value;
    [Column(Storage=@"_Value", DbType=@"Float NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public double Value
    {
      get { return _Value; }
      set {
        if (_Value != value) {
          OnValueChanging(value);
          SendPropertyChanging();
          _Value = value;
          SendPropertyChanged("Value");
          OnValueChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<Experiment> _Experiment;
    [Association(Name=@"Experiment_ProblemParameterFloatValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public Experiment Experiment
    {
      get {
        return _Experiment.Entity;
      }
      set {
        Experiment previousValue = _Experiment.Entity;
        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Experiment.Entity = null;
            previousValue.ProblemParameterFloatValues.Remove(this);
          }
          _Experiment.Entity = value;
          if (value != null) {
            value.ProblemParameterFloatValues.Add(this);
            _ExperimentId = value.Id;
          }
          else {
            _ExperimentId = default(long);
          }
          SendPropertyChanged("Experiment");
        }
      }
    }

    private EntityRef<ProblemParameter> _ProblemParameter;
    [Association(Name=@"ProblemParameter_ProblemParameterFloatValue", Storage=@"_ProblemParameter", ThisKey=@"ProblemParameterId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public ProblemParameter ProblemParameter
    {
      get {
        return _ProblemParameter.Entity;
      }
      set {
        ProblemParameter previousValue = _ProblemParameter.Entity;
        if ((previousValue != value) || (!_ProblemParameter.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _ProblemParameter.Entity = null;
            previousValue.ProblemParameterFloatValues.Remove(this);
          }
          _ProblemParameter.Entity = value;
          if (value != null) {
            value.ProblemParameterFloatValues.Add(this);
            _ProblemParameterId = value.Id;
          }
          else {
            _ProblemParameterId = default(long);
          }
          SendPropertyChanged("ProblemParameter");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.ProblemParameterIntValue")]
[KnownType(typeof(ProblemParameterIntValue))] public partial class ProblemParameterIntValue : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public ProblemParameterIntValue()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Experiment = default(EntityRef<Experiment>);
      _ProblemParameter = default(EntityRef<ProblemParameter>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnProblemParameterIdChanging(long value);
    partial void OnProblemParameterIdChanged();
    private long _ProblemParameterId;
    [Column(Storage=@"_ProblemParameterId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long ProblemParameterId
    {
      get { return _ProblemParameterId; }
      set {
        if (_ProblemParameterId != value) {
          if (_ProblemParameter.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnProblemParameterIdChanging(value);
          SendPropertyChanging();
          _ProblemParameterId = value;
          SendPropertyChanged("ProblemParameterId");
          OnProblemParameterIdChanged();
        }
      }
    }
    
    partial void OnExperimentIdChanging(long value);
    partial void OnExperimentIdChanged();
    private long _ExperimentId;
    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public long ExperimentId
    {
      get { return _ExperimentId; }
      set {
        if (_ExperimentId != value) {
          if (_Experiment.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnExperimentIdChanging(value);
          SendPropertyChanging();
          _ExperimentId = value;
          SendPropertyChanged("ExperimentId");
          OnExperimentIdChanged();
        }
      }
    }
    
    partial void OnValueChanging(int value);
    partial void OnValueChanged();
    private int _Value;
    [Column(Storage=@"_Value", DbType=@"Int NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public int Value
    {
      get { return _Value; }
      set {
        if (_Value != value) {
          OnValueChanging(value);
          SendPropertyChanging();
          _Value = value;
          SendPropertyChanged("Value");
          OnValueChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<Experiment> _Experiment;
    [Association(Name=@"Experiment_ProblemParameterIntValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public Experiment Experiment
    {
      get {
        return _Experiment.Entity;
      }
      set {
        Experiment previousValue = _Experiment.Entity;
        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Experiment.Entity = null;
            previousValue.ProblemParameterIntValues.Remove(this);
          }
          _Experiment.Entity = value;
          if (value != null) {
            value.ProblemParameterIntValues.Add(this);
            _ExperimentId = value.Id;
          }
          else {
            _ExperimentId = default(long);
          }
          SendPropertyChanged("Experiment");
        }
      }
    }

    private EntityRef<ProblemParameter> _ProblemParameter;
    [Association(Name=@"ProblemParameter_ProblemParameterIntValue", Storage=@"_ProblemParameter", ThisKey=@"ProblemParameterId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public ProblemParameter ProblemParameter
    {
      get {
        return _ProblemParameter.Entity;
      }
      set {
        ProblemParameter previousValue = _ProblemParameter.Entity;
        if ((previousValue != value) || (!_ProblemParameter.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _ProblemParameter.Entity = null;
            previousValue.ProblemParameterIntValues.Remove(this);
          }
          _ProblemParameter.Entity = value;
          if (value != null) {
            value.ProblemParameterIntValues.Add(this);
            _ProblemParameterId = value.Id;
          }
          else {
            _ProblemParameterId = default(long);
          }
          SendPropertyChanged("ProblemParameter");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.ProblemParameterStringValue")]
[KnownType(typeof(ProblemParameterStringValue))]  public partial class ProblemParameterStringValue : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public ProblemParameterStringValue()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Experiment = default(EntityRef<Experiment>);
      _ProblemParameter = default(EntityRef<ProblemParameter>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnProblemParameterIdChanging(long value);
    partial void OnProblemParameterIdChanged();
    private long _ProblemParameterId;
    [Column(Storage=@"_ProblemParameterId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long ProblemParameterId
    {
      get { return _ProblemParameterId; }
      set {
        if (_ProblemParameterId != value) {
          if (_ProblemParameter.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnProblemParameterIdChanging(value);
          SendPropertyChanging();
          _ProblemParameterId = value;
          SendPropertyChanged("ProblemParameterId");
          OnProblemParameterIdChanged();
        }
      }
    }
    
    partial void OnExperimentIdChanging(long value);
    partial void OnExperimentIdChanged();
    private long _ExperimentId;
    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public long ExperimentId
    {
      get { return _ExperimentId; }
      set {
        if (_ExperimentId != value) {
          if (_Experiment.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnExperimentIdChanging(value);
          SendPropertyChanging();
          _ExperimentId = value;
          SendPropertyChanged("ExperimentId");
          OnExperimentIdChanged();
        }
      }
    }
    
    partial void OnValueChanging(string value);
    partial void OnValueChanged();
    private string _Value;
    [Column(Storage=@"_Value", DbType=@"NVarChar(MAX) NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public string Value
    {
      get { return _Value; }
      set {
        if (_Value != value) {
          OnValueChanging(value);
          SendPropertyChanging();
          _Value = value;
          SendPropertyChanged("Value");
          OnValueChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<Experiment> _Experiment;
    [Association(Name=@"Experiment_ProblemParameterStringValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public Experiment Experiment
    {
      get {
        return _Experiment.Entity;
      }
      set {
        Experiment previousValue = _Experiment.Entity;
        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Experiment.Entity = null;
            previousValue.ProblemParameterStringValues.Remove(this);
          }
          _Experiment.Entity = value;
          if (value != null) {
            value.ProblemParameterStringValues.Add(this);
            _ExperimentId = value.Id;
          }
          else {
            _ExperimentId = default(long);
          }
          SendPropertyChanged("Experiment");
        }
      }
    }

    private EntityRef<ProblemParameter> _ProblemParameter;
    [Association(Name=@"ProblemParameter_ProblemParameterStringValue", Storage=@"_ProblemParameter", ThisKey=@"ProblemParameterId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public ProblemParameter ProblemParameter
    {
      get {
        return _ProblemParameter.Entity;
      }
      set {
        ProblemParameter previousValue = _ProblemParameter.Entity;
        if ((previousValue != value) || (!_ProblemParameter.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _ProblemParameter.Entity = null;
            previousValue.ProblemParameterStringValues.Remove(this);
          }
          _ProblemParameter.Entity = value;
          if (value != null) {
            value.ProblemParameterStringValues.Add(this);
            _ProblemParameterId = value.Id;
          }
          else {
            _ProblemParameterId = default(long);
          }
          SendPropertyChanged("ProblemParameter");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.AlgorithmData")]
[KnownType(typeof(AlgorithmData))]  public partial class AlgorithmData : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public AlgorithmData()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Algorithm = default(EntityRef<Algorithm>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnAlgorithmIdChanging(long value);
    partial void OnAlgorithmIdChanged();
    private long _AlgorithmId;
    [Column(Storage=@"_AlgorithmId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long AlgorithmId
    {
      get { return _AlgorithmId; }
      set {
        if (_AlgorithmId != value) {
          if (_Algorithm.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnAlgorithmIdChanging(value);
          SendPropertyChanging();
          _AlgorithmId = value;
          SendPropertyChanged("AlgorithmId");
          OnAlgorithmIdChanged();
        }
      }
    }
    
    partial void OnDataChanging(Binary value);
    partial void OnDataChanged();
    private Binary _Data;
    [Column(Storage=@"_Data", DbType=@"VarBinary(MAX) NOT NULL", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public Binary Data
    {
      get { return _Data; }
      set {
        if (_Data != value) {
          OnDataChanging(value);
          SendPropertyChanging();
          _Data = value;
          SendPropertyChanged("Data");
          OnDataChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<Algorithm> _Algorithm;
    [Association(Name=@"Algorithm_AlgorithmData", Storage=@"_Algorithm", ThisKey=@"AlgorithmId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=3, EmitDefaultValue=false)]
    public Algorithm Algorithm
    {
      get {
        return _Algorithm.Entity;
      }
      set {
        Algorithm previousValue = _Algorithm.Entity;
        if ((previousValue != value) || (!_Algorithm.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Algorithm.Entity = null;
            previousValue.AlgorithmData = null;
          }
          _Algorithm.Entity = value;
          if (value != null) {
            value.AlgorithmData = this;
            _AlgorithmId = value.Id;
          }
          else {
            _AlgorithmId = default(long);
          }
          SendPropertyChanged("Algorithm");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.[User]")]
[KnownType(typeof(User))] public partial class User : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public User()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _AlgorithmUsers = new EntitySet<AlgorithmUser>(attach_AlgorithmUsers, detach_AlgorithmUsers);
      _ProblemUsers = new EntitySet<ProblemUser>(attach_ProblemUsers, detach_ProblemUsers);
      _Runs = new EntitySet<Run>(attach_Runs, detach_Runs);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnIdChanging(Guid value);
    partial void OnIdChanged();
    private Guid _Id;
    [Column(Storage=@"_Id", DbType=@"UniqueIdentifier NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public Guid Id
    {
      get { return _Id; }
      set {
        if (_Id != value) {
          OnIdChanging(value);
          SendPropertyChanging();
          _Id = value;
          SendPropertyChanged("Id");
          OnIdChanged();
        }
      }
    }
    
    partial void OnNameChanging(string value);
    partial void OnNameChanged();
    private string _Name;
    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
    [DataMember(Order=2)]
    public string Name
    {
      get { return _Name; }
      set {
        if (_Name != value) {
          OnNameChanging(value);
          SendPropertyChanging();
          _Name = value;
          SendPropertyChanged("Name");
          OnNameChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntitySet<AlgorithmUser> _AlgorithmUsers;
    [Association(Name=@"User_AlgorithmUser", Storage=@"_AlgorithmUsers", ThisKey=@"Id", OtherKey=@"UserId")]
    [DataMember(Order=3, EmitDefaultValue=false)]
    public EntitySet<AlgorithmUser> AlgorithmUsers
    {
      get {
        if (serializing && !_AlgorithmUsers.HasLoadedOrAssignedValues) {
          return null;
        }
        return _AlgorithmUsers;
      }
      set {
        _AlgorithmUsers.Assign(value);
      }
    }

    private void attach_AlgorithmUsers(AlgorithmUser entity)
    {
      SendPropertyChanging();
      entity.User = this;
    }
    
    private void detach_AlgorithmUsers(AlgorithmUser entity)
    {
      SendPropertyChanging();
      entity.User = null;
    }
    private EntitySet<ProblemUser> _ProblemUsers;
    [Association(Name=@"User_ProblemUser", Storage=@"_ProblemUsers", ThisKey=@"Id", OtherKey=@"UserId")]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public EntitySet<ProblemUser> ProblemUsers
    {
      get {
        if (serializing && !_ProblemUsers.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemUsers;
      }
      set {
        _ProblemUsers.Assign(value);
      }
    }

    private void attach_ProblemUsers(ProblemUser entity)
    {
      SendPropertyChanging();
      entity.User = this;
    }
    
    private void detach_ProblemUsers(ProblemUser entity)
    {
      SendPropertyChanging();
      entity.User = null;
    }
    private EntitySet<Run> _Runs;
    [Association(Name=@"User_Run", Storage=@"_Runs", ThisKey=@"Id", OtherKey=@"UserId")]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public EntitySet<Run> Runs
    {
      get {
        if (serializing && !_Runs.HasLoadedOrAssignedValues) {
          return null;
        }
        return _Runs;
      }
      set {
        _Runs.Assign(value);
      }
    }

    private void attach_Runs(Run entity)
    {
      SendPropertyChanging();
      entity.User = this;
    }
    
    private void detach_Runs(Run entity)
    {
      SendPropertyChanging();
      entity.User = null;
    }
    #endregion
    
    #region Serialization
    private bool serializing;
    
    [OnSerializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerializing(StreamingContext context)
    {
      serializing = true;
    }
    
    [OnSerialized()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerialized(StreamingContext context)
    {
      serializing = false;
    }
    
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.ProblemData")]
[KnownType(typeof(ProblemData))]  public partial class ProblemData : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public ProblemData()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Problem = default(EntityRef<Problem>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnProblemIdChanging(long value);
    partial void OnProblemIdChanged();
    private long _ProblemId;
    [Column(Storage=@"_ProblemId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long ProblemId
    {
      get { return _ProblemId; }
      set {
        if (_ProblemId != value) {
          if (_Problem.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnProblemIdChanging(value);
          SendPropertyChanging();
          _ProblemId = value;
          SendPropertyChanged("ProblemId");
          OnProblemIdChanged();
        }
      }
    }
    
    partial void OnDataChanging(Binary value);
    partial void OnDataChanged();
    private Binary _Data;
    [Column(Storage=@"_Data", DbType=@"VarBinary(MAX) NOT NULL", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public Binary Data
    {
      get { return _Data; }
      set {
        if (_Data != value) {
          OnDataChanging(value);
          SendPropertyChanging();
          _Data = value;
          SendPropertyChanged("Data");
          OnDataChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<Problem> _Problem;
    [Association(Name=@"Problem_ProblemData", Storage=@"_Problem", ThisKey=@"ProblemId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=3, EmitDefaultValue=false)]
    public Problem Problem
    {
      get {
        return _Problem.Entity;
      }
      set {
        Problem previousValue = _Problem.Entity;
        if ((previousValue != value) || (!_Problem.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Problem.Entity = null;
            previousValue.ProblemData = null;
          }
          _Problem.Entity = value;
          if (value != null) {
            value.ProblemData = this;
            _ProblemId = value.Id;
          }
          else {
            _ProblemId = default(long);
          }
          SendPropertyChanged("Problem");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.AlgorithmUser")]
[KnownType(typeof(AlgorithmUser))]  public partial class AlgorithmUser : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public AlgorithmUser()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Algorithm = default(EntityRef<Algorithm>);
      _User = default(EntityRef<User>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnAlgorithmIdChanging(long value);
    partial void OnAlgorithmIdChanged();
    private long _AlgorithmId;
    [Column(Storage=@"_AlgorithmId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long AlgorithmId
    {
      get { return _AlgorithmId; }
      set {
        if (_AlgorithmId != value) {
          if (_Algorithm.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnAlgorithmIdChanging(value);
          SendPropertyChanging();
          _AlgorithmId = value;
          SendPropertyChanged("AlgorithmId");
          OnAlgorithmIdChanged();
        }
      }
    }
    
    partial void OnUserIdChanging(Guid value);
    partial void OnUserIdChanged();
    private Guid _UserId;
    [Column(Storage=@"_UserId", DbType=@"UniqueIdentifier NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public Guid UserId
    {
      get { return _UserId; }
      set {
        if (_UserId != value) {
          if (_User.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnUserIdChanging(value);
          SendPropertyChanging();
          _UserId = value;
          SendPropertyChanged("UserId");
          OnUserIdChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<Algorithm> _Algorithm;
    [Association(Name=@"Algorithm_AlgorithmUser", Storage=@"_Algorithm", ThisKey=@"AlgorithmId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=3, EmitDefaultValue=false)]
    public Algorithm Algorithm
    {
      get {
        return _Algorithm.Entity;
      }
      set {
        Algorithm previousValue = _Algorithm.Entity;
        if ((previousValue != value) || (!_Algorithm.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Algorithm.Entity = null;
            previousValue.AlgorithmUsers.Remove(this);
          }
          _Algorithm.Entity = value;
          if (value != null) {
            value.AlgorithmUsers.Add(this);
            _AlgorithmId = value.Id;
          }
          else {
            _AlgorithmId = default(long);
          }
          SendPropertyChanged("Algorithm");
        }
      }
    }

    private EntityRef<User> _User;
    [Association(Name=@"User_AlgorithmUser", Storage=@"_User", ThisKey=@"UserId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public User User
    {
      get {
        return _User.Entity;
      }
      set {
        User previousValue = _User.Entity;
        if ((previousValue != value) || (!_User.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _User.Entity = null;
            previousValue.AlgorithmUsers.Remove(this);
          }
          _User.Entity = value;
          if (value != null) {
            value.AlgorithmUsers.Add(this);
            _UserId = value.Id;
          }
          else {
            _UserId = default(Guid);
          }
          SendPropertyChanged("User");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.ProblemUser")]
[KnownType(typeof(ProblemUser))]  public partial class ProblemUser : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public ProblemUser()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Problem = default(EntityRef<Problem>);
      _User = default(EntityRef<User>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnProblemIdChanging(long value);
    partial void OnProblemIdChanged();
    private long _ProblemId;
    [Column(Storage=@"_ProblemId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long ProblemId
    {
      get { return _ProblemId; }
      set {
        if (_ProblemId != value) {
          if (_Problem.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnProblemIdChanging(value);
          SendPropertyChanging();
          _ProblemId = value;
          SendPropertyChanged("ProblemId");
          OnProblemIdChanged();
        }
      }
    }
    
    partial void OnUserIdChanging(Guid value);
    partial void OnUserIdChanged();
    private Guid _UserId;
    [Column(Storage=@"_UserId", DbType=@"UniqueIdentifier NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public Guid UserId
    {
      get { return _UserId; }
      set {
        if (_UserId != value) {
          if (_User.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnUserIdChanging(value);
          SendPropertyChanging();
          _UserId = value;
          SendPropertyChanged("UserId");
          OnUserIdChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<Problem> _Problem;
    [Association(Name=@"Problem_ProblemUser", Storage=@"_Problem", ThisKey=@"ProblemId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=3, EmitDefaultValue=false)]
    public Problem Problem
    {
      get {
        return _Problem.Entity;
      }
      set {
        Problem previousValue = _Problem.Entity;
        if ((previousValue != value) || (!_Problem.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Problem.Entity = null;
            previousValue.ProblemUsers.Remove(this);
          }
          _Problem.Entity = value;
          if (value != null) {
            value.ProblemUsers.Add(this);
            _ProblemId = value.Id;
          }
          else {
            _ProblemId = default(long);
          }
          SendPropertyChanged("Problem");
        }
      }
    }

    private EntityRef<User> _User;
    [Association(Name=@"User_ProblemUser", Storage=@"_User", ThisKey=@"UserId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public User User
    {
      get {
        return _User.Entity;
      }
      set {
        User previousValue = _User.Entity;
        if ((previousValue != value) || (!_User.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _User.Entity = null;
            previousValue.ProblemUsers.Remove(this);
          }
          _User.Entity = value;
          if (value != null) {
            value.ProblemUsers.Add(this);
            _UserId = value.Id;
          }
          else {
            _UserId = default(Guid);
          }
          SendPropertyChanged("User");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.Platform")]
[KnownType(typeof(Platform))] public partial class Platform : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public Platform()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Algorithms = new EntitySet<Algorithm>(attach_Algorithms, detach_Algorithms);
      _Problems = new EntitySet<Problem>(attach_Problems, detach_Problems);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnIdChanging(long value);
    partial void OnIdChanged();
    private long _Id;
    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long Id
    {
      get { return _Id; }
      set {
        if (_Id != value) {
          OnIdChanging(value);
          SendPropertyChanging();
          _Id = value;
          SendPropertyChanged("Id");
          OnIdChanged();
        }
      }
    }
    
    partial void OnNameChanging(string value);
    partial void OnNameChanged();
    private string _Name;
    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
    [DataMember(Order=2)]
    public string Name
    {
      get { return _Name; }
      set {
        if (_Name != value) {
          OnNameChanging(value);
          SendPropertyChanging();
          _Name = value;
          SendPropertyChanged("Name");
          OnNameChanged();
        }
      }
    }
    
    partial void OnDescriptionChanging(string value);
    partial void OnDescriptionChanged();
    private string _Description;
    [Column(Storage=@"_Description", DbType=@"NVarChar(MAX)")]
    [DataMember(Order=3)]
    public string Description
    {
      get { return _Description; }
      set {
        if (_Description != value) {
          OnDescriptionChanging(value);
          SendPropertyChanging();
          _Description = value;
          SendPropertyChanged("Description");
          OnDescriptionChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntitySet<Algorithm> _Algorithms;
    [Association(Name=@"Platform_Algorithm", Storage=@"_Algorithms", ThisKey=@"Id", OtherKey=@"PlatformId")]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public EntitySet<Algorithm> Algorithms
    {
      get {
        if (serializing && !_Algorithms.HasLoadedOrAssignedValues) {
          return null;
        }
        return _Algorithms;
      }
      set {
        _Algorithms.Assign(value);
      }
    }

    private void attach_Algorithms(Algorithm entity)
    {
      SendPropertyChanging();
      entity.Platform = this;
    }
    
    private void detach_Algorithms(Algorithm entity)
    {
      SendPropertyChanging();
      entity.Platform = null;
    }
    private EntitySet<Problem> _Problems;
    [Association(Name=@"Platform_Problem", Storage=@"_Problems", ThisKey=@"Id", OtherKey=@"PlatformId")]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public EntitySet<Problem> Problems
    {
      get {
        if (serializing && !_Problems.HasLoadedOrAssignedValues) {
          return null;
        }
        return _Problems;
      }
      set {
        _Problems.Assign(value);
      }
    }

    private void attach_Problems(Problem entity)
    {
      SendPropertyChanging();
      entity.Platform = this;
    }
    
    private void detach_Problems(Problem entity)
    {
      SendPropertyChanging();
      entity.Platform = null;
    }
    #endregion
    
    #region Serialization
    private bool serializing;
    
    [OnSerializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerializing(StreamingContext context)
    {
      serializing = true;
    }
    
    [OnSerialized()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerialized(StreamingContext context)
    {
      serializing = false;
    }
    
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.SolutionRepresentation")]
[KnownType(typeof(SolutionRepresentation))] public partial class SolutionRepresentation : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public SolutionRepresentation()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Problems = new EntitySet<Problem>(attach_Problems, detach_Problems);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnIdChanging(long value);
    partial void OnIdChanged();
    private long _Id;
    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long Id
    {
      get { return _Id; }
      set {
        if (_Id != value) {
          OnIdChanging(value);
          SendPropertyChanging();
          _Id = value;
          SendPropertyChanged("Id");
          OnIdChanged();
        }
      }
    }
    
    partial void OnNameChanging(string value);
    partial void OnNameChanged();
    private string _Name;
    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
    [DataMember(Order=2)]
    public string Name
    {
      get { return _Name; }
      set {
        if (_Name != value) {
          OnNameChanging(value);
          SendPropertyChanging();
          _Name = value;
          SendPropertyChanged("Name");
          OnNameChanged();
        }
      }
    }
    
    partial void OnDescriptionChanging(string value);
    partial void OnDescriptionChanged();
    private string _Description;
    [Column(Storage=@"_Description", DbType=@"NVarChar(MAX)")]
    [DataMember(Order=3)]
    public string Description
    {
      get { return _Description; }
      set {
        if (_Description != value) {
          OnDescriptionChanging(value);
          SendPropertyChanging();
          _Description = value;
          SendPropertyChanged("Description");
          OnDescriptionChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntitySet<Problem> _Problems;
    [Association(Name=@"SolutionRepresentation_Problem", Storage=@"_Problems", ThisKey=@"Id", OtherKey=@"SolutionRepresentationId")]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public EntitySet<Problem> Problems
    {
      get {
        if (serializing && !_Problems.HasLoadedOrAssignedValues) {
          return null;
        }
        return _Problems;
      }
      set {
        _Problems.Assign(value);
      }
    }

    private void attach_Problems(Problem entity)
    {
      SendPropertyChanging();
      entity.SolutionRepresentation = this;
    }
    
    private void detach_Problems(Problem entity)
    {
      SendPropertyChanging();
      entity.SolutionRepresentation = null;
    }
    #endregion
    
    #region Serialization
    private bool serializing;
    
    [OnSerializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerializing(StreamingContext context)
    {
      serializing = true;
    }
    
    [OnSerialized()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerialized(StreamingContext context)
    {
      serializing = false;
    }
    
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.Run")]
[KnownType(typeof(Run))]  public partial class Run : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public Run()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _ResultBlobValues = new EntitySet<ResultBlobValue>(attach_ResultBlobValues, detach_ResultBlobValues);
      _ResultBoolValues = new EntitySet<ResultBoolValue>(attach_ResultBoolValues, detach_ResultBoolValues);
      _ResultFloatValues = new EntitySet<ResultFloatValue>(attach_ResultFloatValues, detach_ResultFloatValues);
      _ResultIntValues = new EntitySet<ResultIntValue>(attach_ResultIntValues, detach_ResultIntValues);
      _ResultStringValues = new EntitySet<ResultStringValue>(attach_ResultStringValues, detach_ResultStringValues);
      _Experiment = default(EntityRef<Experiment>);
      _User = default(EntityRef<User>);
      _Client = default(EntityRef<Client>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnIdChanging(long value);
    partial void OnIdChanged();
    private long _Id;
    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long Id
    {
      get { return _Id; }
      set {
        if (_Id != value) {
          OnIdChanging(value);
          SendPropertyChanging();
          _Id = value;
          SendPropertyChanged("Id");
          OnIdChanged();
        }
      }
    }
    
    partial void OnExperimentIdChanging(long value);
    partial void OnExperimentIdChanged();
    private long _ExperimentId;
    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
    [DataMember(Order=2)]
    public long ExperimentId
    {
      get { return _ExperimentId; }
      set {
        if (_ExperimentId != value) {
          if (_Experiment.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnExperimentIdChanging(value);
          SendPropertyChanging();
          _ExperimentId = value;
          SendPropertyChanged("ExperimentId");
          OnExperimentIdChanged();
        }
      }
    }
    
    partial void OnRandomSeedChanging(int value);
    partial void OnRandomSeedChanged();
    private int _RandomSeed;
    [Column(Storage=@"_RandomSeed", DbType=@"Int NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public int RandomSeed
    {
      get { return _RandomSeed; }
      set {
        if (_RandomSeed != value) {
          OnRandomSeedChanging(value);
          SendPropertyChanging();
          _RandomSeed = value;
          SendPropertyChanged("RandomSeed");
          OnRandomSeedChanged();
        }
      }
    }
    
    partial void OnFinishedDateChanging(DateTime? value);
    partial void OnFinishedDateChanged();
    private DateTime? _FinishedDate;
    [Column(Storage=@"_FinishedDate", DbType=@"DateTime2")]
    [DataMember(Order=4)]
    public DateTime? FinishedDate
    {
      get { return _FinishedDate; }
      set {
        if (_FinishedDate != value) {
          OnFinishedDateChanging(value);
          SendPropertyChanging();
          _FinishedDate = value;
          SendPropertyChanged("FinishedDate");
          OnFinishedDateChanged();
        }
      }
    }
    
    partial void OnUserIdChanging(Guid value);
    partial void OnUserIdChanged();
    private Guid _UserId;
    [Column(Storage=@"_UserId", DbType=@"UniqueIdentifier NOT NULL", CanBeNull=false)]
    [DataMember(Order=5)]
    public Guid UserId
    {
      get { return _UserId; }
      set {
        if (_UserId != value) {
          if (_User.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnUserIdChanging(value);
          SendPropertyChanging();
          _UserId = value;
          SendPropertyChanged("UserId");
          OnUserIdChanged();
        }
      }
    }
    
    partial void OnClientIdChanging(Guid value);
    partial void OnClientIdChanged();
    private Guid _ClientId;
    [Column(Storage=@"_ClientId", DbType=@"UniqueIdentifier NOT NULL", CanBeNull=false)]
    [DataMember(Order=6)]
    public Guid ClientId
    {
      get { return _ClientId; }
      set {
        if (_ClientId != value) {
          if (_Client.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnClientIdChanging(value);
          SendPropertyChanging();
          _ClientId = value;
          SendPropertyChanged("ClientId");
          OnClientIdChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntitySet<ResultBlobValue> _ResultBlobValues;
    [Association(Name=@"Run_ResultBlobValue", Storage=@"_ResultBlobValues", ThisKey=@"Id", OtherKey=@"RunId")]
    [DataMember(Order=7, EmitDefaultValue=false)]
    public EntitySet<ResultBlobValue> ResultBlobValues
    {
      get {
        if (serializing && !_ResultBlobValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ResultBlobValues;
      }
      set {
        _ResultBlobValues.Assign(value);
      }
    }

    private void attach_ResultBlobValues(ResultBlobValue entity)
    {
      SendPropertyChanging();
      entity.Run = this;
    }
    
    private void detach_ResultBlobValues(ResultBlobValue entity)
    {
      SendPropertyChanging();
      entity.Run = null;
    }
    private EntitySet<ResultBoolValue> _ResultBoolValues;
    [Association(Name=@"Run_ResultBoolValue", Storage=@"_ResultBoolValues", ThisKey=@"Id", OtherKey=@"RunId")]
    [DataMember(Order=8, EmitDefaultValue=false)]
    public EntitySet<ResultBoolValue> ResultBoolValues
    {
      get {
        if (serializing && !_ResultBoolValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ResultBoolValues;
      }
      set {
        _ResultBoolValues.Assign(value);
      }
    }

    private void attach_ResultBoolValues(ResultBoolValue entity)
    {
      SendPropertyChanging();
      entity.Run = this;
    }
    
    private void detach_ResultBoolValues(ResultBoolValue entity)
    {
      SendPropertyChanging();
      entity.Run = null;
    }
    private EntitySet<ResultFloatValue> _ResultFloatValues;
    [Association(Name=@"Run_ResultFloatValue", Storage=@"_ResultFloatValues", ThisKey=@"Id", OtherKey=@"RunId")]
    [DataMember(Order=9, EmitDefaultValue=false)]
    public EntitySet<ResultFloatValue> ResultFloatValues
    {
      get {
        if (serializing && !_ResultFloatValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ResultFloatValues;
      }
      set {
        _ResultFloatValues.Assign(value);
      }
    }

    private void attach_ResultFloatValues(ResultFloatValue entity)
    {
      SendPropertyChanging();
      entity.Run = this;
    }
    
    private void detach_ResultFloatValues(ResultFloatValue entity)
    {
      SendPropertyChanging();
      entity.Run = null;
    }
    private EntitySet<ResultIntValue> _ResultIntValues;
    [Association(Name=@"Run_ResultIntValue", Storage=@"_ResultIntValues", ThisKey=@"Id", OtherKey=@"RunId")]
    [DataMember(Order=10, EmitDefaultValue=false)]
    public EntitySet<ResultIntValue> ResultIntValues
    {
      get {
        if (serializing && !_ResultIntValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ResultIntValues;
      }
      set {
        _ResultIntValues.Assign(value);
      }
    }

    private void attach_ResultIntValues(ResultIntValue entity)
    {
      SendPropertyChanging();
      entity.Run = this;
    }
    
    private void detach_ResultIntValues(ResultIntValue entity)
    {
      SendPropertyChanging();
      entity.Run = null;
    }
    private EntitySet<ResultStringValue> _ResultStringValues;
    [Association(Name=@"Run_ResultStringValue", Storage=@"_ResultStringValues", ThisKey=@"Id", OtherKey=@"RunId")]
    [DataMember(Order=11, EmitDefaultValue=false)]
    public EntitySet<ResultStringValue> ResultStringValues
    {
      get {
        if (serializing && !_ResultStringValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ResultStringValues;
      }
      set {
        _ResultStringValues.Assign(value);
      }
    }

    private void attach_ResultStringValues(ResultStringValue entity)
    {
      SendPropertyChanging();
      entity.Run = this;
    }
    
    private void detach_ResultStringValues(ResultStringValue entity)
    {
      SendPropertyChanging();
      entity.Run = null;
    }
    private EntityRef<Experiment> _Experiment;
    [Association(Name=@"Experiment_Run", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=12, EmitDefaultValue=false)]
    public Experiment Experiment
    {
      get {
        if (serializing && !_Experiment.HasLoadedOrAssignedValue) {
          return null;
        }
        return _Experiment.Entity;
      }
      set {
        Experiment previousValue = _Experiment.Entity;
        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Experiment.Entity = null;
            previousValue.Runs.Remove(this);
          }
          _Experiment.Entity = value;
          if (value != null) {
            value.Runs.Add(this);
            _ExperimentId = value.Id;
          }
          else {
            _ExperimentId = default(long);
          }
          SendPropertyChanged("Experiment");
        }
      }
    }

    private EntityRef<User> _User;
    [Association(Name=@"User_Run", Storage=@"_User", ThisKey=@"UserId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=13, EmitDefaultValue=false)]
    public User User
    {
      get {
        if (serializing && !_User.HasLoadedOrAssignedValue) {
          return null;
        }
        return _User.Entity;
      }
      set {
        User previousValue = _User.Entity;
        if ((previousValue != value) || (!_User.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _User.Entity = null;
            previousValue.Runs.Remove(this);
          }
          _User.Entity = value;
          if (value != null) {
            value.Runs.Add(this);
            _UserId = value.Id;
          }
          else {
            _UserId = default(Guid);
          }
          SendPropertyChanged("User");
        }
      }
    }

    private EntityRef<Client> _Client;
    [Association(Name=@"Client_Run", Storage=@"_Client", ThisKey=@"ClientId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=14, EmitDefaultValue=false)]
    public Client Client
    {
      get {
        if (serializing && !_Client.HasLoadedOrAssignedValue) {
          return null;
        }
        return _Client.Entity;
      }
      set {
        Client previousValue = _Client.Entity;
        if ((previousValue != value) || (!_Client.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Client.Entity = null;
            previousValue.Runs.Remove(this);
          }
          _Client.Entity = value;
          if (value != null) {
            value.Runs.Add(this);
            _ClientId = value.Id;
          }
          else {
            _ClientId = default(Guid);
          }
          SendPropertyChanged("Client");
        }
      }
    }

    #endregion
    
    #region Serialization
    private bool serializing;
    
    [OnSerializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerializing(StreamingContext context)
    {
      serializing = true;
    }
    
    [OnSerialized()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerialized(StreamingContext context)
    {
      serializing = false;
    }
    
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.Result")]
[KnownType(typeof(Result))] public partial class Result : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public Result()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _ResultBlobValues = new EntitySet<ResultBlobValue>(attach_ResultBlobValues, detach_ResultBlobValues);
      _ResultBoolValues = new EntitySet<ResultBoolValue>(attach_ResultBoolValues, detach_ResultBoolValues);
      _ResultFloatValues = new EntitySet<ResultFloatValue>(attach_ResultFloatValues, detach_ResultFloatValues);
      _ResultIntValues = new EntitySet<ResultIntValue>(attach_ResultIntValues, detach_ResultIntValues);
      _ResultStringValues = new EntitySet<ResultStringValue>(attach_ResultStringValues, detach_ResultStringValues);
      _Algorithm = default(EntityRef<Algorithm>);
      _DataType = default(EntityRef<DataType>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnIdChanging(long value);
    partial void OnIdChanged();
    private long _Id;
    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long Id
    {
      get { return _Id; }
      set {
        if (_Id != value) {
          OnIdChanging(value);
          SendPropertyChanging();
          _Id = value;
          SendPropertyChanged("Id");
          OnIdChanged();
        }
      }
    }
    
    partial void OnAlgorithmIdChanging(long value);
    partial void OnAlgorithmIdChanged();
    private long _AlgorithmId;
    [Column(Storage=@"_AlgorithmId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
    [DataMember(Order=2)]
    public long AlgorithmId
    {
      get { return _AlgorithmId; }
      set {
        if (_AlgorithmId != value) {
          if (_Algorithm.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnAlgorithmIdChanging(value);
          SendPropertyChanging();
          _AlgorithmId = value;
          SendPropertyChanged("AlgorithmId");
          OnAlgorithmIdChanged();
        }
      }
    }
    
    partial void OnNameChanging(string value);
    partial void OnNameChanged();
    private string _Name;
    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public string Name
    {
      get { return _Name; }
      set {
        if (_Name != value) {
          OnNameChanging(value);
          SendPropertyChanging();
          _Name = value;
          SendPropertyChanged("Name");
          OnNameChanged();
        }
      }
    }
    
    partial void OnAliasChanging(string value);
    partial void OnAliasChanged();
    private string _Alias;
    [Column(Storage=@"_Alias", DbType=@"NVarChar(200)")]
    [DataMember(Order=4)]
    public string Alias
    {
      get { return _Alias; }
      set {
        if (_Alias != value) {
          OnAliasChanging(value);
          SendPropertyChanging();
          _Alias = value;
          SendPropertyChanged("Alias");
          OnAliasChanged();
        }
      }
    }
    
    partial void OnDescriptionChanging(string value);
    partial void OnDescriptionChanged();
    private string _Description;
    [Column(Storage=@"_Description", DbType=@"NVarChar(MAX)")]
    [DataMember(Order=5)]
    public string Description
    {
      get { return _Description; }
      set {
        if (_Description != value) {
          OnDescriptionChanging(value);
          SendPropertyChanging();
          _Description = value;
          SendPropertyChanged("Description");
          OnDescriptionChanged();
        }
      }
    }
    
    partial void OnDataTypeIdChanging(long value);
    partial void OnDataTypeIdChanged();
    private long _DataTypeId;
    [Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
    [DataMember(Order=6)]
    public long DataTypeId
    {
      get { return _DataTypeId; }
      set {
        if (_DataTypeId != value) {
          if (_DataType.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnDataTypeIdChanging(value);
          SendPropertyChanging();
          _DataTypeId = value;
          SendPropertyChanged("DataTypeId");
          OnDataTypeIdChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntitySet<ResultBlobValue> _ResultBlobValues;
    [Association(Name=@"Result_ResultBlobValue", Storage=@"_ResultBlobValues", ThisKey=@"Id", OtherKey=@"ResultId")]
    [DataMember(Order=7, EmitDefaultValue=false)]
    public EntitySet<ResultBlobValue> ResultBlobValues
    {
      get {
        if (serializing && !_ResultBlobValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ResultBlobValues;
      }
      set {
        _ResultBlobValues.Assign(value);
      }
    }

    private void attach_ResultBlobValues(ResultBlobValue entity)
    {
      SendPropertyChanging();
      entity.Result = this;
    }
    
    private void detach_ResultBlobValues(ResultBlobValue entity)
    {
      SendPropertyChanging();
      entity.Result = null;
    }
    private EntitySet<ResultBoolValue> _ResultBoolValues;
    [Association(Name=@"Result_ResultBoolValue", Storage=@"_ResultBoolValues", ThisKey=@"Id", OtherKey=@"ResultId")]
    [DataMember(Order=8, EmitDefaultValue=false)]
    public EntitySet<ResultBoolValue> ResultBoolValues
    {
      get {
        if (serializing && !_ResultBoolValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ResultBoolValues;
      }
      set {
        _ResultBoolValues.Assign(value);
      }
    }

    private void attach_ResultBoolValues(ResultBoolValue entity)
    {
      SendPropertyChanging();
      entity.Result = this;
    }
    
    private void detach_ResultBoolValues(ResultBoolValue entity)
    {
      SendPropertyChanging();
      entity.Result = null;
    }
    private EntitySet<ResultFloatValue> _ResultFloatValues;
    [Association(Name=@"Result_ResultFloatValue", Storage=@"_ResultFloatValues", ThisKey=@"Id", OtherKey=@"ResultId")]
    [DataMember(Order=9, EmitDefaultValue=false)]
    public EntitySet<ResultFloatValue> ResultFloatValues
    {
      get {
        if (serializing && !_ResultFloatValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ResultFloatValues;
      }
      set {
        _ResultFloatValues.Assign(value);
      }
    }

    private void attach_ResultFloatValues(ResultFloatValue entity)
    {
      SendPropertyChanging();
      entity.Result = this;
    }
    
    private void detach_ResultFloatValues(ResultFloatValue entity)
    {
      SendPropertyChanging();
      entity.Result = null;
    }
    private EntitySet<ResultIntValue> _ResultIntValues;
    [Association(Name=@"Result_ResultIntValue", Storage=@"_ResultIntValues", ThisKey=@"Id", OtherKey=@"ResultId")]
    [DataMember(Order=10, EmitDefaultValue=false)]
    public EntitySet<ResultIntValue> ResultIntValues
    {
      get {
        if (serializing && !_ResultIntValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ResultIntValues;
      }
      set {
        _ResultIntValues.Assign(value);
      }
    }

    private void attach_ResultIntValues(ResultIntValue entity)
    {
      SendPropertyChanging();
      entity.Result = this;
    }
    
    private void detach_ResultIntValues(ResultIntValue entity)
    {
      SendPropertyChanging();
      entity.Result = null;
    }
    private EntitySet<ResultStringValue> _ResultStringValues;
    [Association(Name=@"Result_ResultStringValue", Storage=@"_ResultStringValues", ThisKey=@"Id", OtherKey=@"ResultId")]
    [DataMember(Order=11, EmitDefaultValue=false)]
    public EntitySet<ResultStringValue> ResultStringValues
    {
      get {
        if (serializing && !_ResultStringValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ResultStringValues;
      }
      set {
        _ResultStringValues.Assign(value);
      }
    }

    private void attach_ResultStringValues(ResultStringValue entity)
    {
      SendPropertyChanging();
      entity.Result = this;
    }
    
    private void detach_ResultStringValues(ResultStringValue entity)
    {
      SendPropertyChanging();
      entity.Result = null;
    }
    private EntityRef<Algorithm> _Algorithm;
    [Association(Name=@"Algorithm_Result", Storage=@"_Algorithm", ThisKey=@"AlgorithmId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=12, EmitDefaultValue=false)]
    public Algorithm Algorithm
    {
      get {
        if (serializing && !_Algorithm.HasLoadedOrAssignedValue) {
          return null;
        }
        return _Algorithm.Entity;
      }
      set {
        Algorithm previousValue = _Algorithm.Entity;
        if ((previousValue != value) || (!_Algorithm.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Algorithm.Entity = null;
            previousValue.Results.Remove(this);
          }
          _Algorithm.Entity = value;
          if (value != null) {
            value.Results.Add(this);
            _AlgorithmId = value.Id;
          }
          else {
            _AlgorithmId = default(long);
          }
          SendPropertyChanged("Algorithm");
        }
      }
    }

    private EntityRef<DataType> _DataType;
    [Association(Name=@"DataType_Result", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=13, EmitDefaultValue=false)]
    public DataType DataType
    {
      get {
        if (serializing && !_DataType.HasLoadedOrAssignedValue) {
          return null;
        }
        return _DataType.Entity;
      }
      set {
        DataType previousValue = _DataType.Entity;
        if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _DataType.Entity = null;
            previousValue.Results.Remove(this);
          }
          _DataType.Entity = value;
          if (value != null) {
            value.Results.Add(this);
            _DataTypeId = value.Id;
          }
          else {
            _DataTypeId = default(long);
          }
          SendPropertyChanged("DataType");
        }
      }
    }

    #endregion
    
    #region Serialization
    private bool serializing;
    
    [OnSerializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerializing(StreamingContext context)
    {
      serializing = true;
    }
    
    [OnSerialized()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerialized(StreamingContext context)
    {
      serializing = false;
    }
    
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.ResultBlobValue")]
[KnownType(typeof(ResultBlobValue))]  public partial class ResultBlobValue : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public ResultBlobValue()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Result = default(EntityRef<Result>);
      _Run = default(EntityRef<Run>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnResultIdChanging(long value);
    partial void OnResultIdChanged();
    private long _ResultId;
    [Column(Storage=@"_ResultId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long ResultId
    {
      get { return _ResultId; }
      set {
        if (_ResultId != value) {
          if (_Result.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnResultIdChanging(value);
          SendPropertyChanging();
          _ResultId = value;
          SendPropertyChanged("ResultId");
          OnResultIdChanged();
        }
      }
    }
    
    partial void OnRunIdChanging(long value);
    partial void OnRunIdChanged();
    private long _RunId;
    [Column(Storage=@"_RunId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public long RunId
    {
      get { return _RunId; }
      set {
        if (_RunId != value) {
          if (_Run.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnRunIdChanging(value);
          SendPropertyChanging();
          _RunId = value;
          SendPropertyChanged("RunId");
          OnRunIdChanged();
        }
      }
    }
    
    partial void OnValueChanging(Binary value);
    partial void OnValueChanged();
    private Binary _Value;
    [Column(Storage=@"_Value", DbType=@"VarBinary(MAX) NOT NULL", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=3)]
    public Binary Value
    {
      get { return _Value; }
      set {
        if (_Value != value) {
          OnValueChanging(value);
          SendPropertyChanging();
          _Value = value;
          SendPropertyChanged("Value");
          OnValueChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<Result> _Result;
    [Association(Name=@"Result_ResultBlobValue", Storage=@"_Result", ThisKey=@"ResultId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public Result Result
    {
      get {
        return _Result.Entity;
      }
      set {
        Result previousValue = _Result.Entity;
        if ((previousValue != value) || (!_Result.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Result.Entity = null;
            previousValue.ResultBlobValues.Remove(this);
          }
          _Result.Entity = value;
          if (value != null) {
            value.ResultBlobValues.Add(this);
            _ResultId = value.Id;
          }
          else {
            _ResultId = default(long);
          }
          SendPropertyChanged("Result");
        }
      }
    }

    private EntityRef<Run> _Run;
    [Association(Name=@"Run_ResultBlobValue", Storage=@"_Run", ThisKey=@"RunId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public Run Run
    {
      get {
        return _Run.Entity;
      }
      set {
        Run previousValue = _Run.Entity;
        if ((previousValue != value) || (!_Run.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Run.Entity = null;
            previousValue.ResultBlobValues.Remove(this);
          }
          _Run.Entity = value;
          if (value != null) {
            value.ResultBlobValues.Add(this);
            _RunId = value.Id;
          }
          else {
            _RunId = default(long);
          }
          SendPropertyChanged("Run");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.ResultBoolValue")]
[KnownType(typeof(ResultBoolValue))]  public partial class ResultBoolValue : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public ResultBoolValue()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Result = default(EntityRef<Result>);
      _Run = default(EntityRef<Run>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnResultIdChanging(long value);
    partial void OnResultIdChanged();
    private long _ResultId;
    [Column(Storage=@"_ResultId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long ResultId
    {
      get { return _ResultId; }
      set {
        if (_ResultId != value) {
          if (_Result.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnResultIdChanging(value);
          SendPropertyChanging();
          _ResultId = value;
          SendPropertyChanged("ResultId");
          OnResultIdChanged();
        }
      }
    }
    
    partial void OnRunIdChanging(long value);
    partial void OnRunIdChanged();
    private long _RunId;
    [Column(Storage=@"_RunId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public long RunId
    {
      get { return _RunId; }
      set {
        if (_RunId != value) {
          if (_Run.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnRunIdChanging(value);
          SendPropertyChanging();
          _RunId = value;
          SendPropertyChanged("RunId");
          OnRunIdChanged();
        }
      }
    }
    
    partial void OnValueChanging(bool value);
    partial void OnValueChanged();
    private bool _Value;
    [Column(Storage=@"_Value", DbType=@"Bit NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public bool Value
    {
      get { return _Value; }
      set {
        if (_Value != value) {
          OnValueChanging(value);
          SendPropertyChanging();
          _Value = value;
          SendPropertyChanged("Value");
          OnValueChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<Result> _Result;
    [Association(Name=@"Result_ResultBoolValue", Storage=@"_Result", ThisKey=@"ResultId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public Result Result
    {
      get {
        return _Result.Entity;
      }
      set {
        Result previousValue = _Result.Entity;
        if ((previousValue != value) || (!_Result.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Result.Entity = null;
            previousValue.ResultBoolValues.Remove(this);
          }
          _Result.Entity = value;
          if (value != null) {
            value.ResultBoolValues.Add(this);
            _ResultId = value.Id;
          }
          else {
            _ResultId = default(long);
          }
          SendPropertyChanged("Result");
        }
      }
    }

    private EntityRef<Run> _Run;
    [Association(Name=@"Run_ResultBoolValue", Storage=@"_Run", ThisKey=@"RunId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public Run Run
    {
      get {
        return _Run.Entity;
      }
      set {
        Run previousValue = _Run.Entity;
        if ((previousValue != value) || (!_Run.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Run.Entity = null;
            previousValue.ResultBoolValues.Remove(this);
          }
          _Run.Entity = value;
          if (value != null) {
            value.ResultBoolValues.Add(this);
            _RunId = value.Id;
          }
          else {
            _RunId = default(long);
          }
          SendPropertyChanged("Run");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.ResultFloatValue")]
[KnownType(typeof(ResultFloatValue))] public partial class ResultFloatValue : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public ResultFloatValue()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Result = default(EntityRef<Result>);
      _Run = default(EntityRef<Run>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnResultIdChanging(long value);
    partial void OnResultIdChanged();
    private long _ResultId;
    [Column(Storage=@"_ResultId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long ResultId
    {
      get { return _ResultId; }
      set {
        if (_ResultId != value) {
          if (_Result.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnResultIdChanging(value);
          SendPropertyChanging();
          _ResultId = value;
          SendPropertyChanged("ResultId");
          OnResultIdChanged();
        }
      }
    }
    
    partial void OnRunIdChanging(long value);
    partial void OnRunIdChanged();
    private long _RunId;
    [Column(Storage=@"_RunId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public long RunId
    {
      get { return _RunId; }
      set {
        if (_RunId != value) {
          if (_Run.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnRunIdChanging(value);
          SendPropertyChanging();
          _RunId = value;
          SendPropertyChanged("RunId");
          OnRunIdChanged();
        }
      }
    }
    
    partial void OnValueChanging(double value);
    partial void OnValueChanged();
    private double _Value;
    [Column(Storage=@"_Value", DbType=@"Float NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public double Value
    {
      get { return _Value; }
      set {
        if (_Value != value) {
          OnValueChanging(value);
          SendPropertyChanging();
          _Value = value;
          SendPropertyChanged("Value");
          OnValueChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<Result> _Result;
    [Association(Name=@"Result_ResultFloatValue", Storage=@"_Result", ThisKey=@"ResultId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public Result Result
    {
      get {
        return _Result.Entity;
      }
      set {
        Result previousValue = _Result.Entity;
        if ((previousValue != value) || (!_Result.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Result.Entity = null;
            previousValue.ResultFloatValues.Remove(this);
          }
          _Result.Entity = value;
          if (value != null) {
            value.ResultFloatValues.Add(this);
            _ResultId = value.Id;
          }
          else {
            _ResultId = default(long);
          }
          SendPropertyChanged("Result");
        }
      }
    }

    private EntityRef<Run> _Run;
    [Association(Name=@"Run_ResultFloatValue", Storage=@"_Run", ThisKey=@"RunId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public Run Run
    {
      get {
        return _Run.Entity;
      }
      set {
        Run previousValue = _Run.Entity;
        if ((previousValue != value) || (!_Run.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Run.Entity = null;
            previousValue.ResultFloatValues.Remove(this);
          }
          _Run.Entity = value;
          if (value != null) {
            value.ResultFloatValues.Add(this);
            _RunId = value.Id;
          }
          else {
            _RunId = default(long);
          }
          SendPropertyChanged("Run");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.ResultIntValue")]
[KnownType(typeof(ResultIntValue))] public partial class ResultIntValue : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public ResultIntValue()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Result = default(EntityRef<Result>);
      _Run = default(EntityRef<Run>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnResultIdChanging(long value);
    partial void OnResultIdChanged();
    private long _ResultId;
    [Column(Storage=@"_ResultId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long ResultId
    {
      get { return _ResultId; }
      set {
        if (_ResultId != value) {
          if (_Result.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnResultIdChanging(value);
          SendPropertyChanging();
          _ResultId = value;
          SendPropertyChanged("ResultId");
          OnResultIdChanged();
        }
      }
    }
    
    partial void OnRunIdChanging(long value);
    partial void OnRunIdChanged();
    private long _RunId;
    [Column(Storage=@"_RunId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public long RunId
    {
      get { return _RunId; }
      set {
        if (_RunId != value) {
          if (_Run.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnRunIdChanging(value);
          SendPropertyChanging();
          _RunId = value;
          SendPropertyChanged("RunId");
          OnRunIdChanged();
        }
      }
    }
    
    partial void OnValueChanging(int value);
    partial void OnValueChanged();
    private int _Value;
    [Column(Storage=@"_Value", DbType=@"Int NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public int Value
    {
      get { return _Value; }
      set {
        if (_Value != value) {
          OnValueChanging(value);
          SendPropertyChanging();
          _Value = value;
          SendPropertyChanged("Value");
          OnValueChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<Result> _Result;
    [Association(Name=@"Result_ResultIntValue", Storage=@"_Result", ThisKey=@"ResultId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public Result Result
    {
      get {
        return _Result.Entity;
      }
      set {
        Result previousValue = _Result.Entity;
        if ((previousValue != value) || (!_Result.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Result.Entity = null;
            previousValue.ResultIntValues.Remove(this);
          }
          _Result.Entity = value;
          if (value != null) {
            value.ResultIntValues.Add(this);
            _ResultId = value.Id;
          }
          else {
            _ResultId = default(long);
          }
          SendPropertyChanged("Result");
        }
      }
    }

    private EntityRef<Run> _Run;
    [Association(Name=@"Run_ResultIntValue", Storage=@"_Run", ThisKey=@"RunId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public Run Run
    {
      get {
        return _Run.Entity;
      }
      set {
        Run previousValue = _Run.Entity;
        if ((previousValue != value) || (!_Run.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Run.Entity = null;
            previousValue.ResultIntValues.Remove(this);
          }
          _Run.Entity = value;
          if (value != null) {
            value.ResultIntValues.Add(this);
            _RunId = value.Id;
          }
          else {
            _RunId = default(long);
          }
          SendPropertyChanged("Run");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.ResultStringValue")]
[KnownType(typeof(ResultStringValue))]  public partial class ResultStringValue : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public ResultStringValue()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Result = default(EntityRef<Result>);
      _Run = default(EntityRef<Run>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnResultIdChanging(long value);
    partial void OnResultIdChanged();
    private long _ResultId;
    [Column(Storage=@"_ResultId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long ResultId
    {
      get { return _ResultId; }
      set {
        if (_ResultId != value) {
          if (_Result.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnResultIdChanging(value);
          SendPropertyChanging();
          _ResultId = value;
          SendPropertyChanged("ResultId");
          OnResultIdChanged();
        }
      }
    }
    
    partial void OnRunIdChanging(long value);
    partial void OnRunIdChanged();
    private long _RunId;
    [Column(Storage=@"_RunId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public long RunId
    {
      get { return _RunId; }
      set {
        if (_RunId != value) {
          if (_Run.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnRunIdChanging(value);
          SendPropertyChanging();
          _RunId = value;
          SendPropertyChanged("RunId");
          OnRunIdChanged();
        }
      }
    }
    
    partial void OnValueChanging(string value);
    partial void OnValueChanged();
    private string _Value;
    [Column(Storage=@"_Value", DbType=@"NVarChar(MAX) NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public string Value
    {
      get { return _Value; }
      set {
        if (_Value != value) {
          OnValueChanging(value);
          SendPropertyChanging();
          _Value = value;
          SendPropertyChanged("Value");
          OnValueChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<Result> _Result;
    [Association(Name=@"Result_ResultStringValue", Storage=@"_Result", ThisKey=@"ResultId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public Result Result
    {
      get {
        return _Result.Entity;
      }
      set {
        Result previousValue = _Result.Entity;
        if ((previousValue != value) || (!_Result.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Result.Entity = null;
            previousValue.ResultStringValues.Remove(this);
          }
          _Result.Entity = value;
          if (value != null) {
            value.ResultStringValues.Add(this);
            _ResultId = value.Id;
          }
          else {
            _ResultId = default(long);
          }
          SendPropertyChanged("Result");
        }
      }
    }

    private EntityRef<Run> _Run;
    [Association(Name=@"Run_ResultStringValue", Storage=@"_Run", ThisKey=@"RunId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public Run Run
    {
      get {
        return _Run.Entity;
      }
      set {
        Run previousValue = _Run.Entity;
        if ((previousValue != value) || (!_Run.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Run.Entity = null;
            previousValue.ResultStringValues.Remove(this);
          }
          _Run.Entity = value;
          if (value != null) {
            value.ResultStringValues.Add(this);
            _RunId = value.Id;
          }
          else {
            _RunId = default(long);
          }
          SendPropertyChanged("Run");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.Client")]
[KnownType(typeof(Client))] public partial class Client : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public Client()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Runs = new EntitySet<Run>(attach_Runs, detach_Runs);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnIdChanging(Guid value);
    partial void OnIdChanged();
    private Guid _Id;
    [Column(Storage=@"_Id", DbType=@"UniqueIdentifier NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public Guid Id
    {
      get { return _Id; }
      set {
        if (_Id != value) {
          OnIdChanging(value);
          SendPropertyChanging();
          _Id = value;
          SendPropertyChanged("Id");
          OnIdChanged();
        }
      }
    }
    
    partial void OnNameChanging(string value);
    partial void OnNameChanged();
    private string _Name;
    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
    [DataMember(Order=2)]
    public string Name
    {
      get { return _Name; }
      set {
        if (_Name != value) {
          OnNameChanging(value);
          SendPropertyChanging();
          _Name = value;
          SendPropertyChanged("Name");
          OnNameChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntitySet<Run> _Runs;
    [Association(Name=@"Client_Run", Storage=@"_Runs", ThisKey=@"Id", OtherKey=@"ClientId")]
    [DataMember(Order=3, EmitDefaultValue=false)]
    public EntitySet<Run> Runs
    {
      get {
        if (serializing && !_Runs.HasLoadedOrAssignedValues) {
          return null;
        }
        return _Runs;
      }
      set {
        _Runs.Assign(value);
      }
    }

    private void attach_Runs(Run entity)
    {
      SendPropertyChanging();
      entity.Client = this;
    }
    
    private void detach_Runs(Run entity)
    {
      SendPropertyChanging();
      entity.Client = null;
    }
    #endregion
    
    #region Serialization
    private bool serializing;
    
    [OnSerializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerializing(StreamingContext context)
    {
      serializing = true;
    }
    
    [OnSerialized()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerialized(StreamingContext context)
    {
      serializing = false;
    }
    
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.DataType")]
[KnownType(typeof(DataType))] public partial class DataType : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public DataType()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _AlgorithmParameters = new EntitySet<AlgorithmParameter>(attach_AlgorithmParameters, detach_AlgorithmParameters);
      _ProblemParameters = new EntitySet<ProblemParameter>(attach_ProblemParameters, detach_ProblemParameters);
      _Results = new EntitySet<Result>(attach_Results, detach_Results);
      _ProblemCharacteristics = new EntitySet<ProblemCharacteristic>(attach_ProblemCharacteristics, detach_ProblemCharacteristics);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnIdChanging(long value);
    partial void OnIdChanged();
    private long _Id;
    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long Id
    {
      get { return _Id; }
      set {
        if (_Id != value) {
          OnIdChanging(value);
          SendPropertyChanging();
          _Id = value;
          SendPropertyChanged("Id");
          OnIdChanged();
        }
      }
    }
    
    partial void OnSqlNameChanging(string value);
    partial void OnSqlNameChanged();
    private string _SqlName;
    [Column(Storage=@"_SqlName", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
    [DataMember(Order=2)]
    public string SqlName
    {
      get { return _SqlName; }
      set {
        if (_SqlName != value) {
          OnSqlNameChanging(value);
          SendPropertyChanging();
          _SqlName = value;
          SendPropertyChanged("SqlName");
          OnSqlNameChanged();
        }
      }
    }
    
    partial void OnClrNameChanging(string value);
    partial void OnClrNameChanged();
    private string _ClrName;
    [Column(Storage=@"_ClrName", DbType=@"NVarChar(MAX) NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public string ClrName
    {
      get { return _ClrName; }
      set {
        if (_ClrName != value) {
          OnClrNameChanging(value);
          SendPropertyChanging();
          _ClrName = value;
          SendPropertyChanged("ClrName");
          OnClrNameChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntitySet<AlgorithmParameter> _AlgorithmParameters;
    [Association(Name=@"DataType_AlgorithmParameter", Storage=@"_AlgorithmParameters", ThisKey=@"Id", OtherKey=@"DataTypeId")]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public EntitySet<AlgorithmParameter> AlgorithmParameters
    {
      get {
        if (serializing && !_AlgorithmParameters.HasLoadedOrAssignedValues) {
          return null;
        }
        return _AlgorithmParameters;
      }
      set {
        _AlgorithmParameters.Assign(value);
      }
    }

    private void attach_AlgorithmParameters(AlgorithmParameter entity)
    {
      SendPropertyChanging();
      entity.DataType = this;
    }
    
    private void detach_AlgorithmParameters(AlgorithmParameter entity)
    {
      SendPropertyChanging();
      entity.DataType = null;
    }
    private EntitySet<ProblemParameter> _ProblemParameters;
    [Association(Name=@"DataType_ProblemParameter", Storage=@"_ProblemParameters", ThisKey=@"Id", OtherKey=@"DataTypeId")]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public EntitySet<ProblemParameter> ProblemParameters
    {
      get {
        if (serializing && !_ProblemParameters.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemParameters;
      }
      set {
        _ProblemParameters.Assign(value);
      }
    }

    private void attach_ProblemParameters(ProblemParameter entity)
    {
      SendPropertyChanging();
      entity.DataType = this;
    }
    
    private void detach_ProblemParameters(ProblemParameter entity)
    {
      SendPropertyChanging();
      entity.DataType = null;
    }
    private EntitySet<Result> _Results;
    [Association(Name=@"DataType_Result", Storage=@"_Results", ThisKey=@"Id", OtherKey=@"DataTypeId")]
    [DataMember(Order=6, EmitDefaultValue=false)]
    public EntitySet<Result> Results
    {
      get {
        if (serializing && !_Results.HasLoadedOrAssignedValues) {
          return null;
        }
        return _Results;
      }
      set {
        _Results.Assign(value);
      }
    }

    private void attach_Results(Result entity)
    {
      SendPropertyChanging();
      entity.DataType = this;
    }
    
    private void detach_Results(Result entity)
    {
      SendPropertyChanging();
      entity.DataType = null;
    }
    private EntitySet<ProblemCharacteristic> _ProblemCharacteristics;
    [Association(Name=@"DataType_ProblemCharacteristic", Storage=@"_ProblemCharacteristics", ThisKey=@"Id", OtherKey=@"DataTypeId")]
    [DataMember(Order=7, EmitDefaultValue=false)]
    public EntitySet<ProblemCharacteristic> ProblemCharacteristics
    {
      get {
        if (serializing && !_ProblemCharacteristics.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemCharacteristics;
      }
      set {
        _ProblemCharacteristics.Assign(value);
      }
    }

    private void attach_ProblemCharacteristics(ProblemCharacteristic entity)
    {
      SendPropertyChanging();
      entity.DataType = this;
    }
    
    private void detach_ProblemCharacteristics(ProblemCharacteristic entity)
    {
      SendPropertyChanging();
      entity.DataType = null;
    }
    #endregion
    
    #region Serialization
    private bool serializing;
    
    [OnSerializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerializing(StreamingContext context)
    {
      serializing = true;
    }
    
    [OnSerialized()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerialized(StreamingContext context)
    {
      serializing = false;
    }
    
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.ProblemCharacteristic")]
[KnownType(typeof(ProblemCharacteristic))]  public partial class ProblemCharacteristic : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public ProblemCharacteristic()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _ProblemCharacteristicFloatValues = new EntitySet<ProblemCharacteristicFloatValue>(attach_ProblemCharacteristicFloatValues, detach_ProblemCharacteristicFloatValues);
      _ProblemCharacteristicIntValues = new EntitySet<ProblemCharacteristicIntValue>(attach_ProblemCharacteristicIntValues, detach_ProblemCharacteristicIntValues);
      _ProblemCharacteristicStringValues = new EntitySet<ProblemCharacteristicStringValue>(attach_ProblemCharacteristicStringValues, detach_ProblemCharacteristicStringValues);
      _DataType = default(EntityRef<DataType>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnIdChanging(long value);
    partial void OnIdChanged();
    private long _Id;
    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long Id
    {
      get { return _Id; }
      set {
        if (_Id != value) {
          OnIdChanging(value);
          SendPropertyChanging();
          _Id = value;
          SendPropertyChanged("Id");
          OnIdChanged();
        }
      }
    }
    
    partial void OnNameChanging(string value);
    partial void OnNameChanged();
    private string _Name;
    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
    [DataMember(Order=2)]
    public string Name
    {
      get { return _Name; }
      set {
        if (_Name != value) {
          OnNameChanging(value);
          SendPropertyChanging();
          _Name = value;
          SendPropertyChanged("Name");
          OnNameChanged();
        }
      }
    }
    
    partial void OnDescriptionChanging(string value);
    partial void OnDescriptionChanged();
    private string _Description;
    [Column(Storage=@"_Description", DbType=@"NVarChar(MAX)")]
    [DataMember(Order=3)]
    public string Description
    {
      get { return _Description; }
      set {
        if (_Description != value) {
          OnDescriptionChanging(value);
          SendPropertyChanging();
          _Description = value;
          SendPropertyChanged("Description");
          OnDescriptionChanged();
        }
      }
    }
    
    partial void OnDataTypeIdChanging(long value);
    partial void OnDataTypeIdChanged();
    private long _DataTypeId;
    [Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
    [DataMember(Order=4)]
    public long DataTypeId
    {
      get { return _DataTypeId; }
      set {
        if (_DataTypeId != value) {
          if (_DataType.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnDataTypeIdChanging(value);
          SendPropertyChanging();
          _DataTypeId = value;
          SendPropertyChanged("DataTypeId");
          OnDataTypeIdChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntitySet<ProblemCharacteristicFloatValue> _ProblemCharacteristicFloatValues;
    [Association(Name=@"ProblemCharacteristic_ProblemCharacteristicFloatValue", Storage=@"_ProblemCharacteristicFloatValues", ThisKey=@"Id", OtherKey=@"ProblemCharacteristicId")]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public EntitySet<ProblemCharacteristicFloatValue> ProblemCharacteristicFloatValues
    {
      get {
        if (serializing && !_ProblemCharacteristicFloatValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemCharacteristicFloatValues;
      }
      set {
        _ProblemCharacteristicFloatValues.Assign(value);
      }
    }

    private void attach_ProblemCharacteristicFloatValues(ProblemCharacteristicFloatValue entity)
    {
      SendPropertyChanging();
      entity.ProblemCharacteristic = this;
    }
    
    private void detach_ProblemCharacteristicFloatValues(ProblemCharacteristicFloatValue entity)
    {
      SendPropertyChanging();
      entity.ProblemCharacteristic = null;
    }
    private EntitySet<ProblemCharacteristicIntValue> _ProblemCharacteristicIntValues;
    [Association(Name=@"ProblemCharacteristic_ProblemCharacteristicIntValue", Storage=@"_ProblemCharacteristicIntValues", ThisKey=@"Id", OtherKey=@"ProblemCharacteristicId")]
    [DataMember(Order=6, EmitDefaultValue=false)]
    public EntitySet<ProblemCharacteristicIntValue> ProblemCharacteristicIntValues
    {
      get {
        if (serializing && !_ProblemCharacteristicIntValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemCharacteristicIntValues;
      }
      set {
        _ProblemCharacteristicIntValues.Assign(value);
      }
    }

    private void attach_ProblemCharacteristicIntValues(ProblemCharacteristicIntValue entity)
    {
      SendPropertyChanging();
      entity.ProblemCharacteristic = this;
    }
    
    private void detach_ProblemCharacteristicIntValues(ProblemCharacteristicIntValue entity)
    {
      SendPropertyChanging();
      entity.ProblemCharacteristic = null;
    }
    private EntitySet<ProblemCharacteristicStringValue> _ProblemCharacteristicStringValues;
    [Association(Name=@"ProblemCharacteristic_ProblemCharacteristicStringValue", Storage=@"_ProblemCharacteristicStringValues", ThisKey=@"Id", OtherKey=@"ProblemCharacteristicId")]
    [DataMember(Order=7, EmitDefaultValue=false)]
    public EntitySet<ProblemCharacteristicStringValue> ProblemCharacteristicStringValues
    {
      get {
        if (serializing && !_ProblemCharacteristicStringValues.HasLoadedOrAssignedValues) {
          return null;
        }
        return _ProblemCharacteristicStringValues;
      }
      set {
        _ProblemCharacteristicStringValues.Assign(value);
      }
    }

    private void attach_ProblemCharacteristicStringValues(ProblemCharacteristicStringValue entity)
    {
      SendPropertyChanging();
      entity.ProblemCharacteristic = this;
    }
    
    private void detach_ProblemCharacteristicStringValues(ProblemCharacteristicStringValue entity)
    {
      SendPropertyChanging();
      entity.ProblemCharacteristic = null;
    }
    private EntityRef<DataType> _DataType;
    [Association(Name=@"DataType_ProblemCharacteristic", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=8, EmitDefaultValue=false)]
    public DataType DataType
    {
      get {
        if (serializing && !_DataType.HasLoadedOrAssignedValue) {
          return null;
        }
        return _DataType.Entity;
      }
      set {
        DataType previousValue = _DataType.Entity;
        if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _DataType.Entity = null;
            previousValue.ProblemCharacteristics.Remove(this);
          }
          _DataType.Entity = value;
          if (value != null) {
            value.ProblemCharacteristics.Add(this);
            _DataTypeId = value.Id;
          }
          else {
            _DataTypeId = default(long);
          }
          SendPropertyChanged("DataType");
        }
      }
    }

    #endregion
    
    #region Serialization
    private bool serializing;
    
    [OnSerializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerializing(StreamingContext context)
    {
      serializing = true;
    }
    
    [OnSerialized()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public void OnSerialized(StreamingContext context)
    {
      serializing = false;
    }
    
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.ProblemCharacteristicFloatValue")]
[KnownType(typeof(ProblemCharacteristicFloatValue))]  public partial class ProblemCharacteristicFloatValue : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public ProblemCharacteristicFloatValue()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Problem = default(EntityRef<Problem>);
      _ProblemCharacteristic = default(EntityRef<ProblemCharacteristic>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnProblemCharacteristicIdChanging(long value);
    partial void OnProblemCharacteristicIdChanged();
    private long _ProblemCharacteristicId;
    [Column(Storage=@"_ProblemCharacteristicId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long ProblemCharacteristicId
    {
      get { return _ProblemCharacteristicId; }
      set {
        if (_ProblemCharacteristicId != value) {
          if (_ProblemCharacteristic.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnProblemCharacteristicIdChanging(value);
          SendPropertyChanging();
          _ProblemCharacteristicId = value;
          SendPropertyChanged("ProblemCharacteristicId");
          OnProblemCharacteristicIdChanged();
        }
      }
    }
    
    partial void OnProblemIdChanging(long value);
    partial void OnProblemIdChanged();
    private long _ProblemId;
    [Column(Storage=@"_ProblemId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public long ProblemId
    {
      get { return _ProblemId; }
      set {
        if (_ProblemId != value) {
          if (_Problem.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnProblemIdChanging(value);
          SendPropertyChanging();
          _ProblemId = value;
          SendPropertyChanged("ProblemId");
          OnProblemIdChanged();
        }
      }
    }
    
    partial void OnValueChanging(double value);
    partial void OnValueChanged();
    private double _Value;
    [Column(Storage=@"_Value", DbType=@"Float NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public double Value
    {
      get { return _Value; }
      set {
        if (_Value != value) {
          OnValueChanging(value);
          SendPropertyChanging();
          _Value = value;
          SendPropertyChanged("Value");
          OnValueChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<Problem> _Problem;
    [Association(Name=@"Problem_ProblemCharacteristicFloatValue", Storage=@"_Problem", ThisKey=@"ProblemId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public Problem Problem
    {
      get {
        return _Problem.Entity;
      }
      set {
        Problem previousValue = _Problem.Entity;
        if ((previousValue != value) || (!_Problem.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Problem.Entity = null;
            previousValue.ProblemCharacteristicFloatValues.Remove(this);
          }
          _Problem.Entity = value;
          if (value != null) {
            value.ProblemCharacteristicFloatValues.Add(this);
            _ProblemId = value.Id;
          }
          else {
            _ProblemId = default(long);
          }
          SendPropertyChanged("Problem");
        }
      }
    }

    private EntityRef<ProblemCharacteristic> _ProblemCharacteristic;
    [Association(Name=@"ProblemCharacteristic_ProblemCharacteristicFloatValue", Storage=@"_ProblemCharacteristic", ThisKey=@"ProblemCharacteristicId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public ProblemCharacteristic ProblemCharacteristic
    {
      get {
        return _ProblemCharacteristic.Entity;
      }
      set {
        ProblemCharacteristic previousValue = _ProblemCharacteristic.Entity;
        if ((previousValue != value) || (!_ProblemCharacteristic.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _ProblemCharacteristic.Entity = null;
            previousValue.ProblemCharacteristicFloatValues.Remove(this);
          }
          _ProblemCharacteristic.Entity = value;
          if (value != null) {
            value.ProblemCharacteristicFloatValues.Add(this);
            _ProblemCharacteristicId = value.Id;
          }
          else {
            _ProblemCharacteristicId = default(long);
          }
          SendPropertyChanged("ProblemCharacteristic");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.ProblemCharacteristicIntValue")]
[KnownType(typeof(ProblemCharacteristicIntValue))]  public partial class ProblemCharacteristicIntValue : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public ProblemCharacteristicIntValue()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Problem = default(EntityRef<Problem>);
      _ProblemCharacteristic = default(EntityRef<ProblemCharacteristic>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnProblemCharacteristicIdChanging(long value);
    partial void OnProblemCharacteristicIdChanged();
    private long _ProblemCharacteristicId;
    [Column(Storage=@"_ProblemCharacteristicId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long ProblemCharacteristicId
    {
      get { return _ProblemCharacteristicId; }
      set {
        if (_ProblemCharacteristicId != value) {
          if (_ProblemCharacteristic.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnProblemCharacteristicIdChanging(value);
          SendPropertyChanging();
          _ProblemCharacteristicId = value;
          SendPropertyChanged("ProblemCharacteristicId");
          OnProblemCharacteristicIdChanged();
        }
      }
    }
    
    partial void OnProblemIdChanging(long value);
    partial void OnProblemIdChanged();
    private long _ProblemId;
    [Column(Storage=@"_ProblemId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public long ProblemId
    {
      get { return _ProblemId; }
      set {
        if (_ProblemId != value) {
          if (_Problem.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnProblemIdChanging(value);
          SendPropertyChanging();
          _ProblemId = value;
          SendPropertyChanged("ProblemId");
          OnProblemIdChanged();
        }
      }
    }
    
    partial void OnValueChanging(int value);
    partial void OnValueChanged();
    private int _Value;
    [Column(Storage=@"_Value", DbType=@"Int NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public int Value
    {
      get { return _Value; }
      set {
        if (_Value != value) {
          OnValueChanging(value);
          SendPropertyChanging();
          _Value = value;
          SendPropertyChanged("Value");
          OnValueChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<Problem> _Problem;
    [Association(Name=@"Problem_ProblemCharacteristicIntValue", Storage=@"_Problem", ThisKey=@"ProblemId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public Problem Problem
    {
      get {
        return _Problem.Entity;
      }
      set {
        Problem previousValue = _Problem.Entity;
        if ((previousValue != value) || (!_Problem.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Problem.Entity = null;
            previousValue.ProblemCharacteristicIntValues.Remove(this);
          }
          _Problem.Entity = value;
          if (value != null) {
            value.ProblemCharacteristicIntValues.Add(this);
            _ProblemId = value.Id;
          }
          else {
            _ProblemId = default(long);
          }
          SendPropertyChanged("Problem");
        }
      }
    }

    private EntityRef<ProblemCharacteristic> _ProblemCharacteristic;
    [Association(Name=@"ProblemCharacteristic_ProblemCharacteristicIntValue", Storage=@"_ProblemCharacteristic", ThisKey=@"ProblemCharacteristicId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public ProblemCharacteristic ProblemCharacteristic
    {
      get {
        return _ProblemCharacteristic.Entity;
      }
      set {
        ProblemCharacteristic previousValue = _ProblemCharacteristic.Entity;
        if ((previousValue != value) || (!_ProblemCharacteristic.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _ProblemCharacteristic.Entity = null;
            previousValue.ProblemCharacteristicIntValues.Remove(this);
          }
          _ProblemCharacteristic.Entity = value;
          if (value != null) {
            value.ProblemCharacteristicIntValues.Add(this);
            _ProblemCharacteristicId = value.Id;
          }
          else {
            _ProblemCharacteristicId = default(long);
          }
          SendPropertyChanged("ProblemCharacteristic");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}

namespace HeuristicLab.Services.OKB.DataAccess
{ 
  [DataContract(IsReference=true)]
  [Table(Name=@"dbo.ProblemCharacteristicStringValue")]
[KnownType(typeof(ProblemCharacteristicStringValue))] public partial class ProblemCharacteristicStringValue : INotifyPropertyChanging, INotifyPropertyChanged
  {
    #region Property Change Event Handling
    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    
    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;
    
    public virtual void SendPropertyChanging()
    {
      if (PropertyChanging != null) {
        PropertyChanging(this, emptyChangingEventArgs);
      }
    }
      
    public virtual void SendPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
      }
    }
    #endregion
    
    #region Extensibility Method Definitions
    partial void OnLoaded();
    partial void OnValidate(ChangeAction action);
    partial void OnCreated();
    #endregion

    #region Construction
    public ProblemCharacteristicStringValue()
    {
      Initialize();
    }
    
    private void Initialize()
    {
      _Problem = default(EntityRef<Problem>);
      _ProblemCharacteristic = default(EntityRef<ProblemCharacteristic>);
      OnCreated();
    }
    #endregion

    #region Column Mappings
    partial void OnProblemCharacteristicIdChanging(long value);
    partial void OnProblemCharacteristicIdChanged();
    private long _ProblemCharacteristicId;
    [Column(Storage=@"_ProblemCharacteristicId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=1)]
    public long ProblemCharacteristicId
    {
      get { return _ProblemCharacteristicId; }
      set {
        if (_ProblemCharacteristicId != value) {
          if (_ProblemCharacteristic.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnProblemCharacteristicIdChanging(value);
          SendPropertyChanging();
          _ProblemCharacteristicId = value;
          SendPropertyChanged("ProblemCharacteristicId");
          OnProblemCharacteristicIdChanged();
        }
      }
    }
    
    partial void OnProblemIdChanging(long value);
    partial void OnProblemIdChanged();
    private long _ProblemId;
    [Column(Storage=@"_ProblemId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
    [DataMember(Order=2)]
    public long ProblemId
    {
      get { return _ProblemId; }
      set {
        if (_ProblemId != value) {
          if (_Problem.HasLoadedOrAssignedValue) {
            throw new ForeignKeyReferenceAlreadyHasValueException();
          }
          OnProblemIdChanging(value);
          SendPropertyChanging();
          _ProblemId = value;
          SendPropertyChanged("ProblemId");
          OnProblemIdChanged();
        }
      }
    }
    
    partial void OnValueChanging(string value);
    partial void OnValueChanged();
    private string _Value;
    [Column(Storage=@"_Value", DbType=@"NVarChar(MAX) NOT NULL", CanBeNull=false)]
    [DataMember(Order=3)]
    public string Value
    {
      get { return _Value; }
      set {
        if (_Value != value) {
          OnValueChanging(value);
          SendPropertyChanging();
          _Value = value;
          SendPropertyChanged("Value");
          OnValueChanged();
        }
      }
    }
    
    #endregion
    
    #region Associations
    private EntityRef<Problem> _Problem;
    [Association(Name=@"Problem_ProblemCharacteristicStringValue", Storage=@"_Problem", ThisKey=@"ProblemId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=4, EmitDefaultValue=false)]
    public Problem Problem
    {
      get {
        return _Problem.Entity;
      }
      set {
        Problem previousValue = _Problem.Entity;
        if ((previousValue != value) || (!_Problem.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _Problem.Entity = null;
            previousValue.ProblemCharacteristicStringValues.Remove(this);
          }
          _Problem.Entity = value;
          if (value != null) {
            value.ProblemCharacteristicStringValues.Add(this);
            _ProblemId = value.Id;
          }
          else {
            _ProblemId = default(long);
          }
          SendPropertyChanged("Problem");
        }
      }
    }

    private EntityRef<ProblemCharacteristic> _ProblemCharacteristic;
    [Association(Name=@"ProblemCharacteristic_ProblemCharacteristicStringValue", Storage=@"_ProblemCharacteristic", ThisKey=@"ProblemCharacteristicId", OtherKey=@"Id", IsForeignKey=true)]
    [DataMember(Order=5, EmitDefaultValue=false)]
    public ProblemCharacteristic ProblemCharacteristic
    {
      get {
        return _ProblemCharacteristic.Entity;
      }
      set {
        ProblemCharacteristic previousValue = _ProblemCharacteristic.Entity;
        if ((previousValue != value) || (!_ProblemCharacteristic.HasLoadedOrAssignedValue)) {
          SendPropertyChanging();
          if (previousValue != null) {
            _ProblemCharacteristic.Entity = null;
            previousValue.ProblemCharacteristicStringValues.Remove(this);
          }
          _ProblemCharacteristic.Entity = value;
          if (value != null) {
            value.ProblemCharacteristicStringValues.Add(this);
            _ProblemCharacteristicId = value.Id;
          }
          else {
            _ProblemCharacteristicId = default(long);
          }
          SendPropertyChanged("ProblemCharacteristic");
        }
      }
    }

    #endregion
    
    #region Serialization
    [OnDeserializing()]
    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
    public  void OnDeserializing(StreamingContext context)
    {
      Initialize();
    }
    #endregion
  }
}
#pragma warning restore 1591