#pragma warning disable 1591
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by LINQ to SQL template for T4 C#
//     Generated at 09/16/2010 02:21:16
//
//     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=@"HeuristicLab.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 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 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 InsertClient(Client instance);
		partial void UpdateClient(Client instance);
		partial void DeleteClient(Client instance);
		partial void InsertAlgorithmParameterBlobValue(AlgorithmParameterBlobValue instance);
		partial void UpdateAlgorithmParameterBlobValue(AlgorithmParameterBlobValue instance);
		partial void DeleteAlgorithmParameterBlobValue(AlgorithmParameterBlobValue instance);
		partial void InsertDataType(DataType instance);
		partial void UpdateDataType(DataType instance);
		partial void DeleteDataType(DataType 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 InsertProblemParameterBlobValue(ProblemParameterBlobValue instance);
		partial void UpdateProblemParameterBlobValue(ProblemParameterBlobValue instance);
		partial void DeleteProblemParameterBlobValue(ProblemParameterBlobValue 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 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);
		#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<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<Run> Runs
		{
			get { return GetTable<Run>(); }
		}
		
		public Table<Result> Results
		{
			get { return GetTable<Result>(); }
		}
		
		public Table<Client> Clients
		{
			get { return GetTable<Client>(); }
		}
		
		public Table<AlgorithmParameterBlobValue> AlgorithmParameterBlobValues
		{
			get { return GetTable<AlgorithmParameterBlobValue>(); }
		}
		
		public Table<DataType> DataTypes
		{
			get { return GetTable<DataType>(); }
		}
		
		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<ProblemParameterBlobValue> ProblemParameterBlobValues
		{
			get { return GetTable<ProblemParameterBlobValue>(); }
		}
		
		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<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>(); }
		}
		
		#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);
			_ProblemClass = default(EntityRef<ProblemClass>);
			_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 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) {
					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 EntityRef<ProblemClass> _ProblemClass;
		[Association(Name=@"ProblemClass_Problem", Storage=@"_ProblemClass", ThisKey=@"ProblemClassId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=11, 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=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.Problems.Remove(this);
					}
					_Platform.Entity = value;
					if (value != null) {
						value.Problems.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.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()
		{
			_Runs = new EntitySet<Run>(attach_Runs, detach_Runs);
			_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);
			_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>);
			_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<Run> _Runs;
		[Association(Name=@"Experiment_Run", Storage=@"_Runs", ThisKey=@"Id", OtherKey=@"ExperimentId")]
		[DataMember(Order=4, 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 EntitySet<AlgorithmParameterBlobValue> _AlgorithmParameterBlobValues;
		[Association(Name=@"Experiment_AlgorithmParameterBlobValue", Storage=@"_AlgorithmParameterBlobValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
		[DataMember(Order=5, 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<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<ProblemParameterBlobValue> _ProblemParameterBlobValues;
		[Association(Name=@"Experiment_ProblemParameterBlobValue", Storage=@"_ProblemParameterBlobValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
		[DataMember(Order=10, 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<ProblemParameterBoolValue> _ProblemParameterBoolValues;
		[Association(Name=@"Experiment_ProblemParameterBoolValue", Storage=@"_ProblemParameterBoolValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
		[DataMember(Order=11, 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=12, 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=13, 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=14, 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 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.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);
			_DataTypes = new EntitySet<DataType>(attach_DataTypes, detach_DataTypes);
			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;
		}
		private EntitySet<DataType> _DataTypes;
		[Association(Name=@"Platform_DataType", Storage=@"_DataTypes", ThisKey=@"Id", OtherKey=@"PlatformId")]
		[DataMember(Order=6, EmitDefaultValue=false)]
		public EntitySet<DataType> DataTypes
		{
			get {
				if (serializing && !_DataTypes.HasLoadedOrAssignedValues) {
					return null;
				}
				return _DataTypes;
			}
			set {
				_DataTypes.Assign(value);
			}
		}

		private void attach_DataTypes(DataType entity)
		{
			SendPropertyChanging();
			entity.Platform = this;
		}
		
		private void detach_DataTypes(DataType 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.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.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.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>);
			_DataType = default(EntityRef<DataType>);
			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 OnDataTypeIdChanging(long value);
		partial void OnDataTypeIdChanged();
		private long _DataTypeId;
		[Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
		[DataMember(Order=3)]
		public long DataTypeId
		{
			get { return _DataTypeId; }
			set {
				if (_DataTypeId != value) {
					if (_DataType.HasLoadedOrAssignedValue) {
						throw new ForeignKeyReferenceAlreadyHasValueException();
					}
					OnDataTypeIdChanging(value);
					SendPropertyChanging();
					_DataTypeId = value;
					SendPropertyChanged("DataTypeId");
					OnDataTypeIdChanged();
				}
			}
		}
		
		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=4)]
		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=5, 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=6, 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");
				}
			}
		}

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

		#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.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);
			_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);
			_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);
			_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);
			_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 OnPlatformIdChanging(long value);
		partial void OnPlatformIdChanged();
		private long _PlatformId;
		[Column(Storage=@"_PlatformId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
		[DataMember(Order=2)]
		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(MAX) 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 OnSqlNameChanging(string value);
		partial void OnSqlNameChanged();
		private string _SqlName;
		[Column(Storage=@"_SqlName", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
		[DataMember(Order=4)]
		public string SqlName
		{
			get { return _SqlName; }
			set {
				if (_SqlName != value) {
					OnSqlNameChanging(value);
					SendPropertyChanging();
					_SqlName = value;
					SendPropertyChanged("SqlName");
					OnSqlNameChanged();
				}
			}
		}
		
		#endregion
		
		#region Associations
		private EntitySet<AlgorithmParameter> _AlgorithmParameters;
		[Association(Name=@"DataType_AlgorithmParameter", Storage=@"_AlgorithmParameters", ThisKey=@"Id", OtherKey=@"DataTypeId")]
		[DataMember(Order=5, 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=6, 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=7, 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<AlgorithmParameterBlobValue> _AlgorithmParameterBlobValues;
		[Association(Name=@"DataType_AlgorithmParameterBlobValue", Storage=@"_AlgorithmParameterBlobValues", ThisKey=@"Id", OtherKey=@"DataTypeId")]
		[DataMember(Order=8, 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.DataType = this;
		}
		
		private void detach_AlgorithmParameterBlobValues(AlgorithmParameterBlobValue entity)
		{
			SendPropertyChanging();
			entity.DataType = null;
		}
		private EntitySet<AlgorithmParameterBoolValue> _AlgorithmParameterBoolValues;
		[Association(Name=@"DataType_AlgorithmParameterBoolValue", Storage=@"_AlgorithmParameterBoolValues", ThisKey=@"Id", OtherKey=@"DataTypeId")]
		[DataMember(Order=9, 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.DataType = this;
		}
		
		private void detach_AlgorithmParameterBoolValues(AlgorithmParameterBoolValue entity)
		{
			SendPropertyChanging();
			entity.DataType = null;
		}
		private EntitySet<AlgorithmParameterFloatValue> _AlgorithmParameterFloatValues;
		[Association(Name=@"DataType_AlgorithmParameterFloatValue", Storage=@"_AlgorithmParameterFloatValues", ThisKey=@"Id", OtherKey=@"DataTypeId")]
		[DataMember(Order=10, 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.DataType = this;
		}
		
		private void detach_AlgorithmParameterFloatValues(AlgorithmParameterFloatValue entity)
		{
			SendPropertyChanging();
			entity.DataType = null;
		}
		private EntitySet<AlgorithmParameterIntValue> _AlgorithmParameterIntValues;
		[Association(Name=@"DataType_AlgorithmParameterIntValue", Storage=@"_AlgorithmParameterIntValues", ThisKey=@"Id", OtherKey=@"DataTypeId")]
		[DataMember(Order=11, 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.DataType = this;
		}
		
		private void detach_AlgorithmParameterIntValues(AlgorithmParameterIntValue entity)
		{
			SendPropertyChanging();
			entity.DataType = null;
		}
		private EntitySet<AlgorithmParameterStringValue> _AlgorithmParameterStringValues;
		[Association(Name=@"DataType_AlgorithmParameterStringValue", Storage=@"_AlgorithmParameterStringValues", ThisKey=@"Id", OtherKey=@"DataTypeId")]
		[DataMember(Order=12, 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.DataType = this;
		}
		
		private void detach_AlgorithmParameterStringValues(AlgorithmParameterStringValue entity)
		{
			SendPropertyChanging();
			entity.DataType = null;
		}
		private EntitySet<ProblemParameterBlobValue> _ProblemParameterBlobValues;
		[Association(Name=@"DataType_ProblemParameterBlobValue", Storage=@"_ProblemParameterBlobValues", ThisKey=@"Id", OtherKey=@"DataTypeId")]
		[DataMember(Order=13, 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.DataType = this;
		}
		
		private void detach_ProblemParameterBlobValues(ProblemParameterBlobValue entity)
		{
			SendPropertyChanging();
			entity.DataType = null;
		}
		private EntitySet<ProblemParameterBoolValue> _ProblemParameterBoolValues;
		[Association(Name=@"DataType_ProblemParameterBoolValue", Storage=@"_ProblemParameterBoolValues", ThisKey=@"Id", OtherKey=@"DataTypeId")]
		[DataMember(Order=14, 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.DataType = this;
		}
		
		private void detach_ProblemParameterBoolValues(ProblemParameterBoolValue entity)
		{
			SendPropertyChanging();
			entity.DataType = null;
		}
		private EntitySet<ProblemParameterFloatValue> _ProblemParameterFloatValues;
		[Association(Name=@"DataType_ProblemParameterFloatValue", Storage=@"_ProblemParameterFloatValues", ThisKey=@"Id", OtherKey=@"DataTypeId")]
		[DataMember(Order=15, 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.DataType = this;
		}
		
		private void detach_ProblemParameterFloatValues(ProblemParameterFloatValue entity)
		{
			SendPropertyChanging();
			entity.DataType = null;
		}
		private EntitySet<ProblemParameterIntValue> _ProblemParameterIntValues;
		[Association(Name=@"DataType_ProblemParameterIntValue", Storage=@"_ProblemParameterIntValues", ThisKey=@"Id", OtherKey=@"DataTypeId")]
		[DataMember(Order=16, 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.DataType = this;
		}
		
		private void detach_ProblemParameterIntValues(ProblemParameterIntValue entity)
		{
			SendPropertyChanging();
			entity.DataType = null;
		}
		private EntitySet<ProblemParameterStringValue> _ProblemParameterStringValues;
		[Association(Name=@"DataType_ProblemParameterStringValue", Storage=@"_ProblemParameterStringValues", ThisKey=@"Id", OtherKey=@"DataTypeId")]
		[DataMember(Order=17, 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.DataType = this;
		}
		
		private void detach_ProblemParameterStringValues(ProblemParameterStringValue entity)
		{
			SendPropertyChanging();
			entity.DataType = null;
		}
		private EntitySet<ResultBlobValue> _ResultBlobValues;
		[Association(Name=@"DataType_ResultBlobValue", Storage=@"_ResultBlobValues", ThisKey=@"Id", OtherKey=@"DataTypeId")]
		[DataMember(Order=18, 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.DataType = this;
		}
		
		private void detach_ResultBlobValues(ResultBlobValue entity)
		{
			SendPropertyChanging();
			entity.DataType = null;
		}
		private EntitySet<ResultBoolValue> _ResultBoolValues;
		[Association(Name=@"DataType_ResultBoolValue", Storage=@"_ResultBoolValues", ThisKey=@"Id", OtherKey=@"DataTypeId")]
		[DataMember(Order=19, 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.DataType = this;
		}
		
		private void detach_ResultBoolValues(ResultBoolValue entity)
		{
			SendPropertyChanging();
			entity.DataType = null;
		}
		private EntitySet<ResultFloatValue> _ResultFloatValues;
		[Association(Name=@"DataType_ResultFloatValue", Storage=@"_ResultFloatValues", ThisKey=@"Id", OtherKey=@"DataTypeId")]
		[DataMember(Order=20, 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.DataType = this;
		}
		
		private void detach_ResultFloatValues(ResultFloatValue entity)
		{
			SendPropertyChanging();
			entity.DataType = null;
		}
		private EntitySet<ResultIntValue> _ResultIntValues;
		[Association(Name=@"DataType_ResultIntValue", Storage=@"_ResultIntValues", ThisKey=@"Id", OtherKey=@"DataTypeId")]
		[DataMember(Order=21, 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.DataType = this;
		}
		
		private void detach_ResultIntValues(ResultIntValue entity)
		{
			SendPropertyChanging();
			entity.DataType = null;
		}
		private EntitySet<ResultStringValue> _ResultStringValues;
		[Association(Name=@"DataType_ResultStringValue", Storage=@"_ResultStringValues", ThisKey=@"Id", OtherKey=@"DataTypeId")]
		[DataMember(Order=22, 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.DataType = this;
		}
		
		private void detach_ResultStringValues(ResultStringValue entity)
		{
			SendPropertyChanging();
			entity.DataType = null;
		}
		private EntityRef<Platform> _Platform;
		[Association(Name=@"Platform_DataType", Storage=@"_Platform", ThisKey=@"PlatformId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=23, 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.DataTypes.Remove(this);
					}
					_Platform.Entity = value;
					if (value != null) {
						value.DataTypes.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.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>);
			_DataType = default(EntityRef<DataType>);
			_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 OnDataTypeIdChanging(long value);
		partial void OnDataTypeIdChanged();
		private long _DataTypeId;
		[Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
		[DataMember(Order=3)]
		public long DataTypeId
		{
			get { return _DataTypeId; }
			set {
				if (_DataTypeId != value) {
					if (_DataType.HasLoadedOrAssignedValue) {
						throw new ForeignKeyReferenceAlreadyHasValueException();
					}
					OnDataTypeIdChanging(value);
					SendPropertyChanging();
					_DataTypeId = value;
					SendPropertyChanged("DataTypeId");
					OnDataTypeIdChanged();
				}
			}
		}
		
		partial void OnValueChanging(bool value);
		partial void OnValueChanged();
		private bool _Value;
		[Column(Storage=@"_Value", DbType=@"Bit NOT NULL", CanBeNull=false)]
		[DataMember(Order=4)]
		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=5, 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<DataType> _DataType;
		[Association(Name=@"DataType_AlgorithmParameterBoolValue", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=6, EmitDefaultValue=false)]
		public DataType DataType
		{
			get {
				return _DataType.Entity;
			}
			set {
				DataType previousValue = _DataType.Entity;
				if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
					SendPropertyChanging();
					if (previousValue != null) {
						_DataType.Entity = null;
						previousValue.AlgorithmParameterBoolValues.Remove(this);
					}
					_DataType.Entity = value;
					if (value != null) {
						value.AlgorithmParameterBoolValues.Add(this);
						_DataTypeId = value.Id;
					}
					else {
						_DataTypeId = default(long);
					}
					SendPropertyChanged("DataType");
				}
			}
		}

		private EntityRef<Experiment> _Experiment;
		[Association(Name=@"Experiment_AlgorithmParameterBoolValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=7, 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>);
			_DataType = default(EntityRef<DataType>);
			_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 OnDataTypeIdChanging(long value);
		partial void OnDataTypeIdChanged();
		private long _DataTypeId;
		[Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
		[DataMember(Order=3)]
		public long DataTypeId
		{
			get { return _DataTypeId; }
			set {
				if (_DataTypeId != value) {
					if (_DataType.HasLoadedOrAssignedValue) {
						throw new ForeignKeyReferenceAlreadyHasValueException();
					}
					OnDataTypeIdChanging(value);
					SendPropertyChanging();
					_DataTypeId = value;
					SendPropertyChanged("DataTypeId");
					OnDataTypeIdChanged();
				}
			}
		}
		
		partial void OnValueChanging(double value);
		partial void OnValueChanged();
		private double _Value;
		[Column(Storage=@"_Value", DbType=@"Float NOT NULL", CanBeNull=false)]
		[DataMember(Order=4)]
		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=5, 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<DataType> _DataType;
		[Association(Name=@"DataType_AlgorithmParameterFloatValue", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=6, EmitDefaultValue=false)]
		public DataType DataType
		{
			get {
				return _DataType.Entity;
			}
			set {
				DataType previousValue = _DataType.Entity;
				if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
					SendPropertyChanging();
					if (previousValue != null) {
						_DataType.Entity = null;
						previousValue.AlgorithmParameterFloatValues.Remove(this);
					}
					_DataType.Entity = value;
					if (value != null) {
						value.AlgorithmParameterFloatValues.Add(this);
						_DataTypeId = value.Id;
					}
					else {
						_DataTypeId = default(long);
					}
					SendPropertyChanged("DataType");
				}
			}
		}

		private EntityRef<Experiment> _Experiment;
		[Association(Name=@"Experiment_AlgorithmParameterFloatValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=7, 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>);
			_DataType = default(EntityRef<DataType>);
			_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 OnDataTypeIdChanging(long value);
		partial void OnDataTypeIdChanged();
		private long _DataTypeId;
		[Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
		[DataMember(Order=3)]
		public long DataTypeId
		{
			get { return _DataTypeId; }
			set {
				if (_DataTypeId != value) {
					if (_DataType.HasLoadedOrAssignedValue) {
						throw new ForeignKeyReferenceAlreadyHasValueException();
					}
					OnDataTypeIdChanging(value);
					SendPropertyChanging();
					_DataTypeId = value;
					SendPropertyChanged("DataTypeId");
					OnDataTypeIdChanged();
				}
			}
		}
		
		partial void OnValueChanging(long value);
		partial void OnValueChanged();
		private long _Value;
		[Column(Storage=@"_Value", DbType=@"BigInt NOT NULL", CanBeNull=false)]
		[DataMember(Order=4)]
		public long 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=5, 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<DataType> _DataType;
		[Association(Name=@"DataType_AlgorithmParameterIntValue", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=6, EmitDefaultValue=false)]
		public DataType DataType
		{
			get {
				return _DataType.Entity;
			}
			set {
				DataType previousValue = _DataType.Entity;
				if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
					SendPropertyChanging();
					if (previousValue != null) {
						_DataType.Entity = null;
						previousValue.AlgorithmParameterIntValues.Remove(this);
					}
					_DataType.Entity = value;
					if (value != null) {
						value.AlgorithmParameterIntValues.Add(this);
						_DataTypeId = value.Id;
					}
					else {
						_DataTypeId = default(long);
					}
					SendPropertyChanged("DataType");
				}
			}
		}

		private EntityRef<Experiment> _Experiment;
		[Association(Name=@"Experiment_AlgorithmParameterIntValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=7, 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>);
			_DataType = default(EntityRef<DataType>);
			_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 OnDataTypeIdChanging(long value);
		partial void OnDataTypeIdChanged();
		private long _DataTypeId;
		[Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
		[DataMember(Order=3)]
		public long DataTypeId
		{
			get { return _DataTypeId; }
			set {
				if (_DataTypeId != value) {
					if (_DataType.HasLoadedOrAssignedValue) {
						throw new ForeignKeyReferenceAlreadyHasValueException();
					}
					OnDataTypeIdChanging(value);
					SendPropertyChanging();
					_DataTypeId = value;
					SendPropertyChanged("DataTypeId");
					OnDataTypeIdChanged();
				}
			}
		}
		
		partial void OnValueChanging(string value);
		partial void OnValueChanged();
		private string _Value;
		[Column(Storage=@"_Value", DbType=@"NVarChar(MAX) NOT NULL", CanBeNull=false)]
		[DataMember(Order=4)]
		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=5, 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<DataType> _DataType;
		[Association(Name=@"DataType_AlgorithmParameterStringValue", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=6, EmitDefaultValue=false)]
		public DataType DataType
		{
			get {
				return _DataType.Entity;
			}
			set {
				DataType previousValue = _DataType.Entity;
				if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
					SendPropertyChanging();
					if (previousValue != null) {
						_DataType.Entity = null;
						previousValue.AlgorithmParameterStringValues.Remove(this);
					}
					_DataType.Entity = value;
					if (value != null) {
						value.AlgorithmParameterStringValues.Add(this);
						_DataTypeId = value.Id;
					}
					else {
						_DataTypeId = default(long);
					}
					SendPropertyChanged("DataType");
				}
			}
		}

		private EntityRef<Experiment> _Experiment;
		[Association(Name=@"Experiment_AlgorithmParameterStringValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=7, 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.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()
		{
			_DataType = default(EntityRef<DataType>);
			_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 OnDataTypeIdChanging(long value);
		partial void OnDataTypeIdChanged();
		private long _DataTypeId;
		[Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
		[DataMember(Order=3)]
		public long DataTypeId
		{
			get { return _DataTypeId; }
			set {
				if (_DataTypeId != value) {
					if (_DataType.HasLoadedOrAssignedValue) {
						throw new ForeignKeyReferenceAlreadyHasValueException();
					}
					OnDataTypeIdChanging(value);
					SendPropertyChanging();
					_DataTypeId = value;
					SendPropertyChanged("DataTypeId");
					OnDataTypeIdChanged();
				}
			}
		}
		
		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=4)]
		public Binary Value
		{
			get { return _Value; }
			set {
				if (_Value != value) {
					OnValueChanging(value);
					SendPropertyChanging();
					_Value = value;
					SendPropertyChanged("Value");
					OnValueChanged();
				}
			}
		}
		
		#endregion
		
		#region Associations
		private EntityRef<DataType> _DataType;
		[Association(Name=@"DataType_ProblemParameterBlobValue", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=5, EmitDefaultValue=false)]
		public DataType DataType
		{
			get {
				return _DataType.Entity;
			}
			set {
				DataType previousValue = _DataType.Entity;
				if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
					SendPropertyChanging();
					if (previousValue != null) {
						_DataType.Entity = null;
						previousValue.ProblemParameterBlobValues.Remove(this);
					}
					_DataType.Entity = value;
					if (value != null) {
						value.ProblemParameterBlobValues.Add(this);
						_DataTypeId = value.Id;
					}
					else {
						_DataTypeId = default(long);
					}
					SendPropertyChanged("DataType");
				}
			}
		}

		private EntityRef<Experiment> _Experiment;
		[Association(Name=@"Experiment_ProblemParameterBlobValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=6, 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=7, 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.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()
		{
			_DataType = default(EntityRef<DataType>);
			_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 OnDataTypeIdChanging(long value);
		partial void OnDataTypeIdChanged();
		private long _DataTypeId;
		[Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
		[DataMember(Order=3)]
		public long DataTypeId
		{
			get { return _DataTypeId; }
			set {
				if (_DataTypeId != value) {
					if (_DataType.HasLoadedOrAssignedValue) {
						throw new ForeignKeyReferenceAlreadyHasValueException();
					}
					OnDataTypeIdChanging(value);
					SendPropertyChanging();
					_DataTypeId = value;
					SendPropertyChanged("DataTypeId");
					OnDataTypeIdChanged();
				}
			}
		}
		
		partial void OnValueChanging(bool value);
		partial void OnValueChanged();
		private bool _Value;
		[Column(Storage=@"_Value", DbType=@"Bit NOT NULL", CanBeNull=false)]
		[DataMember(Order=4)]
		public bool Value
		{
			get { return _Value; }
			set {
				if (_Value != value) {
					OnValueChanging(value);
					SendPropertyChanging();
					_Value = value;
					SendPropertyChanged("Value");
					OnValueChanged();
				}
			}
		}
		
		#endregion
		
		#region Associations
		private EntityRef<DataType> _DataType;
		[Association(Name=@"DataType_ProblemParameterBoolValue", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=5, EmitDefaultValue=false)]
		public DataType DataType
		{
			get {
				return _DataType.Entity;
			}
			set {
				DataType previousValue = _DataType.Entity;
				if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
					SendPropertyChanging();
					if (previousValue != null) {
						_DataType.Entity = null;
						previousValue.ProblemParameterBoolValues.Remove(this);
					}
					_DataType.Entity = value;
					if (value != null) {
						value.ProblemParameterBoolValues.Add(this);
						_DataTypeId = value.Id;
					}
					else {
						_DataTypeId = default(long);
					}
					SendPropertyChanged("DataType");
				}
			}
		}

		private EntityRef<Experiment> _Experiment;
		[Association(Name=@"Experiment_ProblemParameterBoolValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=6, 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=7, 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()
		{
			_DataType = default(EntityRef<DataType>);
			_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 OnDataTypeIdChanging(long value);
		partial void OnDataTypeIdChanged();
		private long _DataTypeId;
		[Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
		[DataMember(Order=3)]
		public long DataTypeId
		{
			get { return _DataTypeId; }
			set {
				if (_DataTypeId != value) {
					if (_DataType.HasLoadedOrAssignedValue) {
						throw new ForeignKeyReferenceAlreadyHasValueException();
					}
					OnDataTypeIdChanging(value);
					SendPropertyChanging();
					_DataTypeId = value;
					SendPropertyChanged("DataTypeId");
					OnDataTypeIdChanged();
				}
			}
		}
		
		partial void OnValueChanging(double value);
		partial void OnValueChanged();
		private double _Value;
		[Column(Storage=@"_Value", DbType=@"Float NOT NULL", CanBeNull=false)]
		[DataMember(Order=4)]
		public double Value
		{
			get { return _Value; }
			set {
				if (_Value != value) {
					OnValueChanging(value);
					SendPropertyChanging();
					_Value = value;
					SendPropertyChanged("Value");
					OnValueChanged();
				}
			}
		}
		
		#endregion
		
		#region Associations
		private EntityRef<DataType> _DataType;
		[Association(Name=@"DataType_ProblemParameterFloatValue", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=5, EmitDefaultValue=false)]
		public DataType DataType
		{
			get {
				return _DataType.Entity;
			}
			set {
				DataType previousValue = _DataType.Entity;
				if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
					SendPropertyChanging();
					if (previousValue != null) {
						_DataType.Entity = null;
						previousValue.ProblemParameterFloatValues.Remove(this);
					}
					_DataType.Entity = value;
					if (value != null) {
						value.ProblemParameterFloatValues.Add(this);
						_DataTypeId = value.Id;
					}
					else {
						_DataTypeId = default(long);
					}
					SendPropertyChanged("DataType");
				}
			}
		}

		private EntityRef<Experiment> _Experiment;
		[Association(Name=@"Experiment_ProblemParameterFloatValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=6, 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=7, 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()
		{
			_DataType = default(EntityRef<DataType>);
			_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 OnDataTypeIdChanging(long value);
		partial void OnDataTypeIdChanged();
		private long _DataTypeId;
		[Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
		[DataMember(Order=3)]
		public long DataTypeId
		{
			get { return _DataTypeId; }
			set {
				if (_DataTypeId != value) {
					if (_DataType.HasLoadedOrAssignedValue) {
						throw new ForeignKeyReferenceAlreadyHasValueException();
					}
					OnDataTypeIdChanging(value);
					SendPropertyChanging();
					_DataTypeId = value;
					SendPropertyChanged("DataTypeId");
					OnDataTypeIdChanged();
				}
			}
		}
		
		partial void OnValueChanging(long value);
		partial void OnValueChanged();
		private long _Value;
		[Column(Storage=@"_Value", DbType=@"BigInt NOT NULL", CanBeNull=false)]
		[DataMember(Order=4)]
		public long Value
		{
			get { return _Value; }
			set {
				if (_Value != value) {
					OnValueChanging(value);
					SendPropertyChanging();
					_Value = value;
					SendPropertyChanged("Value");
					OnValueChanged();
				}
			}
		}
		
		#endregion
		
		#region Associations
		private EntityRef<DataType> _DataType;
		[Association(Name=@"DataType_ProblemParameterIntValue", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=5, EmitDefaultValue=false)]
		public DataType DataType
		{
			get {
				return _DataType.Entity;
			}
			set {
				DataType previousValue = _DataType.Entity;
				if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
					SendPropertyChanging();
					if (previousValue != null) {
						_DataType.Entity = null;
						previousValue.ProblemParameterIntValues.Remove(this);
					}
					_DataType.Entity = value;
					if (value != null) {
						value.ProblemParameterIntValues.Add(this);
						_DataTypeId = value.Id;
					}
					else {
						_DataTypeId = default(long);
					}
					SendPropertyChanged("DataType");
				}
			}
		}

		private EntityRef<Experiment> _Experiment;
		[Association(Name=@"Experiment_ProblemParameterIntValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=6, 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=7, 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()
		{
			_DataType = default(EntityRef<DataType>);
			_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 OnDataTypeIdChanging(long value);
		partial void OnDataTypeIdChanged();
		private long _DataTypeId;
		[Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
		[DataMember(Order=3)]
		public long DataTypeId
		{
			get { return _DataTypeId; }
			set {
				if (_DataTypeId != value) {
					if (_DataType.HasLoadedOrAssignedValue) {
						throw new ForeignKeyReferenceAlreadyHasValueException();
					}
					OnDataTypeIdChanging(value);
					SendPropertyChanging();
					_DataTypeId = value;
					SendPropertyChanged("DataTypeId");
					OnDataTypeIdChanged();
				}
			}
		}
		
		partial void OnValueChanging(string value);
		partial void OnValueChanged();
		private string _Value;
		[Column(Storage=@"_Value", DbType=@"NVarChar(MAX) NOT NULL", CanBeNull=false)]
		[DataMember(Order=4)]
		public string Value
		{
			get { return _Value; }
			set {
				if (_Value != value) {
					OnValueChanging(value);
					SendPropertyChanging();
					_Value = value;
					SendPropertyChanged("Value");
					OnValueChanged();
				}
			}
		}
		
		#endregion
		
		#region Associations
		private EntityRef<DataType> _DataType;
		[Association(Name=@"DataType_ProblemParameterStringValue", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=5, EmitDefaultValue=false)]
		public DataType DataType
		{
			get {
				return _DataType.Entity;
			}
			set {
				DataType previousValue = _DataType.Entity;
				if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
					SendPropertyChanging();
					if (previousValue != null) {
						_DataType.Entity = null;
						previousValue.ProblemParameterStringValues.Remove(this);
					}
					_DataType.Entity = value;
					if (value != null) {
						value.ProblemParameterStringValues.Add(this);
						_DataTypeId = value.Id;
					}
					else {
						_DataTypeId = default(long);
					}
					SendPropertyChanged("DataType");
				}
			}
		}

		private EntityRef<Experiment> _Experiment;
		[Association(Name=@"Experiment_ProblemParameterStringValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=6, 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=7, 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.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()
		{
			_DataType = default(EntityRef<DataType>);
			_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 OnDataTypeIdChanging(long value);
		partial void OnDataTypeIdChanged();
		private long _DataTypeId;
		[Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
		[DataMember(Order=3)]
		public long DataTypeId
		{
			get { return _DataTypeId; }
			set {
				if (_DataTypeId != value) {
					if (_DataType.HasLoadedOrAssignedValue) {
						throw new ForeignKeyReferenceAlreadyHasValueException();
					}
					OnDataTypeIdChanging(value);
					SendPropertyChanging();
					_DataTypeId = value;
					SendPropertyChanged("DataTypeId");
					OnDataTypeIdChanged();
				}
			}
		}
		
		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=4)]
		public Binary Value
		{
			get { return _Value; }
			set {
				if (_Value != value) {
					OnValueChanging(value);
					SendPropertyChanging();
					_Value = value;
					SendPropertyChanged("Value");
					OnValueChanged();
				}
			}
		}
		
		#endregion
		
		#region Associations
		private EntityRef<DataType> _DataType;
		[Association(Name=@"DataType_ResultBlobValue", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=5, EmitDefaultValue=false)]
		public DataType DataType
		{
			get {
				return _DataType.Entity;
			}
			set {
				DataType previousValue = _DataType.Entity;
				if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
					SendPropertyChanging();
					if (previousValue != null) {
						_DataType.Entity = null;
						previousValue.ResultBlobValues.Remove(this);
					}
					_DataType.Entity = value;
					if (value != null) {
						value.ResultBlobValues.Add(this);
						_DataTypeId = value.Id;
					}
					else {
						_DataTypeId = default(long);
					}
					SendPropertyChanged("DataType");
				}
			}
		}

		private EntityRef<Result> _Result;
		[Association(Name=@"Result_ResultBlobValue", Storage=@"_Result", ThisKey=@"ResultId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=6, 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=7, 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()
		{
			_DataType = default(EntityRef<DataType>);
			_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 OnDataTypeIdChanging(long value);
		partial void OnDataTypeIdChanged();
		private long _DataTypeId;
		[Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
		[DataMember(Order=3)]
		public long DataTypeId
		{
			get { return _DataTypeId; }
			set {
				if (_DataTypeId != value) {
					if (_DataType.HasLoadedOrAssignedValue) {
						throw new ForeignKeyReferenceAlreadyHasValueException();
					}
					OnDataTypeIdChanging(value);
					SendPropertyChanging();
					_DataTypeId = value;
					SendPropertyChanged("DataTypeId");
					OnDataTypeIdChanged();
				}
			}
		}
		
		partial void OnValueChanging(bool value);
		partial void OnValueChanged();
		private bool _Value;
		[Column(Storage=@"_Value", DbType=@"Bit NOT NULL", CanBeNull=false)]
		[DataMember(Order=4)]
		public bool Value
		{
			get { return _Value; }
			set {
				if (_Value != value) {
					OnValueChanging(value);
					SendPropertyChanging();
					_Value = value;
					SendPropertyChanged("Value");
					OnValueChanged();
				}
			}
		}
		
		#endregion
		
		#region Associations
		private EntityRef<DataType> _DataType;
		[Association(Name=@"DataType_ResultBoolValue", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=5, EmitDefaultValue=false)]
		public DataType DataType
		{
			get {
				return _DataType.Entity;
			}
			set {
				DataType previousValue = _DataType.Entity;
				if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
					SendPropertyChanging();
					if (previousValue != null) {
						_DataType.Entity = null;
						previousValue.ResultBoolValues.Remove(this);
					}
					_DataType.Entity = value;
					if (value != null) {
						value.ResultBoolValues.Add(this);
						_DataTypeId = value.Id;
					}
					else {
						_DataTypeId = default(long);
					}
					SendPropertyChanged("DataType");
				}
			}
		}

		private EntityRef<Result> _Result;
		[Association(Name=@"Result_ResultBoolValue", Storage=@"_Result", ThisKey=@"ResultId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=6, 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=7, 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()
		{
			_DataType = default(EntityRef<DataType>);
			_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 OnDataTypeIdChanging(long value);
		partial void OnDataTypeIdChanged();
		private long _DataTypeId;
		[Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
		[DataMember(Order=3)]
		public long DataTypeId
		{
			get { return _DataTypeId; }
			set {
				if (_DataTypeId != value) {
					if (_DataType.HasLoadedOrAssignedValue) {
						throw new ForeignKeyReferenceAlreadyHasValueException();
					}
					OnDataTypeIdChanging(value);
					SendPropertyChanging();
					_DataTypeId = value;
					SendPropertyChanged("DataTypeId");
					OnDataTypeIdChanged();
				}
			}
		}
		
		partial void OnValueChanging(double value);
		partial void OnValueChanged();
		private double _Value;
		[Column(Storage=@"_Value", DbType=@"Float NOT NULL", CanBeNull=false)]
		[DataMember(Order=4)]
		public double Value
		{
			get { return _Value; }
			set {
				if (_Value != value) {
					OnValueChanging(value);
					SendPropertyChanging();
					_Value = value;
					SendPropertyChanged("Value");
					OnValueChanged();
				}
			}
		}
		
		#endregion
		
		#region Associations
		private EntityRef<DataType> _DataType;
		[Association(Name=@"DataType_ResultFloatValue", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=5, EmitDefaultValue=false)]
		public DataType DataType
		{
			get {
				return _DataType.Entity;
			}
			set {
				DataType previousValue = _DataType.Entity;
				if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
					SendPropertyChanging();
					if (previousValue != null) {
						_DataType.Entity = null;
						previousValue.ResultFloatValues.Remove(this);
					}
					_DataType.Entity = value;
					if (value != null) {
						value.ResultFloatValues.Add(this);
						_DataTypeId = value.Id;
					}
					else {
						_DataTypeId = default(long);
					}
					SendPropertyChanged("DataType");
				}
			}
		}

		private EntityRef<Result> _Result;
		[Association(Name=@"Result_ResultFloatValue", Storage=@"_Result", ThisKey=@"ResultId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=6, 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=7, 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()
		{
			_DataType = default(EntityRef<DataType>);
			_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 OnDataTypeIdChanging(long value);
		partial void OnDataTypeIdChanged();
		private long _DataTypeId;
		[Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
		[DataMember(Order=3)]
		public long DataTypeId
		{
			get { return _DataTypeId; }
			set {
				if (_DataTypeId != value) {
					if (_DataType.HasLoadedOrAssignedValue) {
						throw new ForeignKeyReferenceAlreadyHasValueException();
					}
					OnDataTypeIdChanging(value);
					SendPropertyChanging();
					_DataTypeId = value;
					SendPropertyChanged("DataTypeId");
					OnDataTypeIdChanged();
				}
			}
		}
		
		partial void OnValueChanging(long value);
		partial void OnValueChanged();
		private long _Value;
		[Column(Storage=@"_Value", DbType=@"BigInt NOT NULL", CanBeNull=false)]
		[DataMember(Order=4)]
		public long Value
		{
			get { return _Value; }
			set {
				if (_Value != value) {
					OnValueChanging(value);
					SendPropertyChanging();
					_Value = value;
					SendPropertyChanged("Value");
					OnValueChanged();
				}
			}
		}
		
		#endregion
		
		#region Associations
		private EntityRef<DataType> _DataType;
		[Association(Name=@"DataType_ResultIntValue", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=5, EmitDefaultValue=false)]
		public DataType DataType
		{
			get {
				return _DataType.Entity;
			}
			set {
				DataType previousValue = _DataType.Entity;
				if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
					SendPropertyChanging();
					if (previousValue != null) {
						_DataType.Entity = null;
						previousValue.ResultIntValues.Remove(this);
					}
					_DataType.Entity = value;
					if (value != null) {
						value.ResultIntValues.Add(this);
						_DataTypeId = value.Id;
					}
					else {
						_DataTypeId = default(long);
					}
					SendPropertyChanged("DataType");
				}
			}
		}

		private EntityRef<Result> _Result;
		[Association(Name=@"Result_ResultIntValue", Storage=@"_Result", ThisKey=@"ResultId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=6, 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=7, 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()
		{
			_DataType = default(EntityRef<DataType>);
			_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 OnDataTypeIdChanging(long value);
		partial void OnDataTypeIdChanged();
		private long _DataTypeId;
		[Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
		[DataMember(Order=3)]
		public long DataTypeId
		{
			get { return _DataTypeId; }
			set {
				if (_DataTypeId != value) {
					if (_DataType.HasLoadedOrAssignedValue) {
						throw new ForeignKeyReferenceAlreadyHasValueException();
					}
					OnDataTypeIdChanging(value);
					SendPropertyChanging();
					_DataTypeId = value;
					SendPropertyChanged("DataTypeId");
					OnDataTypeIdChanged();
				}
			}
		}
		
		partial void OnValueChanging(string value);
		partial void OnValueChanged();
		private string _Value;
		[Column(Storage=@"_Value", DbType=@"NVarChar(MAX) NOT NULL", CanBeNull=false)]
		[DataMember(Order=4)]
		public string Value
		{
			get { return _Value; }
			set {
				if (_Value != value) {
					OnValueChanging(value);
					SendPropertyChanging();
					_Value = value;
					SendPropertyChanged("Value");
					OnValueChanged();
				}
			}
		}
		
		#endregion
		
		#region Associations
		private EntityRef<DataType> _DataType;
		[Association(Name=@"DataType_ResultStringValue", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=5, EmitDefaultValue=false)]
		public DataType DataType
		{
			get {
				return _DataType.Entity;
			}
			set {
				DataType previousValue = _DataType.Entity;
				if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
					SendPropertyChanging();
					if (previousValue != null) {
						_DataType.Entity = null;
						previousValue.ResultStringValues.Remove(this);
					}
					_DataType.Entity = value;
					if (value != null) {
						value.ResultStringValues.Add(this);
						_DataTypeId = value.Id;
					}
					else {
						_DataTypeId = default(long);
					}
					SendPropertyChanged("DataType");
				}
			}
		}

		private EntityRef<Result> _Result;
		[Association(Name=@"Result_ResultStringValue", Storage=@"_Result", ThisKey=@"ResultId", OtherKey=@"Id", IsForeignKey=true)]
		[DataMember(Order=6, 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=7, 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
	}
}
#pragma warning restore 1591