Free cookie consent management tool by TermsFeed Policy Generator

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

Last change on this file since 4384 was 4384, checked in by swagner, 14 years ago

Worked on OKB data model (#1174)

File size: 254.2 KB
Line 
1#pragma warning disable 1591
2//------------------------------------------------------------------------------
3// <auto-generated>
4//     This code was generated by LINQ to SQL template for T4 C#
5//     Generated at 09/13/2010 13:15:17
6//
7//     Changes to this file may cause incorrect behavior and will be lost if
8//     the code is regenerated.
9// </auto-generated>
10//------------------------------------------------------------------------------
11using System;
12using System.ComponentModel;
13using System.Data.Linq;
14using System.Data.Linq.Mapping;
15using System.Runtime.Serialization;
16
17namespace HeuristicLab.Services.OKB.DataAccess
18{
19  [DatabaseAttribute(Name=@"OKB")]
20  public partial class OKBDataContext : DataContext
21  {
22    private static MappingSource mappingSource = new AttributeMappingSource();
23   
24    #region Extensibility Method Definitions
25    partial void OnCreated();
26    partial void InsertAlgorithmClass(AlgorithmClass instance);
27    partial void UpdateAlgorithmClass(AlgorithmClass instance);
28    partial void DeleteAlgorithmClass(AlgorithmClass instance);
29    partial void InsertAlgorithm(Algorithm instance);
30    partial void UpdateAlgorithm(Algorithm instance);
31    partial void DeleteAlgorithm(Algorithm instance);
32    partial void InsertProblem(Problem instance);
33    partial void UpdateProblem(Problem instance);
34    partial void DeleteProblem(Problem instance);
35    partial void InsertProblemClass(ProblemClass instance);
36    partial void UpdateProblemClass(ProblemClass instance);
37    partial void DeleteProblemClass(ProblemClass instance);
38    partial void InsertExperiment(Experiment instance);
39    partial void UpdateExperiment(Experiment instance);
40    partial void DeleteExperiment(Experiment instance);
41    partial void InsertAlgorithmParameter(AlgorithmParameter instance);
42    partial void UpdateAlgorithmParameter(AlgorithmParameter instance);
43    partial void DeleteAlgorithmParameter(AlgorithmParameter instance);
44    partial void InsertProblemParameter(ProblemParameter instance);
45    partial void UpdateProblemParameter(ProblemParameter instance);
46    partial void DeleteProblemParameter(ProblemParameter instance);
47    partial void InsertAlgorithmParameterBlobValue(AlgorithmParameterBlobValue instance);
48    partial void UpdateAlgorithmParameterBlobValue(AlgorithmParameterBlobValue instance);
49    partial void DeleteAlgorithmParameterBlobValue(AlgorithmParameterBlobValue instance);
50    partial void InsertProblemParameterBlobValue(ProblemParameterBlobValue instance);
51    partial void UpdateProblemParameterBlobValue(ProblemParameterBlobValue instance);
52    partial void DeleteProblemParameterBlobValue(ProblemParameterBlobValue instance);
53    partial void InsertAlgorithmParameterBoolValue(AlgorithmParameterBoolValue instance);
54    partial void UpdateAlgorithmParameterBoolValue(AlgorithmParameterBoolValue instance);
55    partial void DeleteAlgorithmParameterBoolValue(AlgorithmParameterBoolValue instance);
56    partial void InsertAlgorithmParameterFloatValue(AlgorithmParameterFloatValue instance);
57    partial void UpdateAlgorithmParameterFloatValue(AlgorithmParameterFloatValue instance);
58    partial void DeleteAlgorithmParameterFloatValue(AlgorithmParameterFloatValue instance);
59    partial void InsertAlgorithmParameterIntValue(AlgorithmParameterIntValue instance);
60    partial void UpdateAlgorithmParameterIntValue(AlgorithmParameterIntValue instance);
61    partial void DeleteAlgorithmParameterIntValue(AlgorithmParameterIntValue instance);
62    partial void InsertAlgorithmParameterStringValue(AlgorithmParameterStringValue instance);
63    partial void UpdateAlgorithmParameterStringValue(AlgorithmParameterStringValue instance);
64    partial void DeleteAlgorithmParameterStringValue(AlgorithmParameterStringValue instance);
65    partial void InsertProblemParameterBoolValue(ProblemParameterBoolValue instance);
66    partial void UpdateProblemParameterBoolValue(ProblemParameterBoolValue instance);
67    partial void DeleteProblemParameterBoolValue(ProblemParameterBoolValue instance);
68    partial void InsertProblemParameterFloatValue(ProblemParameterFloatValue instance);
69    partial void UpdateProblemParameterFloatValue(ProblemParameterFloatValue instance);
70    partial void DeleteProblemParameterFloatValue(ProblemParameterFloatValue instance);
71    partial void InsertProblemParameterIntValue(ProblemParameterIntValue instance);
72    partial void UpdateProblemParameterIntValue(ProblemParameterIntValue instance);
73    partial void DeleteProblemParameterIntValue(ProblemParameterIntValue instance);
74    partial void InsertProblemParameterStringValue(ProblemParameterStringValue instance);
75    partial void UpdateProblemParameterStringValue(ProblemParameterStringValue instance);
76    partial void DeleteProblemParameterStringValue(ProblemParameterStringValue instance);
77    partial void InsertAlgorithmData(AlgorithmData instance);
78    partial void UpdateAlgorithmData(AlgorithmData instance);
79    partial void DeleteAlgorithmData(AlgorithmData instance);
80    partial void InsertUser(User instance);
81    partial void UpdateUser(User instance);
82    partial void DeleteUser(User instance);
83    partial void InsertProblemData(ProblemData instance);
84    partial void UpdateProblemData(ProblemData instance);
85    partial void DeleteProblemData(ProblemData instance);
86    partial void InsertAlgorithmUser(AlgorithmUser instance);
87    partial void UpdateAlgorithmUser(AlgorithmUser instance);
88    partial void DeleteAlgorithmUser(AlgorithmUser instance);
89    partial void InsertProblemUser(ProblemUser instance);
90    partial void UpdateProblemUser(ProblemUser instance);
91    partial void DeleteProblemUser(ProblemUser instance);
92    partial void InsertPlatform(Platform instance);
93    partial void UpdatePlatform(Platform instance);
94    partial void DeletePlatform(Platform instance);
95    partial void InsertSolutionRepresentation(SolutionRepresentation instance);
96    partial void UpdateSolutionRepresentation(SolutionRepresentation instance);
97    partial void DeleteSolutionRepresentation(SolutionRepresentation instance);
98    partial void InsertRun(Run instance);
99    partial void UpdateRun(Run instance);
100    partial void DeleteRun(Run instance);
101    partial void InsertResult(Result instance);
102    partial void UpdateResult(Result instance);
103    partial void DeleteResult(Result instance);
104    partial void InsertResultBlobValue(ResultBlobValue instance);
105    partial void UpdateResultBlobValue(ResultBlobValue instance);
106    partial void DeleteResultBlobValue(ResultBlobValue instance);
107    partial void InsertResultBoolValue(ResultBoolValue instance);
108    partial void UpdateResultBoolValue(ResultBoolValue instance);
109    partial void DeleteResultBoolValue(ResultBoolValue instance);
110    partial void InsertResultFloatValue(ResultFloatValue instance);
111    partial void UpdateResultFloatValue(ResultFloatValue instance);
112    partial void DeleteResultFloatValue(ResultFloatValue instance);
113    partial void InsertResultIntValue(ResultIntValue instance);
114    partial void UpdateResultIntValue(ResultIntValue instance);
115    partial void DeleteResultIntValue(ResultIntValue instance);
116    partial void InsertResultStringValue(ResultStringValue instance);
117    partial void UpdateResultStringValue(ResultStringValue instance);
118    partial void DeleteResultStringValue(ResultStringValue instance);
119    partial void InsertClient(Client instance);
120    partial void UpdateClient(Client instance);
121    partial void DeleteClient(Client instance);
122    partial void InsertDataType(DataType instance);
123    partial void UpdateDataType(DataType instance);
124    partial void DeleteDataType(DataType instance);
125    partial void InsertProblemCharacteristic(ProblemCharacteristic instance);
126    partial void UpdateProblemCharacteristic(ProblemCharacteristic instance);
127    partial void DeleteProblemCharacteristic(ProblemCharacteristic instance);
128    partial void InsertProblemCharacteristicFloatValue(ProblemCharacteristicFloatValue instance);
129    partial void UpdateProblemCharacteristicFloatValue(ProblemCharacteristicFloatValue instance);
130    partial void DeleteProblemCharacteristicFloatValue(ProblemCharacteristicFloatValue instance);
131    partial void InsertProblemCharacteristicIntValue(ProblemCharacteristicIntValue instance);
132    partial void UpdateProblemCharacteristicIntValue(ProblemCharacteristicIntValue instance);
133    partial void DeleteProblemCharacteristicIntValue(ProblemCharacteristicIntValue instance);
134    partial void InsertProblemCharacteristicStringValue(ProblemCharacteristicStringValue instance);
135    partial void UpdateProblemCharacteristicStringValue(ProblemCharacteristicStringValue instance);
136    partial void DeleteProblemCharacteristicStringValue(ProblemCharacteristicStringValue instance);
137    #endregion
138   
139    #region Construction
140    public OKBDataContext() :
141      base(global::HeuristicLab.Services.OKB.DataAccess.Properties.Settings.Default.OKBConnectionString, mappingSource)
142    {
143      OnCreated();
144    }
145 
146    public OKBDataContext(string connection) :
147      base(connection, mappingSource)
148    {
149      OnCreated();
150    }
151   
152    public OKBDataContext(System.Data.IDbConnection connection) :
153      base(connection, mappingSource)
154    {
155      OnCreated();
156    }
157   
158    public OKBDataContext(string connection, MappingSource mappingSource) :
159      base(connection, mappingSource)
160    {
161      OnCreated();
162    }
163   
164    public OKBDataContext(System.Data.IDbConnection connection, MappingSource mappingSource) :
165      base(connection, mappingSource)
166    {
167      OnCreated();
168    }
169    #endregion
170   
171    #region Tables
172    public Table<AlgorithmClass> AlgorithmClasses
173    {
174      get { return GetTable<AlgorithmClass>(); }
175    }
176   
177    public Table<Algorithm> Algorithms
178    {
179      get { return GetTable<Algorithm>(); }
180    }
181   
182    public Table<Problem> Problems
183    {
184      get { return GetTable<Problem>(); }
185    }
186   
187    public Table<ProblemClass> ProblemClasses
188    {
189      get { return GetTable<ProblemClass>(); }
190    }
191   
192    public Table<Experiment> Experiments
193    {
194      get { return GetTable<Experiment>(); }
195    }
196   
197    public Table<AlgorithmParameter> AlgorithmParameters
198    {
199      get { return GetTable<AlgorithmParameter>(); }
200    }
201   
202    public Table<ProblemParameter> ProblemParameters
203    {
204      get { return GetTable<ProblemParameter>(); }
205    }
206   
207    public Table<AlgorithmParameterBlobValue> AlgorithmParameterBlobValues
208    {
209      get { return GetTable<AlgorithmParameterBlobValue>(); }
210    }
211   
212    public Table<ProblemParameterBlobValue> ProblemParameterBlobValues
213    {
214      get { return GetTable<ProblemParameterBlobValue>(); }
215    }
216   
217    public Table<AlgorithmParameterBoolValue> AlgorithmParameterBoolValues
218    {
219      get { return GetTable<AlgorithmParameterBoolValue>(); }
220    }
221   
222    public Table<AlgorithmParameterFloatValue> AlgorithmParameterFloatValues
223    {
224      get { return GetTable<AlgorithmParameterFloatValue>(); }
225    }
226   
227    public Table<AlgorithmParameterIntValue> AlgorithmParameterIntValues
228    {
229      get { return GetTable<AlgorithmParameterIntValue>(); }
230    }
231   
232    public Table<AlgorithmParameterStringValue> AlgorithmParameterStringValues
233    {
234      get { return GetTable<AlgorithmParameterStringValue>(); }
235    }
236   
237    public Table<ProblemParameterBoolValue> ProblemParameterBoolValues
238    {
239      get { return GetTable<ProblemParameterBoolValue>(); }
240    }
241   
242    public Table<ProblemParameterFloatValue> ProblemParameterFloatValues
243    {
244      get { return GetTable<ProblemParameterFloatValue>(); }
245    }
246   
247    public Table<ProblemParameterIntValue> ProblemParameterIntValues
248    {
249      get { return GetTable<ProblemParameterIntValue>(); }
250    }
251   
252    public Table<ProblemParameterStringValue> ProblemParameterStringValues
253    {
254      get { return GetTable<ProblemParameterStringValue>(); }
255    }
256   
257    public Table<AlgorithmData> AlgorithmDatas
258    {
259      get { return GetTable<AlgorithmData>(); }
260    }
261   
262    public Table<User> Users
263    {
264      get { return GetTable<User>(); }
265    }
266   
267    public Table<ProblemData> ProblemDatas
268    {
269      get { return GetTable<ProblemData>(); }
270    }
271   
272    public Table<AlgorithmUser> AlgorithmUsers
273    {
274      get { return GetTable<AlgorithmUser>(); }
275    }
276   
277    public Table<ProblemUser> ProblemUsers
278    {
279      get { return GetTable<ProblemUser>(); }
280    }
281   
282    public Table<Platform> Platforms
283    {
284      get { return GetTable<Platform>(); }
285    }
286   
287    public Table<SolutionRepresentation> SolutionRepresentations
288    {
289      get { return GetTable<SolutionRepresentation>(); }
290    }
291   
292    public Table<Run> Runs
293    {
294      get { return GetTable<Run>(); }
295    }
296   
297    public Table<Result> Results
298    {
299      get { return GetTable<Result>(); }
300    }
301   
302    public Table<ResultBlobValue> ResultBlobValues
303    {
304      get { return GetTable<ResultBlobValue>(); }
305    }
306   
307    public Table<ResultBoolValue> ResultBoolValues
308    {
309      get { return GetTable<ResultBoolValue>(); }
310    }
311   
312    public Table<ResultFloatValue> ResultFloatValues
313    {
314      get { return GetTable<ResultFloatValue>(); }
315    }
316   
317    public Table<ResultIntValue> ResultIntValues
318    {
319      get { return GetTable<ResultIntValue>(); }
320    }
321   
322    public Table<ResultStringValue> ResultStringValues
323    {
324      get { return GetTable<ResultStringValue>(); }
325    }
326   
327    public Table<Client> Clients
328    {
329      get { return GetTable<Client>(); }
330    }
331   
332    public Table<DataType> DataTypes
333    {
334      get { return GetTable<DataType>(); }
335    }
336   
337    public Table<ProblemCharacteristic> ProblemCharacteristics
338    {
339      get { return GetTable<ProblemCharacteristic>(); }
340    }
341   
342    public Table<ProblemCharacteristicFloatValue> ProblemCharacteristicFloatValues
343    {
344      get { return GetTable<ProblemCharacteristicFloatValue>(); }
345    }
346   
347    public Table<ProblemCharacteristicIntValue> ProblemCharacteristicIntValues
348    {
349      get { return GetTable<ProblemCharacteristicIntValue>(); }
350    }
351   
352    public Table<ProblemCharacteristicStringValue> ProblemCharacteristicStringValues
353    {
354      get { return GetTable<ProblemCharacteristicStringValue>(); }
355    }
356   
357    #endregion
358  }
359}
360
361namespace HeuristicLab.Services.OKB.DataAccess
362{
363  [DataContract(IsReference=true)]
364  [Table(Name=@"dbo.AlgorithmClass")]
365[KnownType(typeof(AlgorithmClass))] public partial class AlgorithmClass : INotifyPropertyChanging, INotifyPropertyChanged
366  {
367    #region Property Change Event Handling
368    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
369   
370    public event PropertyChangingEventHandler PropertyChanging;
371    public event PropertyChangedEventHandler PropertyChanged;
372   
373    public virtual void SendPropertyChanging()
374    {
375      if (PropertyChanging != null) {
376        PropertyChanging(this, emptyChangingEventArgs);
377      }
378    }
379     
380    public virtual void SendPropertyChanged(String propertyName)
381    {
382      if (PropertyChanged != null) {
383        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
384      }
385    }
386    #endregion
387   
388    #region Extensibility Method Definitions
389    partial void OnLoaded();
390    partial void OnValidate(ChangeAction action);
391    partial void OnCreated();
392    #endregion
393
394    #region Construction
395    public AlgorithmClass()
396    {
397      Initialize();
398    }
399   
400    private void Initialize()
401    {
402      _Algorithms = new EntitySet<Algorithm>(attach_Algorithms, detach_Algorithms);
403      OnCreated();
404    }
405    #endregion
406
407    #region Column Mappings
408    partial void OnIdChanging(long value);
409    partial void OnIdChanged();
410    private long _Id;
411    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
412    [DataMember(Order=1)]
413    public long Id
414    {
415      get { return _Id; }
416      set {
417        if (_Id != value) {
418          OnIdChanging(value);
419          SendPropertyChanging();
420          _Id = value;
421          SendPropertyChanged("Id");
422          OnIdChanged();
423        }
424      }
425    }
426   
427    partial void OnNameChanging(string value);
428    partial void OnNameChanged();
429    private string _Name;
430    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
431    [DataMember(Order=2)]
432    public string Name
433    {
434      get { return _Name; }
435      set {
436        if (_Name != value) {
437          OnNameChanging(value);
438          SendPropertyChanging();
439          _Name = value;
440          SendPropertyChanged("Name");
441          OnNameChanged();
442        }
443      }
444    }
445   
446    partial void OnDescriptionChanging(string value);
447    partial void OnDescriptionChanged();
448    private string _Description;
449    [Column(Storage=@"_Description", DbType=@"NVarChar(MAX)")]
450    [DataMember(Order=3)]
451    public string Description
452    {
453      get { return _Description; }
454      set {
455        if (_Description != value) {
456          OnDescriptionChanging(value);
457          SendPropertyChanging();
458          _Description = value;
459          SendPropertyChanged("Description");
460          OnDescriptionChanged();
461        }
462      }
463    }
464   
465    #endregion
466   
467    #region Associations
468    private EntitySet<Algorithm> _Algorithms;
469    [Association(Name=@"AlgorithmClass_Algorithm", Storage=@"_Algorithms", ThisKey=@"Id", OtherKey=@"AlgorithmClassId")]
470    [DataMember(Order=4, EmitDefaultValue=false)]
471    public EntitySet<Algorithm> Algorithms
472    {
473      get {
474        if (serializing && !_Algorithms.HasLoadedOrAssignedValues) {
475          return null;
476        }
477        return _Algorithms;
478      }
479      set {
480        _Algorithms.Assign(value);
481      }
482    }
483
484    private void attach_Algorithms(Algorithm entity)
485    {
486      SendPropertyChanging();
487      entity.AlgorithmClass = this;
488    }
489   
490    private void detach_Algorithms(Algorithm entity)
491    {
492      SendPropertyChanging();
493      entity.AlgorithmClass = null;
494    }
495    #endregion
496   
497    #region Serialization
498    private bool serializing;
499   
500    [OnSerializing()]
501    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
502    public void OnSerializing(StreamingContext context)
503    {
504      serializing = true;
505    }
506   
507    [OnSerialized()]
508    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
509    public void OnSerialized(StreamingContext context)
510    {
511      serializing = false;
512    }
513   
514    [OnDeserializing()]
515    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
516    public  void OnDeserializing(StreamingContext context)
517    {
518      Initialize();
519    }
520    #endregion
521  }
522}
523
524namespace HeuristicLab.Services.OKB.DataAccess
525{
526  [DataContract(IsReference=true)]
527  [Table(Name=@"dbo.Algorithm")]
528[KnownType(typeof(Algorithm))]  public partial class Algorithm : INotifyPropertyChanging, INotifyPropertyChanged
529  {
530    #region Property Change Event Handling
531    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
532   
533    public event PropertyChangingEventHandler PropertyChanging;
534    public event PropertyChangedEventHandler PropertyChanged;
535   
536    public virtual void SendPropertyChanging()
537    {
538      if (PropertyChanging != null) {
539        PropertyChanging(this, emptyChangingEventArgs);
540      }
541    }
542     
543    public virtual void SendPropertyChanged(String propertyName)
544    {
545      if (PropertyChanged != null) {
546        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
547      }
548    }
549    #endregion
550   
551    #region Extensibility Method Definitions
552    partial void OnLoaded();
553    partial void OnValidate(ChangeAction action);
554    partial void OnCreated();
555    #endregion
556
557    #region Construction
558    public Algorithm()
559    {
560      Initialize();
561    }
562   
563    private void Initialize()
564    {
565      _Experiments = new EntitySet<Experiment>(attach_Experiments, detach_Experiments);
566      _AlgorithmParameters = new EntitySet<AlgorithmParameter>(attach_AlgorithmParameters, detach_AlgorithmParameters);
567      _AlgorithmData = default(EntityRef<AlgorithmData>);
568      _AlgorithmUsers = new EntitySet<AlgorithmUser>(attach_AlgorithmUsers, detach_AlgorithmUsers);
569      _Results = new EntitySet<Result>(attach_Results, detach_Results);
570      _AlgorithmClass = default(EntityRef<AlgorithmClass>);
571      _Platform = default(EntityRef<Platform>);
572      OnCreated();
573    }
574    #endregion
575
576    #region Column Mappings
577    partial void OnIdChanging(long value);
578    partial void OnIdChanged();
579    private long _Id;
580    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
581    [DataMember(Order=1)]
582    public long Id
583    {
584      get { return _Id; }
585      set {
586        if (_Id != value) {
587          OnIdChanging(value);
588          SendPropertyChanging();
589          _Id = value;
590          SendPropertyChanged("Id");
591          OnIdChanged();
592        }
593      }
594    }
595   
596    partial void OnAlgorithmClassIdChanging(long value);
597    partial void OnAlgorithmClassIdChanged();
598    private long _AlgorithmClassId;
599    [Column(Storage=@"_AlgorithmClassId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
600    [DataMember(Order=2)]
601    public long AlgorithmClassId
602    {
603      get { return _AlgorithmClassId; }
604      set {
605        if (_AlgorithmClassId != value) {
606          if (_AlgorithmClass.HasLoadedOrAssignedValue) {
607            throw new ForeignKeyReferenceAlreadyHasValueException();
608          }
609          OnAlgorithmClassIdChanging(value);
610          SendPropertyChanging();
611          _AlgorithmClassId = value;
612          SendPropertyChanged("AlgorithmClassId");
613          OnAlgorithmClassIdChanged();
614        }
615      }
616    }
617   
618    partial void OnPlatformIdChanging(long value);
619    partial void OnPlatformIdChanged();
620    private long _PlatformId;
621    [Column(Storage=@"_PlatformId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
622    [DataMember(Order=3)]
623    public long PlatformId
624    {
625      get { return _PlatformId; }
626      set {
627        if (_PlatformId != value) {
628          if (_Platform.HasLoadedOrAssignedValue) {
629            throw new ForeignKeyReferenceAlreadyHasValueException();
630          }
631          OnPlatformIdChanging(value);
632          SendPropertyChanging();
633          _PlatformId = value;
634          SendPropertyChanged("PlatformId");
635          OnPlatformIdChanged();
636        }
637      }
638    }
639   
640    partial void OnNameChanging(string value);
641    partial void OnNameChanged();
642    private string _Name;
643    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
644    [DataMember(Order=4)]
645    public string Name
646    {
647      get { return _Name; }
648      set {
649        if (_Name != value) {
650          OnNameChanging(value);
651          SendPropertyChanging();
652          _Name = value;
653          SendPropertyChanged("Name");
654          OnNameChanged();
655        }
656      }
657    }
658   
659    partial void OnDescriptionChanging(string value);
660    partial void OnDescriptionChanged();
661    private string _Description;
662    [Column(Storage=@"_Description", DbType=@"NVarChar(MAX)")]
663    [DataMember(Order=5)]
664    public string Description
665    {
666      get { return _Description; }
667      set {
668        if (_Description != value) {
669          OnDescriptionChanging(value);
670          SendPropertyChanging();
671          _Description = value;
672          SendPropertyChanged("Description");
673          OnDescriptionChanged();
674        }
675      }
676    }
677   
678    #endregion
679   
680    #region Associations
681    private EntitySet<Experiment> _Experiments;
682    [Association(Name=@"Algorithm_Experiment", Storage=@"_Experiments", ThisKey=@"Id", OtherKey=@"AlgorithmId")]
683    [DataMember(Order=6, EmitDefaultValue=false)]
684    public EntitySet<Experiment> Experiments
685    {
686      get {
687        if (serializing && !_Experiments.HasLoadedOrAssignedValues) {
688          return null;
689        }
690        return _Experiments;
691      }
692      set {
693        _Experiments.Assign(value);
694      }
695    }
696
697    private void attach_Experiments(Experiment entity)
698    {
699      SendPropertyChanging();
700      entity.Algorithm = this;
701    }
702   
703    private void detach_Experiments(Experiment entity)
704    {
705      SendPropertyChanging();
706      entity.Algorithm = null;
707    }
708    private EntitySet<AlgorithmParameter> _AlgorithmParameters;
709    [Association(Name=@"Algorithm_AlgorithmParameter", Storage=@"_AlgorithmParameters", ThisKey=@"Id", OtherKey=@"AlgorithmId")]
710    [DataMember(Order=7, EmitDefaultValue=false)]
711    public EntitySet<AlgorithmParameter> AlgorithmParameters
712    {
713      get {
714        if (serializing && !_AlgorithmParameters.HasLoadedOrAssignedValues) {
715          return null;
716        }
717        return _AlgorithmParameters;
718      }
719      set {
720        _AlgorithmParameters.Assign(value);
721      }
722    }
723
724    private void attach_AlgorithmParameters(AlgorithmParameter entity)
725    {
726      SendPropertyChanging();
727      entity.Algorithm = this;
728    }
729   
730    private void detach_AlgorithmParameters(AlgorithmParameter entity)
731    {
732      SendPropertyChanging();
733      entity.Algorithm = null;
734    }
735    private EntityRef<AlgorithmData> _AlgorithmData;
736    [Association(Name=@"Algorithm_AlgorithmData", Storage=@"_AlgorithmData", ThisKey=@"Id", OtherKey=@"AlgorithmId", IsUnique=true, IsForeignKey=false)]
737    [DataMember(Order=8, EmitDefaultValue=false)]
738    public AlgorithmData AlgorithmData
739    {
740      get {
741        if (serializing && !_AlgorithmData.HasLoadedOrAssignedValue) {
742          return null;
743        }
744        return _AlgorithmData.Entity;
745      }
746      set {
747        AlgorithmData previousValue = _AlgorithmData.Entity;
748        if ((previousValue != value) || (!_AlgorithmData.HasLoadedOrAssignedValue)) {
749          SendPropertyChanging();
750          if (previousValue != null) {
751            _AlgorithmData.Entity = null;
752            previousValue.Algorithm = null;
753          }
754          _AlgorithmData.Entity = value;
755          if (value != null) {
756            value.Algorithm = this;
757          }
758          SendPropertyChanged("AlgorithmData");
759        }
760      }
761    }
762
763    private EntitySet<AlgorithmUser> _AlgorithmUsers;
764    [Association(Name=@"Algorithm_AlgorithmUser", Storage=@"_AlgorithmUsers", ThisKey=@"Id", OtherKey=@"AlgorithmId")]
765    [DataMember(Order=9, EmitDefaultValue=false)]
766    public EntitySet<AlgorithmUser> AlgorithmUsers
767    {
768      get {
769        if (serializing && !_AlgorithmUsers.HasLoadedOrAssignedValues) {
770          return null;
771        }
772        return _AlgorithmUsers;
773      }
774      set {
775        _AlgorithmUsers.Assign(value);
776      }
777    }
778
779    private void attach_AlgorithmUsers(AlgorithmUser entity)
780    {
781      SendPropertyChanging();
782      entity.Algorithm = this;
783    }
784   
785    private void detach_AlgorithmUsers(AlgorithmUser entity)
786    {
787      SendPropertyChanging();
788      entity.Algorithm = null;
789    }
790    private EntitySet<Result> _Results;
791    [Association(Name=@"Algorithm_Result", Storage=@"_Results", ThisKey=@"Id", OtherKey=@"AlgorithmId")]
792    [DataMember(Order=10, EmitDefaultValue=false)]
793    public EntitySet<Result> Results
794    {
795      get {
796        if (serializing && !_Results.HasLoadedOrAssignedValues) {
797          return null;
798        }
799        return _Results;
800      }
801      set {
802        _Results.Assign(value);
803      }
804    }
805
806    private void attach_Results(Result entity)
807    {
808      SendPropertyChanging();
809      entity.Algorithm = this;
810    }
811   
812    private void detach_Results(Result entity)
813    {
814      SendPropertyChanging();
815      entity.Algorithm = null;
816    }
817    private EntityRef<AlgorithmClass> _AlgorithmClass;
818    [Association(Name=@"AlgorithmClass_Algorithm", Storage=@"_AlgorithmClass", ThisKey=@"AlgorithmClassId", OtherKey=@"Id", IsForeignKey=true)]
819    [DataMember(Order=11, EmitDefaultValue=false)]
820    public AlgorithmClass AlgorithmClass
821    {
822      get {
823        if (serializing && !_AlgorithmClass.HasLoadedOrAssignedValue) {
824          return null;
825        }
826        return _AlgorithmClass.Entity;
827      }
828      set {
829        AlgorithmClass previousValue = _AlgorithmClass.Entity;
830        if ((previousValue != value) || (!_AlgorithmClass.HasLoadedOrAssignedValue)) {
831          SendPropertyChanging();
832          if (previousValue != null) {
833            _AlgorithmClass.Entity = null;
834            previousValue.Algorithms.Remove(this);
835          }
836          _AlgorithmClass.Entity = value;
837          if (value != null) {
838            value.Algorithms.Add(this);
839            _AlgorithmClassId = value.Id;
840          }
841          else {
842            _AlgorithmClassId = default(long);
843          }
844          SendPropertyChanged("AlgorithmClass");
845        }
846      }
847    }
848
849    private EntityRef<Platform> _Platform;
850    [Association(Name=@"Platform_Algorithm", Storage=@"_Platform", ThisKey=@"PlatformId", OtherKey=@"Id", IsForeignKey=true)]
851    [DataMember(Order=12, EmitDefaultValue=false)]
852    public Platform Platform
853    {
854      get {
855        if (serializing && !_Platform.HasLoadedOrAssignedValue) {
856          return null;
857        }
858        return _Platform.Entity;
859      }
860      set {
861        Platform previousValue = _Platform.Entity;
862        if ((previousValue != value) || (!_Platform.HasLoadedOrAssignedValue)) {
863          SendPropertyChanging();
864          if (previousValue != null) {
865            _Platform.Entity = null;
866            previousValue.Algorithms.Remove(this);
867          }
868          _Platform.Entity = value;
869          if (value != null) {
870            value.Algorithms.Add(this);
871            _PlatformId = value.Id;
872          }
873          else {
874            _PlatformId = default(long);
875          }
876          SendPropertyChanged("Platform");
877        }
878      }
879    }
880
881    #endregion
882   
883    #region Serialization
884    private bool serializing;
885   
886    [OnSerializing()]
887    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
888    public void OnSerializing(StreamingContext context)
889    {
890      serializing = true;
891    }
892   
893    [OnSerialized()]
894    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
895    public void OnSerialized(StreamingContext context)
896    {
897      serializing = false;
898    }
899   
900    [OnDeserializing()]
901    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
902    public  void OnDeserializing(StreamingContext context)
903    {
904      Initialize();
905    }
906    #endregion
907  }
908}
909
910namespace HeuristicLab.Services.OKB.DataAccess
911{
912  [DataContract(IsReference=true)]
913  [Table(Name=@"dbo.Problem")]
914[KnownType(typeof(Problem))]  public partial class Problem : INotifyPropertyChanging, INotifyPropertyChanged
915  {
916    #region Property Change Event Handling
917    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
918   
919    public event PropertyChangingEventHandler PropertyChanging;
920    public event PropertyChangedEventHandler PropertyChanged;
921   
922    public virtual void SendPropertyChanging()
923    {
924      if (PropertyChanging != null) {
925        PropertyChanging(this, emptyChangingEventArgs);
926      }
927    }
928     
929    public virtual void SendPropertyChanged(String propertyName)
930    {
931      if (PropertyChanged != null) {
932        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
933      }
934    }
935    #endregion
936   
937    #region Extensibility Method Definitions
938    partial void OnLoaded();
939    partial void OnValidate(ChangeAction action);
940    partial void OnCreated();
941    #endregion
942
943    #region Construction
944    public Problem()
945    {
946      Initialize();
947    }
948   
949    private void Initialize()
950    {
951      _Experiments = new EntitySet<Experiment>(attach_Experiments, detach_Experiments);
952      _ProblemParameters = new EntitySet<ProblemParameter>(attach_ProblemParameters, detach_ProblemParameters);
953      _ProblemData = default(EntityRef<ProblemData>);
954      _ProblemUsers = new EntitySet<ProblemUser>(attach_ProblemUsers, detach_ProblemUsers);
955      _ProblemCharacteristicFloatValues = new EntitySet<ProblemCharacteristicFloatValue>(attach_ProblemCharacteristicFloatValues, detach_ProblemCharacteristicFloatValues);
956      _ProblemCharacteristicIntValues = new EntitySet<ProblemCharacteristicIntValue>(attach_ProblemCharacteristicIntValues, detach_ProblemCharacteristicIntValues);
957      _ProblemCharacteristicStringValues = new EntitySet<ProblemCharacteristicStringValue>(attach_ProblemCharacteristicStringValues, detach_ProblemCharacteristicStringValues);
958      _ProblemClass = default(EntityRef<ProblemClass>);
959      _Platform = default(EntityRef<Platform>);
960      _SolutionRepresentation = default(EntityRef<SolutionRepresentation>);
961      OnCreated();
962    }
963    #endregion
964
965    #region Column Mappings
966    partial void OnIdChanging(long value);
967    partial void OnIdChanged();
968    private long _Id;
969    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
970    [DataMember(Order=1)]
971    public long Id
972    {
973      get { return _Id; }
974      set {
975        if (_Id != value) {
976          OnIdChanging(value);
977          SendPropertyChanging();
978          _Id = value;
979          SendPropertyChanged("Id");
980          OnIdChanged();
981        }
982      }
983    }
984   
985    partial void OnProblemClassIdChanging(long value);
986    partial void OnProblemClassIdChanged();
987    private long _ProblemClassId;
988    [Column(Storage=@"_ProblemClassId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
989    [DataMember(Order=2)]
990    public long ProblemClassId
991    {
992      get { return _ProblemClassId; }
993      set {
994        if (_ProblemClassId != value) {
995          if (_ProblemClass.HasLoadedOrAssignedValue) {
996            throw new ForeignKeyReferenceAlreadyHasValueException();
997          }
998          OnProblemClassIdChanging(value);
999          SendPropertyChanging();
1000          _ProblemClassId = value;
1001          SendPropertyChanged("ProblemClassId");
1002          OnProblemClassIdChanged();
1003        }
1004      }
1005    }
1006   
1007    partial void OnPlatformIdChanging(long value);
1008    partial void OnPlatformIdChanged();
1009    private long _PlatformId;
1010    [Column(Storage=@"_PlatformId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
1011    [DataMember(Order=3)]
1012    public long PlatformId
1013    {
1014      get { return _PlatformId; }
1015      set {
1016        if (_PlatformId != value) {
1017          if (_Platform.HasLoadedOrAssignedValue) {
1018            throw new ForeignKeyReferenceAlreadyHasValueException();
1019          }
1020          OnPlatformIdChanging(value);
1021          SendPropertyChanging();
1022          _PlatformId = value;
1023          SendPropertyChanged("PlatformId");
1024          OnPlatformIdChanged();
1025        }
1026      }
1027    }
1028   
1029    partial void OnSolutionRepresentationIdChanging(long value);
1030    partial void OnSolutionRepresentationIdChanged();
1031    private long _SolutionRepresentationid;
1032    [Column(Storage=@"_SolutionRepresentationid", DbType=@"BigInt NOT NULL", CanBeNull=false)]
1033    [DataMember(Order=4)]
1034    public long SolutionRepresentationId
1035    {
1036      get { return _SolutionRepresentationid; }
1037      set {
1038        if (_SolutionRepresentationid != value) {
1039          if (_SolutionRepresentation.HasLoadedOrAssignedValue) {
1040            throw new ForeignKeyReferenceAlreadyHasValueException();
1041          }
1042          OnSolutionRepresentationIdChanging(value);
1043          SendPropertyChanging();
1044          _SolutionRepresentationid = value;
1045          SendPropertyChanged("SolutionRepresentationId");
1046          OnSolutionRepresentationIdChanged();
1047        }
1048      }
1049    }
1050   
1051    partial void OnNameChanging(string value);
1052    partial void OnNameChanged();
1053    private string _Name;
1054    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
1055    [DataMember(Order=5)]
1056    public string Name
1057    {
1058      get { return _Name; }
1059      set {
1060        if (_Name != value) {
1061          OnNameChanging(value);
1062          SendPropertyChanging();
1063          _Name = value;
1064          SendPropertyChanged("Name");
1065          OnNameChanged();
1066        }
1067      }
1068    }
1069   
1070    partial void OnDescriptionChanging(string value);
1071    partial void OnDescriptionChanged();
1072    private string _Description;
1073    [Column(Storage=@"_Description", DbType=@"NVarChar(MAX)")]
1074    [DataMember(Order=6)]
1075    public string Description
1076    {
1077      get { return _Description; }
1078      set {
1079        if (_Description != value) {
1080          OnDescriptionChanging(value);
1081          SendPropertyChanging();
1082          _Description = value;
1083          SendPropertyChanged("Description");
1084          OnDescriptionChanged();
1085        }
1086      }
1087    }
1088   
1089    #endregion
1090   
1091    #region Associations
1092    private EntitySet<Experiment> _Experiments;
1093    [Association(Name=@"Problem_Experiment", Storage=@"_Experiments", ThisKey=@"Id", OtherKey=@"ProblemId")]
1094    [DataMember(Order=7, EmitDefaultValue=false)]
1095    public EntitySet<Experiment> Experiments
1096    {
1097      get {
1098        if (serializing && !_Experiments.HasLoadedOrAssignedValues) {
1099          return null;
1100        }
1101        return _Experiments;
1102      }
1103      set {
1104        _Experiments.Assign(value);
1105      }
1106    }
1107
1108    private void attach_Experiments(Experiment entity)
1109    {
1110      SendPropertyChanging();
1111      entity.Problem = this;
1112    }
1113   
1114    private void detach_Experiments(Experiment entity)
1115    {
1116      SendPropertyChanging();
1117      entity.Problem = null;
1118    }
1119    private EntitySet<ProblemParameter> _ProblemParameters;
1120    [Association(Name=@"Problem_ProblemParameter", Storage=@"_ProblemParameters", ThisKey=@"Id", OtherKey=@"ProblemId")]
1121    [DataMember(Order=8, EmitDefaultValue=false)]
1122    public EntitySet<ProblemParameter> ProblemParameters
1123    {
1124      get {
1125        if (serializing && !_ProblemParameters.HasLoadedOrAssignedValues) {
1126          return null;
1127        }
1128        return _ProblemParameters;
1129      }
1130      set {
1131        _ProblemParameters.Assign(value);
1132      }
1133    }
1134
1135    private void attach_ProblemParameters(ProblemParameter entity)
1136    {
1137      SendPropertyChanging();
1138      entity.Problem = this;
1139    }
1140   
1141    private void detach_ProblemParameters(ProblemParameter entity)
1142    {
1143      SendPropertyChanging();
1144      entity.Problem = null;
1145    }
1146    private EntityRef<ProblemData> _ProblemData;
1147    [Association(Name=@"Problem_ProblemData", Storage=@"_ProblemData", ThisKey=@"Id", OtherKey=@"ProblemId", IsUnique=true, IsForeignKey=false)]
1148    [DataMember(Order=9, EmitDefaultValue=false)]
1149    public ProblemData ProblemData
1150    {
1151      get {
1152        if (serializing && !_ProblemData.HasLoadedOrAssignedValue) {
1153          return null;
1154        }
1155        return _ProblemData.Entity;
1156      }
1157      set {
1158        ProblemData previousValue = _ProblemData.Entity;
1159        if ((previousValue != value) || (!_ProblemData.HasLoadedOrAssignedValue)) {
1160          SendPropertyChanging();
1161          if (previousValue != null) {
1162            _ProblemData.Entity = null;
1163            previousValue.Problem = null;
1164          }
1165          _ProblemData.Entity = value;
1166          if (value != null) {
1167            value.Problem = this;
1168          }
1169          SendPropertyChanged("ProblemData");
1170        }
1171      }
1172    }
1173
1174    private EntitySet<ProblemUser> _ProblemUsers;
1175    [Association(Name=@"Problem_ProblemUser", Storage=@"_ProblemUsers", ThisKey=@"Id", OtherKey=@"ProblemId")]
1176    [DataMember(Order=10, EmitDefaultValue=false)]
1177    public EntitySet<ProblemUser> ProblemUsers
1178    {
1179      get {
1180        if (serializing && !_ProblemUsers.HasLoadedOrAssignedValues) {
1181          return null;
1182        }
1183        return _ProblemUsers;
1184      }
1185      set {
1186        _ProblemUsers.Assign(value);
1187      }
1188    }
1189
1190    private void attach_ProblemUsers(ProblemUser entity)
1191    {
1192      SendPropertyChanging();
1193      entity.Problem = this;
1194    }
1195   
1196    private void detach_ProblemUsers(ProblemUser entity)
1197    {
1198      SendPropertyChanging();
1199      entity.Problem = null;
1200    }
1201    private EntitySet<ProblemCharacteristicFloatValue> _ProblemCharacteristicFloatValues;
1202    [Association(Name=@"Problem_ProblemCharacteristicFloatValue", Storage=@"_ProblemCharacteristicFloatValues", ThisKey=@"Id", OtherKey=@"ProblemId")]
1203    [DataMember(Order=11, EmitDefaultValue=false)]
1204    public EntitySet<ProblemCharacteristicFloatValue> ProblemCharacteristicFloatValues
1205    {
1206      get {
1207        if (serializing && !_ProblemCharacteristicFloatValues.HasLoadedOrAssignedValues) {
1208          return null;
1209        }
1210        return _ProblemCharacteristicFloatValues;
1211      }
1212      set {
1213        _ProblemCharacteristicFloatValues.Assign(value);
1214      }
1215    }
1216
1217    private void attach_ProblemCharacteristicFloatValues(ProblemCharacteristicFloatValue entity)
1218    {
1219      SendPropertyChanging();
1220      entity.Problem = this;
1221    }
1222   
1223    private void detach_ProblemCharacteristicFloatValues(ProblemCharacteristicFloatValue entity)
1224    {
1225      SendPropertyChanging();
1226      entity.Problem = null;
1227    }
1228    private EntitySet<ProblemCharacteristicIntValue> _ProblemCharacteristicIntValues;
1229    [Association(Name=@"Problem_ProblemCharacteristicIntValue", Storage=@"_ProblemCharacteristicIntValues", ThisKey=@"Id", OtherKey=@"ProblemId")]
1230    [DataMember(Order=12, EmitDefaultValue=false)]
1231    public EntitySet<ProblemCharacteristicIntValue> ProblemCharacteristicIntValues
1232    {
1233      get {
1234        if (serializing && !_ProblemCharacteristicIntValues.HasLoadedOrAssignedValues) {
1235          return null;
1236        }
1237        return _ProblemCharacteristicIntValues;
1238      }
1239      set {
1240        _ProblemCharacteristicIntValues.Assign(value);
1241      }
1242    }
1243
1244    private void attach_ProblemCharacteristicIntValues(ProblemCharacteristicIntValue entity)
1245    {
1246      SendPropertyChanging();
1247      entity.Problem = this;
1248    }
1249   
1250    private void detach_ProblemCharacteristicIntValues(ProblemCharacteristicIntValue entity)
1251    {
1252      SendPropertyChanging();
1253      entity.Problem = null;
1254    }
1255    private EntitySet<ProblemCharacteristicStringValue> _ProblemCharacteristicStringValues;
1256    [Association(Name=@"Problem_ProblemCharacteristicStringValue", Storage=@"_ProblemCharacteristicStringValues", ThisKey=@"Id", OtherKey=@"ProblemId")]
1257    [DataMember(Order=13, EmitDefaultValue=false)]
1258    public EntitySet<ProblemCharacteristicStringValue> ProblemCharacteristicStringValues
1259    {
1260      get {
1261        if (serializing && !_ProblemCharacteristicStringValues.HasLoadedOrAssignedValues) {
1262          return null;
1263        }
1264        return _ProblemCharacteristicStringValues;
1265      }
1266      set {
1267        _ProblemCharacteristicStringValues.Assign(value);
1268      }
1269    }
1270
1271    private void attach_ProblemCharacteristicStringValues(ProblemCharacteristicStringValue entity)
1272    {
1273      SendPropertyChanging();
1274      entity.Problem = this;
1275    }
1276   
1277    private void detach_ProblemCharacteristicStringValues(ProblemCharacteristicStringValue entity)
1278    {
1279      SendPropertyChanging();
1280      entity.Problem = null;
1281    }
1282    private EntityRef<ProblemClass> _ProblemClass;
1283    [Association(Name=@"ProblemClass_Problem", Storage=@"_ProblemClass", ThisKey=@"ProblemClassId", OtherKey=@"Id", IsForeignKey=true)]
1284    [DataMember(Order=14, EmitDefaultValue=false)]
1285    public ProblemClass ProblemClass
1286    {
1287      get {
1288        if (serializing && !_ProblemClass.HasLoadedOrAssignedValue) {
1289          return null;
1290        }
1291        return _ProblemClass.Entity;
1292      }
1293      set {
1294        ProblemClass previousValue = _ProblemClass.Entity;
1295        if ((previousValue != value) || (!_ProblemClass.HasLoadedOrAssignedValue)) {
1296          SendPropertyChanging();
1297          if (previousValue != null) {
1298            _ProblemClass.Entity = null;
1299            previousValue.Problems.Remove(this);
1300          }
1301          _ProblemClass.Entity = value;
1302          if (value != null) {
1303            value.Problems.Add(this);
1304            _ProblemClassId = value.Id;
1305          }
1306          else {
1307            _ProblemClassId = default(long);
1308          }
1309          SendPropertyChanged("ProblemClass");
1310        }
1311      }
1312    }
1313
1314    private EntityRef<Platform> _Platform;
1315    [Association(Name=@"Platform_Problem", Storage=@"_Platform", ThisKey=@"PlatformId", OtherKey=@"Id", IsForeignKey=true)]
1316    [DataMember(Order=15, EmitDefaultValue=false)]
1317    public Platform Platform
1318    {
1319      get {
1320        if (serializing && !_Platform.HasLoadedOrAssignedValue) {
1321          return null;
1322        }
1323        return _Platform.Entity;
1324      }
1325      set {
1326        Platform previousValue = _Platform.Entity;
1327        if ((previousValue != value) || (!_Platform.HasLoadedOrAssignedValue)) {
1328          SendPropertyChanging();
1329          if (previousValue != null) {
1330            _Platform.Entity = null;
1331            previousValue.Problems.Remove(this);
1332          }
1333          _Platform.Entity = value;
1334          if (value != null) {
1335            value.Problems.Add(this);
1336            _PlatformId = value.Id;
1337          }
1338          else {
1339            _PlatformId = default(long);
1340          }
1341          SendPropertyChanged("Platform");
1342        }
1343      }
1344    }
1345
1346    private EntityRef<SolutionRepresentation> _SolutionRepresentation;
1347    [Association(Name=@"SolutionRepresentation_Problem", Storage=@"_SolutionRepresentation", ThisKey=@"SolutionRepresentationId", OtherKey=@"Id", IsForeignKey=true)]
1348    [DataMember(Order=16, EmitDefaultValue=false)]
1349    public SolutionRepresentation SolutionRepresentation
1350    {
1351      get {
1352        if (serializing && !_SolutionRepresentation.HasLoadedOrAssignedValue) {
1353          return null;
1354        }
1355        return _SolutionRepresentation.Entity;
1356      }
1357      set {
1358        SolutionRepresentation previousValue = _SolutionRepresentation.Entity;
1359        if ((previousValue != value) || (!_SolutionRepresentation.HasLoadedOrAssignedValue)) {
1360          SendPropertyChanging();
1361          if (previousValue != null) {
1362            _SolutionRepresentation.Entity = null;
1363            previousValue.Problems.Remove(this);
1364          }
1365          _SolutionRepresentation.Entity = value;
1366          if (value != null) {
1367            value.Problems.Add(this);
1368            _SolutionRepresentationid = value.Id;
1369          }
1370          else {
1371            _SolutionRepresentationid = default(long);
1372          }
1373          SendPropertyChanged("SolutionRepresentation");
1374        }
1375      }
1376    }
1377
1378    #endregion
1379   
1380    #region Serialization
1381    private bool serializing;
1382   
1383    [OnSerializing()]
1384    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
1385    public void OnSerializing(StreamingContext context)
1386    {
1387      serializing = true;
1388    }
1389   
1390    [OnSerialized()]
1391    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
1392    public void OnSerialized(StreamingContext context)
1393    {
1394      serializing = false;
1395    }
1396   
1397    [OnDeserializing()]
1398    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
1399    public  void OnDeserializing(StreamingContext context)
1400    {
1401      Initialize();
1402    }
1403    #endregion
1404  }
1405}
1406
1407namespace HeuristicLab.Services.OKB.DataAccess
1408{
1409  [DataContract(IsReference=true)]
1410  [Table(Name=@"dbo.ProblemClass")]
1411[KnownType(typeof(ProblemClass))] public partial class ProblemClass : INotifyPropertyChanging, INotifyPropertyChanged
1412  {
1413    #region Property Change Event Handling
1414    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1415   
1416    public event PropertyChangingEventHandler PropertyChanging;
1417    public event PropertyChangedEventHandler PropertyChanged;
1418   
1419    public virtual void SendPropertyChanging()
1420    {
1421      if (PropertyChanging != null) {
1422        PropertyChanging(this, emptyChangingEventArgs);
1423      }
1424    }
1425     
1426    public virtual void SendPropertyChanged(String propertyName)
1427    {
1428      if (PropertyChanged != null) {
1429        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1430      }
1431    }
1432    #endregion
1433   
1434    #region Extensibility Method Definitions
1435    partial void OnLoaded();
1436    partial void OnValidate(ChangeAction action);
1437    partial void OnCreated();
1438    #endregion
1439
1440    #region Construction
1441    public ProblemClass()
1442    {
1443      Initialize();
1444    }
1445   
1446    private void Initialize()
1447    {
1448      _Problems = new EntitySet<Problem>(attach_Problems, detach_Problems);
1449      OnCreated();
1450    }
1451    #endregion
1452
1453    #region Column Mappings
1454    partial void OnIdChanging(long value);
1455    partial void OnIdChanged();
1456    private long _Id;
1457    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
1458    [DataMember(Order=1)]
1459    public long Id
1460    {
1461      get { return _Id; }
1462      set {
1463        if (_Id != value) {
1464          OnIdChanging(value);
1465          SendPropertyChanging();
1466          _Id = value;
1467          SendPropertyChanged("Id");
1468          OnIdChanged();
1469        }
1470      }
1471    }
1472   
1473    partial void OnNameChanging(string value);
1474    partial void OnNameChanged();
1475    private string _Name;
1476    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
1477    [DataMember(Order=2)]
1478    public string Name
1479    {
1480      get { return _Name; }
1481      set {
1482        if (_Name != value) {
1483          OnNameChanging(value);
1484          SendPropertyChanging();
1485          _Name = value;
1486          SendPropertyChanged("Name");
1487          OnNameChanged();
1488        }
1489      }
1490    }
1491   
1492    partial void OnDescriptionChanging(string value);
1493    partial void OnDescriptionChanged();
1494    private string _Description;
1495    [Column(Storage=@"_Description", DbType=@"NVarChar(MAX)")]
1496    [DataMember(Order=3)]
1497    public string Description
1498    {
1499      get { return _Description; }
1500      set {
1501        if (_Description != value) {
1502          OnDescriptionChanging(value);
1503          SendPropertyChanging();
1504          _Description = value;
1505          SendPropertyChanged("Description");
1506          OnDescriptionChanged();
1507        }
1508      }
1509    }
1510   
1511    #endregion
1512   
1513    #region Associations
1514    private EntitySet<Problem> _Problems;
1515    [Association(Name=@"ProblemClass_Problem", Storage=@"_Problems", ThisKey=@"Id", OtherKey=@"ProblemClassId")]
1516    [DataMember(Order=4, EmitDefaultValue=false)]
1517    public EntitySet<Problem> Problems
1518    {
1519      get {
1520        if (serializing && !_Problems.HasLoadedOrAssignedValues) {
1521          return null;
1522        }
1523        return _Problems;
1524      }
1525      set {
1526        _Problems.Assign(value);
1527      }
1528    }
1529
1530    private void attach_Problems(Problem entity)
1531    {
1532      SendPropertyChanging();
1533      entity.ProblemClass = this;
1534    }
1535   
1536    private void detach_Problems(Problem entity)
1537    {
1538      SendPropertyChanging();
1539      entity.ProblemClass = null;
1540    }
1541    #endregion
1542   
1543    #region Serialization
1544    private bool serializing;
1545   
1546    [OnSerializing()]
1547    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
1548    public void OnSerializing(StreamingContext context)
1549    {
1550      serializing = true;
1551    }
1552   
1553    [OnSerialized()]
1554    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
1555    public void OnSerialized(StreamingContext context)
1556    {
1557      serializing = false;
1558    }
1559   
1560    [OnDeserializing()]
1561    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
1562    public  void OnDeserializing(StreamingContext context)
1563    {
1564      Initialize();
1565    }
1566    #endregion
1567  }
1568}
1569
1570namespace HeuristicLab.Services.OKB.DataAccess
1571{
1572  [DataContract(IsReference=true)]
1573  [Table(Name=@"dbo.Experiment")]
1574[KnownType(typeof(Experiment))] public partial class Experiment : INotifyPropertyChanging, INotifyPropertyChanged
1575  {
1576    #region Property Change Event Handling
1577    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1578   
1579    public event PropertyChangingEventHandler PropertyChanging;
1580    public event PropertyChangedEventHandler PropertyChanged;
1581   
1582    public virtual void SendPropertyChanging()
1583    {
1584      if (PropertyChanging != null) {
1585        PropertyChanging(this, emptyChangingEventArgs);
1586      }
1587    }
1588     
1589    public virtual void SendPropertyChanged(String propertyName)
1590    {
1591      if (PropertyChanged != null) {
1592        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1593      }
1594    }
1595    #endregion
1596   
1597    #region Extensibility Method Definitions
1598    partial void OnLoaded();
1599    partial void OnValidate(ChangeAction action);
1600    partial void OnCreated();
1601    #endregion
1602
1603    #region Construction
1604    public Experiment()
1605    {
1606      Initialize();
1607    }
1608   
1609    private void Initialize()
1610    {
1611      _AlgorithmParameterBlobValues = new EntitySet<AlgorithmParameterBlobValue>(attach_AlgorithmParameterBlobValues, detach_AlgorithmParameterBlobValues);
1612      _ProblemParameterBlobValues = new EntitySet<ProblemParameterBlobValue>(attach_ProblemParameterBlobValues, detach_ProblemParameterBlobValues);
1613      _AlgorithmParameterBoolValues = new EntitySet<AlgorithmParameterBoolValue>(attach_AlgorithmParameterBoolValues, detach_AlgorithmParameterBoolValues);
1614      _AlgorithmParameterFloatValues = new EntitySet<AlgorithmParameterFloatValue>(attach_AlgorithmParameterFloatValues, detach_AlgorithmParameterFloatValues);
1615      _AlgorithmParameterIntValues = new EntitySet<AlgorithmParameterIntValue>(attach_AlgorithmParameterIntValues, detach_AlgorithmParameterIntValues);
1616      _AlgorithmParameterStringValues = new EntitySet<AlgorithmParameterStringValue>(attach_AlgorithmParameterStringValues, detach_AlgorithmParameterStringValues);
1617      _ProblemParameterBoolValues = new EntitySet<ProblemParameterBoolValue>(attach_ProblemParameterBoolValues, detach_ProblemParameterBoolValues);
1618      _ProblemParameterFloatValues = new EntitySet<ProblemParameterFloatValue>(attach_ProblemParameterFloatValues, detach_ProblemParameterFloatValues);
1619      _ProblemParameterIntValues = new EntitySet<ProblemParameterIntValue>(attach_ProblemParameterIntValues, detach_ProblemParameterIntValues);
1620      _ProblemParameterStringValues = new EntitySet<ProblemParameterStringValue>(attach_ProblemParameterStringValues, detach_ProblemParameterStringValues);
1621      _Runs = new EntitySet<Run>(attach_Runs, detach_Runs);
1622      _Problem = default(EntityRef<Problem>);
1623      _Algorithm = default(EntityRef<Algorithm>);
1624      OnCreated();
1625    }
1626    #endregion
1627
1628    #region Column Mappings
1629    partial void OnIdChanging(long value);
1630    partial void OnIdChanged();
1631    private long _Id;
1632    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
1633    [DataMember(Order=1)]
1634    public long Id
1635    {
1636      get { return _Id; }
1637      set {
1638        if (_Id != value) {
1639          OnIdChanging(value);
1640          SendPropertyChanging();
1641          _Id = value;
1642          SendPropertyChanged("Id");
1643          OnIdChanged();
1644        }
1645      }
1646    }
1647   
1648    partial void OnAlgorithmIdChanging(long value);
1649    partial void OnAlgorithmIdChanged();
1650    private long _AlgorithmId;
1651    [Column(Storage=@"_AlgorithmId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
1652    [DataMember(Order=2)]
1653    public long AlgorithmId
1654    {
1655      get { return _AlgorithmId; }
1656      set {
1657        if (_AlgorithmId != value) {
1658          if (_Algorithm.HasLoadedOrAssignedValue) {
1659            throw new ForeignKeyReferenceAlreadyHasValueException();
1660          }
1661          OnAlgorithmIdChanging(value);
1662          SendPropertyChanging();
1663          _AlgorithmId = value;
1664          SendPropertyChanged("AlgorithmId");
1665          OnAlgorithmIdChanged();
1666        }
1667      }
1668    }
1669   
1670    partial void OnProblemIdChanging(long value);
1671    partial void OnProblemIdChanged();
1672    private long _ProblemId;
1673    [Column(Storage=@"_ProblemId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
1674    [DataMember(Order=3)]
1675    public long ProblemId
1676    {
1677      get { return _ProblemId; }
1678      set {
1679        if (_ProblemId != value) {
1680          if (_Problem.HasLoadedOrAssignedValue) {
1681            throw new ForeignKeyReferenceAlreadyHasValueException();
1682          }
1683          OnProblemIdChanging(value);
1684          SendPropertyChanging();
1685          _ProblemId = value;
1686          SendPropertyChanged("ProblemId");
1687          OnProblemIdChanged();
1688        }
1689      }
1690    }
1691   
1692    #endregion
1693   
1694    #region Associations
1695    private EntitySet<AlgorithmParameterBlobValue> _AlgorithmParameterBlobValues;
1696    [Association(Name=@"Experiment_AlgorithmParameterBlobValue", Storage=@"_AlgorithmParameterBlobValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
1697    [DataMember(Order=4, EmitDefaultValue=false)]
1698    public EntitySet<AlgorithmParameterBlobValue> AlgorithmParameterBlobValues
1699    {
1700      get {
1701        if (serializing && !_AlgorithmParameterBlobValues.HasLoadedOrAssignedValues) {
1702          return null;
1703        }
1704        return _AlgorithmParameterBlobValues;
1705      }
1706      set {
1707        _AlgorithmParameterBlobValues.Assign(value);
1708      }
1709    }
1710
1711    private void attach_AlgorithmParameterBlobValues(AlgorithmParameterBlobValue entity)
1712    {
1713      SendPropertyChanging();
1714      entity.Experiment = this;
1715    }
1716   
1717    private void detach_AlgorithmParameterBlobValues(AlgorithmParameterBlobValue entity)
1718    {
1719      SendPropertyChanging();
1720      entity.Experiment = null;
1721    }
1722    private EntitySet<ProblemParameterBlobValue> _ProblemParameterBlobValues;
1723    [Association(Name=@"Experiment_ProblemParameterBlobValue", Storage=@"_ProblemParameterBlobValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
1724    [DataMember(Order=5, EmitDefaultValue=false)]
1725    public EntitySet<ProblemParameterBlobValue> ProblemParameterBlobValues
1726    {
1727      get {
1728        if (serializing && !_ProblemParameterBlobValues.HasLoadedOrAssignedValues) {
1729          return null;
1730        }
1731        return _ProblemParameterBlobValues;
1732      }
1733      set {
1734        _ProblemParameterBlobValues.Assign(value);
1735      }
1736    }
1737
1738    private void attach_ProblemParameterBlobValues(ProblemParameterBlobValue entity)
1739    {
1740      SendPropertyChanging();
1741      entity.Experiment = this;
1742    }
1743   
1744    private void detach_ProblemParameterBlobValues(ProblemParameterBlobValue entity)
1745    {
1746      SendPropertyChanging();
1747      entity.Experiment = null;
1748    }
1749    private EntitySet<AlgorithmParameterBoolValue> _AlgorithmParameterBoolValues;
1750    [Association(Name=@"Experiment_AlgorithmParameterBoolValue", Storage=@"_AlgorithmParameterBoolValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
1751    [DataMember(Order=6, EmitDefaultValue=false)]
1752    public EntitySet<AlgorithmParameterBoolValue> AlgorithmParameterBoolValues
1753    {
1754      get {
1755        if (serializing && !_AlgorithmParameterBoolValues.HasLoadedOrAssignedValues) {
1756          return null;
1757        }
1758        return _AlgorithmParameterBoolValues;
1759      }
1760      set {
1761        _AlgorithmParameterBoolValues.Assign(value);
1762      }
1763    }
1764
1765    private void attach_AlgorithmParameterBoolValues(AlgorithmParameterBoolValue entity)
1766    {
1767      SendPropertyChanging();
1768      entity.Experiment = this;
1769    }
1770   
1771    private void detach_AlgorithmParameterBoolValues(AlgorithmParameterBoolValue entity)
1772    {
1773      SendPropertyChanging();
1774      entity.Experiment = null;
1775    }
1776    private EntitySet<AlgorithmParameterFloatValue> _AlgorithmParameterFloatValues;
1777    [Association(Name=@"Experiment_AlgorithmParameterFloatValue", Storage=@"_AlgorithmParameterFloatValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
1778    [DataMember(Order=7, EmitDefaultValue=false)]
1779    public EntitySet<AlgorithmParameterFloatValue> AlgorithmParameterFloatValues
1780    {
1781      get {
1782        if (serializing && !_AlgorithmParameterFloatValues.HasLoadedOrAssignedValues) {
1783          return null;
1784        }
1785        return _AlgorithmParameterFloatValues;
1786      }
1787      set {
1788        _AlgorithmParameterFloatValues.Assign(value);
1789      }
1790    }
1791
1792    private void attach_AlgorithmParameterFloatValues(AlgorithmParameterFloatValue entity)
1793    {
1794      SendPropertyChanging();
1795      entity.Experiment = this;
1796    }
1797   
1798    private void detach_AlgorithmParameterFloatValues(AlgorithmParameterFloatValue entity)
1799    {
1800      SendPropertyChanging();
1801      entity.Experiment = null;
1802    }
1803    private EntitySet<AlgorithmParameterIntValue> _AlgorithmParameterIntValues;
1804    [Association(Name=@"Experiment_AlgorithmParameterIntValue", Storage=@"_AlgorithmParameterIntValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
1805    [DataMember(Order=8, EmitDefaultValue=false)]
1806    public EntitySet<AlgorithmParameterIntValue> AlgorithmParameterIntValues
1807    {
1808      get {
1809        if (serializing && !_AlgorithmParameterIntValues.HasLoadedOrAssignedValues) {
1810          return null;
1811        }
1812        return _AlgorithmParameterIntValues;
1813      }
1814      set {
1815        _AlgorithmParameterIntValues.Assign(value);
1816      }
1817    }
1818
1819    private void attach_AlgorithmParameterIntValues(AlgorithmParameterIntValue entity)
1820    {
1821      SendPropertyChanging();
1822      entity.Experiment = this;
1823    }
1824   
1825    private void detach_AlgorithmParameterIntValues(AlgorithmParameterIntValue entity)
1826    {
1827      SendPropertyChanging();
1828      entity.Experiment = null;
1829    }
1830    private EntitySet<AlgorithmParameterStringValue> _AlgorithmParameterStringValues;
1831    [Association(Name=@"Experiment_AlgorithmParameterStringValue", Storage=@"_AlgorithmParameterStringValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
1832    [DataMember(Order=9, EmitDefaultValue=false)]
1833    public EntitySet<AlgorithmParameterStringValue> AlgorithmParameterStringValues
1834    {
1835      get {
1836        if (serializing && !_AlgorithmParameterStringValues.HasLoadedOrAssignedValues) {
1837          return null;
1838        }
1839        return _AlgorithmParameterStringValues;
1840      }
1841      set {
1842        _AlgorithmParameterStringValues.Assign(value);
1843      }
1844    }
1845
1846    private void attach_AlgorithmParameterStringValues(AlgorithmParameterStringValue entity)
1847    {
1848      SendPropertyChanging();
1849      entity.Experiment = this;
1850    }
1851   
1852    private void detach_AlgorithmParameterStringValues(AlgorithmParameterStringValue entity)
1853    {
1854      SendPropertyChanging();
1855      entity.Experiment = null;
1856    }
1857    private EntitySet<ProblemParameterBoolValue> _ProblemParameterBoolValues;
1858    [Association(Name=@"Experiment_ProblemParameterBoolValue", Storage=@"_ProblemParameterBoolValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
1859    [DataMember(Order=10, EmitDefaultValue=false)]
1860    public EntitySet<ProblemParameterBoolValue> ProblemParameterBoolValues
1861    {
1862      get {
1863        if (serializing && !_ProblemParameterBoolValues.HasLoadedOrAssignedValues) {
1864          return null;
1865        }
1866        return _ProblemParameterBoolValues;
1867      }
1868      set {
1869        _ProblemParameterBoolValues.Assign(value);
1870      }
1871    }
1872
1873    private void attach_ProblemParameterBoolValues(ProblemParameterBoolValue entity)
1874    {
1875      SendPropertyChanging();
1876      entity.Experiment = this;
1877    }
1878   
1879    private void detach_ProblemParameterBoolValues(ProblemParameterBoolValue entity)
1880    {
1881      SendPropertyChanging();
1882      entity.Experiment = null;
1883    }
1884    private EntitySet<ProblemParameterFloatValue> _ProblemParameterFloatValues;
1885    [Association(Name=@"Experiment_ProblemParameterFloatValue", Storage=@"_ProblemParameterFloatValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
1886    [DataMember(Order=11, EmitDefaultValue=false)]
1887    public EntitySet<ProblemParameterFloatValue> ProblemParameterFloatValues
1888    {
1889      get {
1890        if (serializing && !_ProblemParameterFloatValues.HasLoadedOrAssignedValues) {
1891          return null;
1892        }
1893        return _ProblemParameterFloatValues;
1894      }
1895      set {
1896        _ProblemParameterFloatValues.Assign(value);
1897      }
1898    }
1899
1900    private void attach_ProblemParameterFloatValues(ProblemParameterFloatValue entity)
1901    {
1902      SendPropertyChanging();
1903      entity.Experiment = this;
1904    }
1905   
1906    private void detach_ProblemParameterFloatValues(ProblemParameterFloatValue entity)
1907    {
1908      SendPropertyChanging();
1909      entity.Experiment = null;
1910    }
1911    private EntitySet<ProblemParameterIntValue> _ProblemParameterIntValues;
1912    [Association(Name=@"Experiment_ProblemParameterIntValue", Storage=@"_ProblemParameterIntValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
1913    [DataMember(Order=12, EmitDefaultValue=false)]
1914    public EntitySet<ProblemParameterIntValue> ProblemParameterIntValues
1915    {
1916      get {
1917        if (serializing && !_ProblemParameterIntValues.HasLoadedOrAssignedValues) {
1918          return null;
1919        }
1920        return _ProblemParameterIntValues;
1921      }
1922      set {
1923        _ProblemParameterIntValues.Assign(value);
1924      }
1925    }
1926
1927    private void attach_ProblemParameterIntValues(ProblemParameterIntValue entity)
1928    {
1929      SendPropertyChanging();
1930      entity.Experiment = this;
1931    }
1932   
1933    private void detach_ProblemParameterIntValues(ProblemParameterIntValue entity)
1934    {
1935      SendPropertyChanging();
1936      entity.Experiment = null;
1937    }
1938    private EntitySet<ProblemParameterStringValue> _ProblemParameterStringValues;
1939    [Association(Name=@"Experiment_ProblemParameterStringValue", Storage=@"_ProblemParameterStringValues", ThisKey=@"Id", OtherKey=@"ExperimentId")]
1940    [DataMember(Order=13, EmitDefaultValue=false)]
1941    public EntitySet<ProblemParameterStringValue> ProblemParameterStringValues
1942    {
1943      get {
1944        if (serializing && !_ProblemParameterStringValues.HasLoadedOrAssignedValues) {
1945          return null;
1946        }
1947        return _ProblemParameterStringValues;
1948      }
1949      set {
1950        _ProblemParameterStringValues.Assign(value);
1951      }
1952    }
1953
1954    private void attach_ProblemParameterStringValues(ProblemParameterStringValue entity)
1955    {
1956      SendPropertyChanging();
1957      entity.Experiment = this;
1958    }
1959   
1960    private void detach_ProblemParameterStringValues(ProblemParameterStringValue entity)
1961    {
1962      SendPropertyChanging();
1963      entity.Experiment = null;
1964    }
1965    private EntitySet<Run> _Runs;
1966    [Association(Name=@"Experiment_Run", Storage=@"_Runs", ThisKey=@"Id", OtherKey=@"ExperimentId")]
1967    [DataMember(Order=14, EmitDefaultValue=false)]
1968    public EntitySet<Run> Runs
1969    {
1970      get {
1971        if (serializing && !_Runs.HasLoadedOrAssignedValues) {
1972          return null;
1973        }
1974        return _Runs;
1975      }
1976      set {
1977        _Runs.Assign(value);
1978      }
1979    }
1980
1981    private void attach_Runs(Run entity)
1982    {
1983      SendPropertyChanging();
1984      entity.Experiment = this;
1985    }
1986   
1987    private void detach_Runs(Run entity)
1988    {
1989      SendPropertyChanging();
1990      entity.Experiment = null;
1991    }
1992    private EntityRef<Problem> _Problem;
1993    [Association(Name=@"Problem_Experiment", Storage=@"_Problem", ThisKey=@"ProblemId", OtherKey=@"Id", IsForeignKey=true)]
1994    [DataMember(Order=15, EmitDefaultValue=false)]
1995    public Problem Problem
1996    {
1997      get {
1998        if (serializing && !_Problem.HasLoadedOrAssignedValue) {
1999          return null;
2000        }
2001        return _Problem.Entity;
2002      }
2003      set {
2004        Problem previousValue = _Problem.Entity;
2005        if ((previousValue != value) || (!_Problem.HasLoadedOrAssignedValue)) {
2006          SendPropertyChanging();
2007          if (previousValue != null) {
2008            _Problem.Entity = null;
2009            previousValue.Experiments.Remove(this);
2010          }
2011          _Problem.Entity = value;
2012          if (value != null) {
2013            value.Experiments.Add(this);
2014            _ProblemId = value.Id;
2015          }
2016          else {
2017            _ProblemId = default(long);
2018          }
2019          SendPropertyChanged("Problem");
2020        }
2021      }
2022    }
2023
2024    private EntityRef<Algorithm> _Algorithm;
2025    [Association(Name=@"Algorithm_Experiment", Storage=@"_Algorithm", ThisKey=@"AlgorithmId", OtherKey=@"Id", IsForeignKey=true)]
2026    [DataMember(Order=16, EmitDefaultValue=false)]
2027    public Algorithm Algorithm
2028    {
2029      get {
2030        if (serializing && !_Algorithm.HasLoadedOrAssignedValue) {
2031          return null;
2032        }
2033        return _Algorithm.Entity;
2034      }
2035      set {
2036        Algorithm previousValue = _Algorithm.Entity;
2037        if ((previousValue != value) || (!_Algorithm.HasLoadedOrAssignedValue)) {
2038          SendPropertyChanging();
2039          if (previousValue != null) {
2040            _Algorithm.Entity = null;
2041            previousValue.Experiments.Remove(this);
2042          }
2043          _Algorithm.Entity = value;
2044          if (value != null) {
2045            value.Experiments.Add(this);
2046            _AlgorithmId = value.Id;
2047          }
2048          else {
2049            _AlgorithmId = default(long);
2050          }
2051          SendPropertyChanged("Algorithm");
2052        }
2053      }
2054    }
2055
2056    #endregion
2057   
2058    #region Serialization
2059    private bool serializing;
2060   
2061    [OnSerializing()]
2062    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
2063    public void OnSerializing(StreamingContext context)
2064    {
2065      serializing = true;
2066    }
2067   
2068    [OnSerialized()]
2069    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
2070    public void OnSerialized(StreamingContext context)
2071    {
2072      serializing = false;
2073    }
2074   
2075    [OnDeserializing()]
2076    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
2077    public  void OnDeserializing(StreamingContext context)
2078    {
2079      Initialize();
2080    }
2081    #endregion
2082  }
2083}
2084
2085namespace HeuristicLab.Services.OKB.DataAccess
2086{
2087  [DataContract(IsReference=true)]
2088  [Table(Name=@"dbo.AlgorithmParameter")]
2089[KnownType(typeof(AlgorithmParameter))] public partial class AlgorithmParameter : INotifyPropertyChanging, INotifyPropertyChanged
2090  {
2091    #region Property Change Event Handling
2092    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2093   
2094    public event PropertyChangingEventHandler PropertyChanging;
2095    public event PropertyChangedEventHandler PropertyChanged;
2096   
2097    public virtual void SendPropertyChanging()
2098    {
2099      if (PropertyChanging != null) {
2100        PropertyChanging(this, emptyChangingEventArgs);
2101      }
2102    }
2103     
2104    public virtual void SendPropertyChanged(String propertyName)
2105    {
2106      if (PropertyChanged != null) {
2107        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2108      }
2109    }
2110    #endregion
2111   
2112    #region Extensibility Method Definitions
2113    partial void OnLoaded();
2114    partial void OnValidate(ChangeAction action);
2115    partial void OnCreated();
2116    #endregion
2117
2118    #region Construction
2119    public AlgorithmParameter()
2120    {
2121      Initialize();
2122    }
2123   
2124    private void Initialize()
2125    {
2126      _AlgorithmParameterBlobValues = new EntitySet<AlgorithmParameterBlobValue>(attach_AlgorithmParameterBlobValues, detach_AlgorithmParameterBlobValues);
2127      _AlgorithmParameterBoolValues = new EntitySet<AlgorithmParameterBoolValue>(attach_AlgorithmParameterBoolValues, detach_AlgorithmParameterBoolValues);
2128      _AlgorithmParameterFloatValues = new EntitySet<AlgorithmParameterFloatValue>(attach_AlgorithmParameterFloatValues, detach_AlgorithmParameterFloatValues);
2129      _AlgorithmParameterIntValues = new EntitySet<AlgorithmParameterIntValue>(attach_AlgorithmParameterIntValues, detach_AlgorithmParameterIntValues);
2130      _AlgorithmParameterStringValues = new EntitySet<AlgorithmParameterStringValue>(attach_AlgorithmParameterStringValues, detach_AlgorithmParameterStringValues);
2131      _Algorithm = default(EntityRef<Algorithm>);
2132      _DataType = default(EntityRef<DataType>);
2133      OnCreated();
2134    }
2135    #endregion
2136
2137    #region Column Mappings
2138    partial void OnIdChanging(long value);
2139    partial void OnIdChanged();
2140    private long _Id;
2141    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
2142    [DataMember(Order=1)]
2143    public long Id
2144    {
2145      get { return _Id; }
2146      set {
2147        if (_Id != value) {
2148          OnIdChanging(value);
2149          SendPropertyChanging();
2150          _Id = value;
2151          SendPropertyChanged("Id");
2152          OnIdChanged();
2153        }
2154      }
2155    }
2156   
2157    partial void OnAlgorithmIdChanging(long value);
2158    partial void OnAlgorithmIdChanged();
2159    private long _AlgorithmId;
2160    [Column(Storage=@"_AlgorithmId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
2161    [DataMember(Order=2)]
2162    public long AlgorithmId
2163    {
2164      get { return _AlgorithmId; }
2165      set {
2166        if (_AlgorithmId != value) {
2167          if (_Algorithm.HasLoadedOrAssignedValue) {
2168            throw new ForeignKeyReferenceAlreadyHasValueException();
2169          }
2170          OnAlgorithmIdChanging(value);
2171          SendPropertyChanging();
2172          _AlgorithmId = value;
2173          SendPropertyChanged("AlgorithmId");
2174          OnAlgorithmIdChanged();
2175        }
2176      }
2177    }
2178   
2179    partial void OnNameChanging(string value);
2180    partial void OnNameChanged();
2181    private string _Name;
2182    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
2183    [DataMember(Order=3)]
2184    public string Name
2185    {
2186      get { return _Name; }
2187      set {
2188        if (_Name != value) {
2189          OnNameChanging(value);
2190          SendPropertyChanging();
2191          _Name = value;
2192          SendPropertyChanged("Name");
2193          OnNameChanged();
2194        }
2195      }
2196    }
2197   
2198    partial void OnAliasChanging(string value);
2199    partial void OnAliasChanged();
2200    private string _Alias;
2201    [Column(Storage=@"_Alias", DbType=@"NVarChar(200)")]
2202    [DataMember(Order=4)]
2203    public string Alias
2204    {
2205      get { return _Alias; }
2206      set {
2207        if (_Alias != value) {
2208          OnAliasChanging(value);
2209          SendPropertyChanging();
2210          _Alias = value;
2211          SendPropertyChanged("Alias");
2212          OnAliasChanged();
2213        }
2214      }
2215    }
2216   
2217    partial void OnDescriptionChanging(string value);
2218    partial void OnDescriptionChanged();
2219    private string _Description;
2220    [Column(Storage=@"_Description", DbType=@"NVarChar(MAX)")]
2221    [DataMember(Order=5)]
2222    public string Description
2223    {
2224      get { return _Description; }
2225      set {
2226        if (_Description != value) {
2227          OnDescriptionChanging(value);
2228          SendPropertyChanging();
2229          _Description = value;
2230          SendPropertyChanged("Description");
2231          OnDescriptionChanged();
2232        }
2233      }
2234    }
2235   
2236    partial void OnDataTypeIdChanging(long value);
2237    partial void OnDataTypeIdChanged();
2238    private long _DataTypeId;
2239    [Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
2240    [DataMember(Order=6)]
2241    public long DataTypeId
2242    {
2243      get { return _DataTypeId; }
2244      set {
2245        if (_DataTypeId != value) {
2246          if (_DataType.HasLoadedOrAssignedValue) {
2247            throw new ForeignKeyReferenceAlreadyHasValueException();
2248          }
2249          OnDataTypeIdChanging(value);
2250          SendPropertyChanging();
2251          _DataTypeId = value;
2252          SendPropertyChanged("DataTypeId");
2253          OnDataTypeIdChanged();
2254        }
2255      }
2256    }
2257   
2258    #endregion
2259   
2260    #region Associations
2261    private EntitySet<AlgorithmParameterBlobValue> _AlgorithmParameterBlobValues;
2262    [Association(Name=@"AlgorithmParameter_AlgorithmParameterBlobValue", Storage=@"_AlgorithmParameterBlobValues", ThisKey=@"Id", OtherKey=@"AlgorithmParameterId")]
2263    [DataMember(Order=7, EmitDefaultValue=false)]
2264    public EntitySet<AlgorithmParameterBlobValue> AlgorithmParameterBlobValues
2265    {
2266      get {
2267        if (serializing && !_AlgorithmParameterBlobValues.HasLoadedOrAssignedValues) {
2268          return null;
2269        }
2270        return _AlgorithmParameterBlobValues;
2271      }
2272      set {
2273        _AlgorithmParameterBlobValues.Assign(value);
2274      }
2275    }
2276
2277    private void attach_AlgorithmParameterBlobValues(AlgorithmParameterBlobValue entity)
2278    {
2279      SendPropertyChanging();
2280      entity.AlgorithmParameter = this;
2281    }
2282   
2283    private void detach_AlgorithmParameterBlobValues(AlgorithmParameterBlobValue entity)
2284    {
2285      SendPropertyChanging();
2286      entity.AlgorithmParameter = null;
2287    }
2288    private EntitySet<AlgorithmParameterBoolValue> _AlgorithmParameterBoolValues;
2289    [Association(Name=@"AlgorithmParameter_AlgorithmParameterBoolValue", Storage=@"_AlgorithmParameterBoolValues", ThisKey=@"Id", OtherKey=@"AlgorithmParameterId")]
2290    [DataMember(Order=8, EmitDefaultValue=false)]
2291    public EntitySet<AlgorithmParameterBoolValue> AlgorithmParameterBoolValues
2292    {
2293      get {
2294        if (serializing && !_AlgorithmParameterBoolValues.HasLoadedOrAssignedValues) {
2295          return null;
2296        }
2297        return _AlgorithmParameterBoolValues;
2298      }
2299      set {
2300        _AlgorithmParameterBoolValues.Assign(value);
2301      }
2302    }
2303
2304    private void attach_AlgorithmParameterBoolValues(AlgorithmParameterBoolValue entity)
2305    {
2306      SendPropertyChanging();
2307      entity.AlgorithmParameter = this;
2308    }
2309   
2310    private void detach_AlgorithmParameterBoolValues(AlgorithmParameterBoolValue entity)
2311    {
2312      SendPropertyChanging();
2313      entity.AlgorithmParameter = null;
2314    }
2315    private EntitySet<AlgorithmParameterFloatValue> _AlgorithmParameterFloatValues;
2316    [Association(Name=@"AlgorithmParameter_AlgorithmParameterFloatValue", Storage=@"_AlgorithmParameterFloatValues", ThisKey=@"Id", OtherKey=@"AlgorithmParameterId")]
2317    [DataMember(Order=9, EmitDefaultValue=false)]
2318    public EntitySet<AlgorithmParameterFloatValue> AlgorithmParameterFloatValues
2319    {
2320      get {
2321        if (serializing && !_AlgorithmParameterFloatValues.HasLoadedOrAssignedValues) {
2322          return null;
2323        }
2324        return _AlgorithmParameterFloatValues;
2325      }
2326      set {
2327        _AlgorithmParameterFloatValues.Assign(value);
2328      }
2329    }
2330
2331    private void attach_AlgorithmParameterFloatValues(AlgorithmParameterFloatValue entity)
2332    {
2333      SendPropertyChanging();
2334      entity.AlgorithmParameter = this;
2335    }
2336   
2337    private void detach_AlgorithmParameterFloatValues(AlgorithmParameterFloatValue entity)
2338    {
2339      SendPropertyChanging();
2340      entity.AlgorithmParameter = null;
2341    }
2342    private EntitySet<AlgorithmParameterIntValue> _AlgorithmParameterIntValues;
2343    [Association(Name=@"AlgorithmParameter_AlgorithmParameterIntValue", Storage=@"_AlgorithmParameterIntValues", ThisKey=@"Id", OtherKey=@"AlgorithmParameterId")]
2344    [DataMember(Order=10, EmitDefaultValue=false)]
2345    public EntitySet<AlgorithmParameterIntValue> AlgorithmParameterIntValues
2346    {
2347      get {
2348        if (serializing && !_AlgorithmParameterIntValues.HasLoadedOrAssignedValues) {
2349          return null;
2350        }
2351        return _AlgorithmParameterIntValues;
2352      }
2353      set {
2354        _AlgorithmParameterIntValues.Assign(value);
2355      }
2356    }
2357
2358    private void attach_AlgorithmParameterIntValues(AlgorithmParameterIntValue entity)
2359    {
2360      SendPropertyChanging();
2361      entity.AlgorithmParameter = this;
2362    }
2363   
2364    private void detach_AlgorithmParameterIntValues(AlgorithmParameterIntValue entity)
2365    {
2366      SendPropertyChanging();
2367      entity.AlgorithmParameter = null;
2368    }
2369    private EntitySet<AlgorithmParameterStringValue> _AlgorithmParameterStringValues;
2370    [Association(Name=@"AlgorithmParameter_AlgorithmParameterStringValue", Storage=@"_AlgorithmParameterStringValues", ThisKey=@"Id", OtherKey=@"AlgorithmParameterId")]
2371    [DataMember(Order=11, EmitDefaultValue=false)]
2372    public EntitySet<AlgorithmParameterStringValue> AlgorithmParameterStringValues
2373    {
2374      get {
2375        if (serializing && !_AlgorithmParameterStringValues.HasLoadedOrAssignedValues) {
2376          return null;
2377        }
2378        return _AlgorithmParameterStringValues;
2379      }
2380      set {
2381        _AlgorithmParameterStringValues.Assign(value);
2382      }
2383    }
2384
2385    private void attach_AlgorithmParameterStringValues(AlgorithmParameterStringValue entity)
2386    {
2387      SendPropertyChanging();
2388      entity.AlgorithmParameter = this;
2389    }
2390   
2391    private void detach_AlgorithmParameterStringValues(AlgorithmParameterStringValue entity)
2392    {
2393      SendPropertyChanging();
2394      entity.AlgorithmParameter = null;
2395    }
2396    private EntityRef<Algorithm> _Algorithm;
2397    [Association(Name=@"Algorithm_AlgorithmParameter", Storage=@"_Algorithm", ThisKey=@"AlgorithmId", OtherKey=@"Id", IsForeignKey=true)]
2398    [DataMember(Order=12, EmitDefaultValue=false)]
2399    public Algorithm Algorithm
2400    {
2401      get {
2402        if (serializing && !_Algorithm.HasLoadedOrAssignedValue) {
2403          return null;
2404        }
2405        return _Algorithm.Entity;
2406      }
2407      set {
2408        Algorithm previousValue = _Algorithm.Entity;
2409        if ((previousValue != value) || (!_Algorithm.HasLoadedOrAssignedValue)) {
2410          SendPropertyChanging();
2411          if (previousValue != null) {
2412            _Algorithm.Entity = null;
2413            previousValue.AlgorithmParameters.Remove(this);
2414          }
2415          _Algorithm.Entity = value;
2416          if (value != null) {
2417            value.AlgorithmParameters.Add(this);
2418            _AlgorithmId = value.Id;
2419          }
2420          else {
2421            _AlgorithmId = default(long);
2422          }
2423          SendPropertyChanged("Algorithm");
2424        }
2425      }
2426    }
2427
2428    private EntityRef<DataType> _DataType;
2429    [Association(Name=@"DataType_AlgorithmParameter", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
2430    [DataMember(Order=13, EmitDefaultValue=false)]
2431    public DataType DataType
2432    {
2433      get {
2434        if (serializing && !_DataType.HasLoadedOrAssignedValue) {
2435          return null;
2436        }
2437        return _DataType.Entity;
2438      }
2439      set {
2440        DataType previousValue = _DataType.Entity;
2441        if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
2442          SendPropertyChanging();
2443          if (previousValue != null) {
2444            _DataType.Entity = null;
2445            previousValue.AlgorithmParameters.Remove(this);
2446          }
2447          _DataType.Entity = value;
2448          if (value != null) {
2449            value.AlgorithmParameters.Add(this);
2450            _DataTypeId = value.Id;
2451          }
2452          else {
2453            _DataTypeId = default(long);
2454          }
2455          SendPropertyChanged("DataType");
2456        }
2457      }
2458    }
2459
2460    #endregion
2461   
2462    #region Serialization
2463    private bool serializing;
2464   
2465    [OnSerializing()]
2466    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
2467    public void OnSerializing(StreamingContext context)
2468    {
2469      serializing = true;
2470    }
2471   
2472    [OnSerialized()]
2473    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
2474    public void OnSerialized(StreamingContext context)
2475    {
2476      serializing = false;
2477    }
2478   
2479    [OnDeserializing()]
2480    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
2481    public  void OnDeserializing(StreamingContext context)
2482    {
2483      Initialize();
2484    }
2485    #endregion
2486  }
2487}
2488
2489namespace HeuristicLab.Services.OKB.DataAccess
2490{
2491  [DataContract(IsReference=true)]
2492  [Table(Name=@"dbo.ProblemParameter")]
2493[KnownType(typeof(ProblemParameter))] public partial class ProblemParameter : INotifyPropertyChanging, INotifyPropertyChanged
2494  {
2495    #region Property Change Event Handling
2496    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2497   
2498    public event PropertyChangingEventHandler PropertyChanging;
2499    public event PropertyChangedEventHandler PropertyChanged;
2500   
2501    public virtual void SendPropertyChanging()
2502    {
2503      if (PropertyChanging != null) {
2504        PropertyChanging(this, emptyChangingEventArgs);
2505      }
2506    }
2507     
2508    public virtual void SendPropertyChanged(String propertyName)
2509    {
2510      if (PropertyChanged != null) {
2511        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2512      }
2513    }
2514    #endregion
2515   
2516    #region Extensibility Method Definitions
2517    partial void OnLoaded();
2518    partial void OnValidate(ChangeAction action);
2519    partial void OnCreated();
2520    #endregion
2521
2522    #region Construction
2523    public ProblemParameter()
2524    {
2525      Initialize();
2526    }
2527   
2528    private void Initialize()
2529    {
2530      _ProblemParameterBlobValues = new EntitySet<ProblemParameterBlobValue>(attach_ProblemParameterBlobValues, detach_ProblemParameterBlobValues);
2531      _ProblemParameterBoolValues = new EntitySet<ProblemParameterBoolValue>(attach_ProblemParameterBoolValues, detach_ProblemParameterBoolValues);
2532      _ProblemParameterFloatValues = new EntitySet<ProblemParameterFloatValue>(attach_ProblemParameterFloatValues, detach_ProblemParameterFloatValues);
2533      _ProblemParameterIntValues = new EntitySet<ProblemParameterIntValue>(attach_ProblemParameterIntValues, detach_ProblemParameterIntValues);
2534      _ProblemParameterStringValues = new EntitySet<ProblemParameterStringValue>(attach_ProblemParameterStringValues, detach_ProblemParameterStringValues);
2535      _Problem = default(EntityRef<Problem>);
2536      _DataType = default(EntityRef<DataType>);
2537      OnCreated();
2538    }
2539    #endregion
2540
2541    #region Column Mappings
2542    partial void OnIdChanging(long value);
2543    partial void OnIdChanged();
2544    private long _Id;
2545    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
2546    [DataMember(Order=1)]
2547    public long Id
2548    {
2549      get { return _Id; }
2550      set {
2551        if (_Id != value) {
2552          OnIdChanging(value);
2553          SendPropertyChanging();
2554          _Id = value;
2555          SendPropertyChanged("Id");
2556          OnIdChanged();
2557        }
2558      }
2559    }
2560   
2561    partial void OnProblemIdChanging(long value);
2562    partial void OnProblemIdChanged();
2563    private long _ProblemId;
2564    [Column(Storage=@"_ProblemId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
2565    [DataMember(Order=2)]
2566    public long ProblemId
2567    {
2568      get { return _ProblemId; }
2569      set {
2570        if (_ProblemId != value) {
2571          if (_Problem.HasLoadedOrAssignedValue) {
2572            throw new ForeignKeyReferenceAlreadyHasValueException();
2573          }
2574          OnProblemIdChanging(value);
2575          SendPropertyChanging();
2576          _ProblemId = value;
2577          SendPropertyChanged("ProblemId");
2578          OnProblemIdChanged();
2579        }
2580      }
2581    }
2582   
2583    partial void OnNameChanging(string value);
2584    partial void OnNameChanged();
2585    private string _Name;
2586    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
2587    [DataMember(Order=3)]
2588    public string Name
2589    {
2590      get { return _Name; }
2591      set {
2592        if (_Name != value) {
2593          OnNameChanging(value);
2594          SendPropertyChanging();
2595          _Name = value;
2596          SendPropertyChanged("Name");
2597          OnNameChanged();
2598        }
2599      }
2600    }
2601   
2602    partial void OnAliasChanging(string value);
2603    partial void OnAliasChanged();
2604    private string _Alias;
2605    [Column(Storage=@"_Alias", DbType=@"NVarChar(200)")]
2606    [DataMember(Order=4)]
2607    public string Alias
2608    {
2609      get { return _Alias; }
2610      set {
2611        if (_Alias != value) {
2612          OnAliasChanging(value);
2613          SendPropertyChanging();
2614          _Alias = value;
2615          SendPropertyChanged("Alias");
2616          OnAliasChanged();
2617        }
2618      }
2619    }
2620   
2621    partial void OnDescriptionChanging(string value);
2622    partial void OnDescriptionChanged();
2623    private string _Description;
2624    [Column(Storage=@"_Description", DbType=@"NVarChar(MAX)")]
2625    [DataMember(Order=5)]
2626    public string Description
2627    {
2628      get { return _Description; }
2629      set {
2630        if (_Description != value) {
2631          OnDescriptionChanging(value);
2632          SendPropertyChanging();
2633          _Description = value;
2634          SendPropertyChanged("Description");
2635          OnDescriptionChanged();
2636        }
2637      }
2638    }
2639   
2640    partial void OnDataTypeIdChanging(long value);
2641    partial void OnDataTypeIdChanged();
2642    private long _DataTypeId;
2643    [Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
2644    [DataMember(Order=6)]
2645    public long DataTypeId
2646    {
2647      get { return _DataTypeId; }
2648      set {
2649        if (_DataTypeId != value) {
2650          if (_DataType.HasLoadedOrAssignedValue) {
2651            throw new ForeignKeyReferenceAlreadyHasValueException();
2652          }
2653          OnDataTypeIdChanging(value);
2654          SendPropertyChanging();
2655          _DataTypeId = value;
2656          SendPropertyChanged("DataTypeId");
2657          OnDataTypeIdChanged();
2658        }
2659      }
2660    }
2661   
2662    #endregion
2663   
2664    #region Associations
2665    private EntitySet<ProblemParameterBlobValue> _ProblemParameterBlobValues;
2666    [Association(Name=@"ProblemParameter_ProblemParameterBlobValue", Storage=@"_ProblemParameterBlobValues", ThisKey=@"Id", OtherKey=@"ProblemParameterId")]
2667    [DataMember(Order=7, EmitDefaultValue=false)]
2668    public EntitySet<ProblemParameterBlobValue> ProblemParameterBlobValues
2669    {
2670      get {
2671        if (serializing && !_ProblemParameterBlobValues.HasLoadedOrAssignedValues) {
2672          return null;
2673        }
2674        return _ProblemParameterBlobValues;
2675      }
2676      set {
2677        _ProblemParameterBlobValues.Assign(value);
2678      }
2679    }
2680
2681    private void attach_ProblemParameterBlobValues(ProblemParameterBlobValue entity)
2682    {
2683      SendPropertyChanging();
2684      entity.ProblemParameter = this;
2685    }
2686   
2687    private void detach_ProblemParameterBlobValues(ProblemParameterBlobValue entity)
2688    {
2689      SendPropertyChanging();
2690      entity.ProblemParameter = null;
2691    }
2692    private EntitySet<ProblemParameterBoolValue> _ProblemParameterBoolValues;
2693    [Association(Name=@"ProblemParameter_ProblemParameterBoolValue", Storage=@"_ProblemParameterBoolValues", ThisKey=@"Id", OtherKey=@"ProblemParameterId")]
2694    [DataMember(Order=8, EmitDefaultValue=false)]
2695    public EntitySet<ProblemParameterBoolValue> ProblemParameterBoolValues
2696    {
2697      get {
2698        if (serializing && !_ProblemParameterBoolValues.HasLoadedOrAssignedValues) {
2699          return null;
2700        }
2701        return _ProblemParameterBoolValues;
2702      }
2703      set {
2704        _ProblemParameterBoolValues.Assign(value);
2705      }
2706    }
2707
2708    private void attach_ProblemParameterBoolValues(ProblemParameterBoolValue entity)
2709    {
2710      SendPropertyChanging();
2711      entity.ProblemParameter = this;
2712    }
2713   
2714    private void detach_ProblemParameterBoolValues(ProblemParameterBoolValue entity)
2715    {
2716      SendPropertyChanging();
2717      entity.ProblemParameter = null;
2718    }
2719    private EntitySet<ProblemParameterFloatValue> _ProblemParameterFloatValues;
2720    [Association(Name=@"ProblemParameter_ProblemParameterFloatValue", Storage=@"_ProblemParameterFloatValues", ThisKey=@"Id", OtherKey=@"ProblemParameterId")]
2721    [DataMember(Order=9, EmitDefaultValue=false)]
2722    public EntitySet<ProblemParameterFloatValue> ProblemParameterFloatValues
2723    {
2724      get {
2725        if (serializing && !_ProblemParameterFloatValues.HasLoadedOrAssignedValues) {
2726          return null;
2727        }
2728        return _ProblemParameterFloatValues;
2729      }
2730      set {
2731        _ProblemParameterFloatValues.Assign(value);
2732      }
2733    }
2734
2735    private void attach_ProblemParameterFloatValues(ProblemParameterFloatValue entity)
2736    {
2737      SendPropertyChanging();
2738      entity.ProblemParameter = this;
2739    }
2740   
2741    private void detach_ProblemParameterFloatValues(ProblemParameterFloatValue entity)
2742    {
2743      SendPropertyChanging();
2744      entity.ProblemParameter = null;
2745    }
2746    private EntitySet<ProblemParameterIntValue> _ProblemParameterIntValues;
2747    [Association(Name=@"ProblemParameter_ProblemParameterIntValue", Storage=@"_ProblemParameterIntValues", ThisKey=@"Id", OtherKey=@"ProblemParameterId")]
2748    [DataMember(Order=10, EmitDefaultValue=false)]
2749    public EntitySet<ProblemParameterIntValue> ProblemParameterIntValues
2750    {
2751      get {
2752        if (serializing && !_ProblemParameterIntValues.HasLoadedOrAssignedValues) {
2753          return null;
2754        }
2755        return _ProblemParameterIntValues;
2756      }
2757      set {
2758        _ProblemParameterIntValues.Assign(value);
2759      }
2760    }
2761
2762    private void attach_ProblemParameterIntValues(ProblemParameterIntValue entity)
2763    {
2764      SendPropertyChanging();
2765      entity.ProblemParameter = this;
2766    }
2767   
2768    private void detach_ProblemParameterIntValues(ProblemParameterIntValue entity)
2769    {
2770      SendPropertyChanging();
2771      entity.ProblemParameter = null;
2772    }
2773    private EntitySet<ProblemParameterStringValue> _ProblemParameterStringValues;
2774    [Association(Name=@"ProblemParameter_ProblemParameterStringValue", Storage=@"_ProblemParameterStringValues", ThisKey=@"Id", OtherKey=@"ProblemParameterId")]
2775    [DataMember(Order=11, EmitDefaultValue=false)]
2776    public EntitySet<ProblemParameterStringValue> ProblemParameterStringValues
2777    {
2778      get {
2779        if (serializing && !_ProblemParameterStringValues.HasLoadedOrAssignedValues) {
2780          return null;
2781        }
2782        return _ProblemParameterStringValues;
2783      }
2784      set {
2785        _ProblemParameterStringValues.Assign(value);
2786      }
2787    }
2788
2789    private void attach_ProblemParameterStringValues(ProblemParameterStringValue entity)
2790    {
2791      SendPropertyChanging();
2792      entity.ProblemParameter = this;
2793    }
2794   
2795    private void detach_ProblemParameterStringValues(ProblemParameterStringValue entity)
2796    {
2797      SendPropertyChanging();
2798      entity.ProblemParameter = null;
2799    }
2800    private EntityRef<Problem> _Problem;
2801    [Association(Name=@"Problem_ProblemParameter", Storage=@"_Problem", ThisKey=@"ProblemId", OtherKey=@"Id", IsForeignKey=true)]
2802    [DataMember(Order=12, EmitDefaultValue=false)]
2803    public Problem Problem
2804    {
2805      get {
2806        if (serializing && !_Problem.HasLoadedOrAssignedValue) {
2807          return null;
2808        }
2809        return _Problem.Entity;
2810      }
2811      set {
2812        Problem previousValue = _Problem.Entity;
2813        if ((previousValue != value) || (!_Problem.HasLoadedOrAssignedValue)) {
2814          SendPropertyChanging();
2815          if (previousValue != null) {
2816            _Problem.Entity = null;
2817            previousValue.ProblemParameters.Remove(this);
2818          }
2819          _Problem.Entity = value;
2820          if (value != null) {
2821            value.ProblemParameters.Add(this);
2822            _ProblemId = value.Id;
2823          }
2824          else {
2825            _ProblemId = default(long);
2826          }
2827          SendPropertyChanged("Problem");
2828        }
2829      }
2830    }
2831
2832    private EntityRef<DataType> _DataType;
2833    [Association(Name=@"DataType_ProblemParameter", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
2834    [DataMember(Order=13, EmitDefaultValue=false)]
2835    public DataType DataType
2836    {
2837      get {
2838        if (serializing && !_DataType.HasLoadedOrAssignedValue) {
2839          return null;
2840        }
2841        return _DataType.Entity;
2842      }
2843      set {
2844        DataType previousValue = _DataType.Entity;
2845        if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
2846          SendPropertyChanging();
2847          if (previousValue != null) {
2848            _DataType.Entity = null;
2849            previousValue.ProblemParameters.Remove(this);
2850          }
2851          _DataType.Entity = value;
2852          if (value != null) {
2853            value.ProblemParameters.Add(this);
2854            _DataTypeId = value.Id;
2855          }
2856          else {
2857            _DataTypeId = default(long);
2858          }
2859          SendPropertyChanged("DataType");
2860        }
2861      }
2862    }
2863
2864    #endregion
2865   
2866    #region Serialization
2867    private bool serializing;
2868   
2869    [OnSerializing()]
2870    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
2871    public void OnSerializing(StreamingContext context)
2872    {
2873      serializing = true;
2874    }
2875   
2876    [OnSerialized()]
2877    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
2878    public void OnSerialized(StreamingContext context)
2879    {
2880      serializing = false;
2881    }
2882   
2883    [OnDeserializing()]
2884    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
2885    public  void OnDeserializing(StreamingContext context)
2886    {
2887      Initialize();
2888    }
2889    #endregion
2890  }
2891}
2892
2893namespace HeuristicLab.Services.OKB.DataAccess
2894{
2895  [DataContract(IsReference=true)]
2896  [Table(Name=@"dbo.AlgorithmParameterBlobValue")]
2897[KnownType(typeof(AlgorithmParameterBlobValue))]  public partial class AlgorithmParameterBlobValue : INotifyPropertyChanging, INotifyPropertyChanged
2898  {
2899    #region Property Change Event Handling
2900    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2901   
2902    public event PropertyChangingEventHandler PropertyChanging;
2903    public event PropertyChangedEventHandler PropertyChanged;
2904   
2905    public virtual void SendPropertyChanging()
2906    {
2907      if (PropertyChanging != null) {
2908        PropertyChanging(this, emptyChangingEventArgs);
2909      }
2910    }
2911     
2912    public virtual void SendPropertyChanged(String propertyName)
2913    {
2914      if (PropertyChanged != null) {
2915        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2916      }
2917    }
2918    #endregion
2919   
2920    #region Extensibility Method Definitions
2921    partial void OnLoaded();
2922    partial void OnValidate(ChangeAction action);
2923    partial void OnCreated();
2924    #endregion
2925
2926    #region Construction
2927    public AlgorithmParameterBlobValue()
2928    {
2929      Initialize();
2930    }
2931   
2932    private void Initialize()
2933    {
2934      _AlgorithmParameter = default(EntityRef<AlgorithmParameter>);
2935      _Experiment = default(EntityRef<Experiment>);
2936      OnCreated();
2937    }
2938    #endregion
2939
2940    #region Column Mappings
2941    partial void OnAlgorithmParameterIdChanging(long value);
2942    partial void OnAlgorithmParameterIdChanged();
2943    private long _AlgorithmParameterId;
2944    [Column(Storage=@"_AlgorithmParameterId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
2945    [DataMember(Order=1)]
2946    public long AlgorithmParameterId
2947    {
2948      get { return _AlgorithmParameterId; }
2949      set {
2950        if (_AlgorithmParameterId != value) {
2951          if (_AlgorithmParameter.HasLoadedOrAssignedValue) {
2952            throw new ForeignKeyReferenceAlreadyHasValueException();
2953          }
2954          OnAlgorithmParameterIdChanging(value);
2955          SendPropertyChanging();
2956          _AlgorithmParameterId = value;
2957          SendPropertyChanged("AlgorithmParameterId");
2958          OnAlgorithmParameterIdChanged();
2959        }
2960      }
2961    }
2962   
2963    partial void OnExperimentIdChanging(long value);
2964    partial void OnExperimentIdChanged();
2965    private long _ExperimentId;
2966    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
2967    [DataMember(Order=2)]
2968    public long ExperimentId
2969    {
2970      get { return _ExperimentId; }
2971      set {
2972        if (_ExperimentId != value) {
2973          if (_Experiment.HasLoadedOrAssignedValue) {
2974            throw new ForeignKeyReferenceAlreadyHasValueException();
2975          }
2976          OnExperimentIdChanging(value);
2977          SendPropertyChanging();
2978          _ExperimentId = value;
2979          SendPropertyChanged("ExperimentId");
2980          OnExperimentIdChanged();
2981        }
2982      }
2983    }
2984   
2985    partial void OnValueChanging(Binary value);
2986    partial void OnValueChanged();
2987    private Binary _Value;
2988    [Column(Storage=@"_Value", DbType=@"VarBinary(MAX) NOT NULL", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
2989    [DataMember(Order=3)]
2990    public Binary Value
2991    {
2992      get { return _Value; }
2993      set {
2994        if (_Value != value) {
2995          OnValueChanging(value);
2996          SendPropertyChanging();
2997          _Value = value;
2998          SendPropertyChanged("Value");
2999          OnValueChanged();
3000        }
3001      }
3002    }
3003   
3004    #endregion
3005   
3006    #region Associations
3007    private EntityRef<AlgorithmParameter> _AlgorithmParameter;
3008    [Association(Name=@"AlgorithmParameter_AlgorithmParameterBlobValue", Storage=@"_AlgorithmParameter", ThisKey=@"AlgorithmParameterId", OtherKey=@"Id", IsForeignKey=true)]
3009    [DataMember(Order=4, EmitDefaultValue=false)]
3010    public AlgorithmParameter AlgorithmParameter
3011    {
3012      get {
3013        return _AlgorithmParameter.Entity;
3014      }
3015      set {
3016        AlgorithmParameter previousValue = _AlgorithmParameter.Entity;
3017        if ((previousValue != value) || (!_AlgorithmParameter.HasLoadedOrAssignedValue)) {
3018          SendPropertyChanging();
3019          if (previousValue != null) {
3020            _AlgorithmParameter.Entity = null;
3021            previousValue.AlgorithmParameterBlobValues.Remove(this);
3022          }
3023          _AlgorithmParameter.Entity = value;
3024          if (value != null) {
3025            value.AlgorithmParameterBlobValues.Add(this);
3026            _AlgorithmParameterId = value.Id;
3027          }
3028          else {
3029            _AlgorithmParameterId = default(long);
3030          }
3031          SendPropertyChanged("AlgorithmParameter");
3032        }
3033      }
3034    }
3035
3036    private EntityRef<Experiment> _Experiment;
3037    [Association(Name=@"Experiment_AlgorithmParameterBlobValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
3038    [DataMember(Order=5, EmitDefaultValue=false)]
3039    public Experiment Experiment
3040    {
3041      get {
3042        return _Experiment.Entity;
3043      }
3044      set {
3045        Experiment previousValue = _Experiment.Entity;
3046        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
3047          SendPropertyChanging();
3048          if (previousValue != null) {
3049            _Experiment.Entity = null;
3050            previousValue.AlgorithmParameterBlobValues.Remove(this);
3051          }
3052          _Experiment.Entity = value;
3053          if (value != null) {
3054            value.AlgorithmParameterBlobValues.Add(this);
3055            _ExperimentId = value.Id;
3056          }
3057          else {
3058            _ExperimentId = default(long);
3059          }
3060          SendPropertyChanged("Experiment");
3061        }
3062      }
3063    }
3064
3065    #endregion
3066   
3067    #region Serialization
3068    [OnDeserializing()]
3069    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
3070    public  void OnDeserializing(StreamingContext context)
3071    {
3072      Initialize();
3073    }
3074    #endregion
3075  }
3076}
3077
3078namespace HeuristicLab.Services.OKB.DataAccess
3079{
3080  [DataContract(IsReference=true)]
3081  [Table(Name=@"dbo.ProblemParameterBlobValue")]
3082[KnownType(typeof(ProblemParameterBlobValue))]  public partial class ProblemParameterBlobValue : INotifyPropertyChanging, INotifyPropertyChanged
3083  {
3084    #region Property Change Event Handling
3085    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3086   
3087    public event PropertyChangingEventHandler PropertyChanging;
3088    public event PropertyChangedEventHandler PropertyChanged;
3089   
3090    public virtual void SendPropertyChanging()
3091    {
3092      if (PropertyChanging != null) {
3093        PropertyChanging(this, emptyChangingEventArgs);
3094      }
3095    }
3096     
3097    public virtual void SendPropertyChanged(String propertyName)
3098    {
3099      if (PropertyChanged != null) {
3100        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3101      }
3102    }
3103    #endregion
3104   
3105    #region Extensibility Method Definitions
3106    partial void OnLoaded();
3107    partial void OnValidate(ChangeAction action);
3108    partial void OnCreated();
3109    #endregion
3110
3111    #region Construction
3112    public ProblemParameterBlobValue()
3113    {
3114      Initialize();
3115    }
3116   
3117    private void Initialize()
3118    {
3119      _Experiment = default(EntityRef<Experiment>);
3120      _ProblemParameter = default(EntityRef<ProblemParameter>);
3121      OnCreated();
3122    }
3123    #endregion
3124
3125    #region Column Mappings
3126    partial void OnProblemParameterIdChanging(long value);
3127    partial void OnProblemParameterIdChanged();
3128    private long _ProblemParameterId;
3129    [Column(Storage=@"_ProblemParameterId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
3130    [DataMember(Order=1)]
3131    public long ProblemParameterId
3132    {
3133      get { return _ProblemParameterId; }
3134      set {
3135        if (_ProblemParameterId != value) {
3136          if (_ProblemParameter.HasLoadedOrAssignedValue) {
3137            throw new ForeignKeyReferenceAlreadyHasValueException();
3138          }
3139          OnProblemParameterIdChanging(value);
3140          SendPropertyChanging();
3141          _ProblemParameterId = value;
3142          SendPropertyChanged("ProblemParameterId");
3143          OnProblemParameterIdChanged();
3144        }
3145      }
3146    }
3147   
3148    partial void OnExperimentIdChanging(long value);
3149    partial void OnExperimentIdChanged();
3150    private long _ExperimentId;
3151    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
3152    [DataMember(Order=2)]
3153    public long ExperimentId
3154    {
3155      get { return _ExperimentId; }
3156      set {
3157        if (_ExperimentId != value) {
3158          if (_Experiment.HasLoadedOrAssignedValue) {
3159            throw new ForeignKeyReferenceAlreadyHasValueException();
3160          }
3161          OnExperimentIdChanging(value);
3162          SendPropertyChanging();
3163          _ExperimentId = value;
3164          SendPropertyChanged("ExperimentId");
3165          OnExperimentIdChanged();
3166        }
3167      }
3168    }
3169   
3170    partial void OnValueChanging(Binary value);
3171    partial void OnValueChanged();
3172    private Binary _Value;
3173    [Column(Storage=@"_Value", DbType=@"VarBinary(MAX) NOT NULL", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
3174    [DataMember(Order=3)]
3175    public Binary Value
3176    {
3177      get { return _Value; }
3178      set {
3179        if (_Value != value) {
3180          OnValueChanging(value);
3181          SendPropertyChanging();
3182          _Value = value;
3183          SendPropertyChanged("Value");
3184          OnValueChanged();
3185        }
3186      }
3187    }
3188   
3189    #endregion
3190   
3191    #region Associations
3192    private EntityRef<Experiment> _Experiment;
3193    [Association(Name=@"Experiment_ProblemParameterBlobValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
3194    [DataMember(Order=4, EmitDefaultValue=false)]
3195    public Experiment Experiment
3196    {
3197      get {
3198        return _Experiment.Entity;
3199      }
3200      set {
3201        Experiment previousValue = _Experiment.Entity;
3202        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
3203          SendPropertyChanging();
3204          if (previousValue != null) {
3205            _Experiment.Entity = null;
3206            previousValue.ProblemParameterBlobValues.Remove(this);
3207          }
3208          _Experiment.Entity = value;
3209          if (value != null) {
3210            value.ProblemParameterBlobValues.Add(this);
3211            _ExperimentId = value.Id;
3212          }
3213          else {
3214            _ExperimentId = default(long);
3215          }
3216          SendPropertyChanged("Experiment");
3217        }
3218      }
3219    }
3220
3221    private EntityRef<ProblemParameter> _ProblemParameter;
3222    [Association(Name=@"ProblemParameter_ProblemParameterBlobValue", Storage=@"_ProblemParameter", ThisKey=@"ProblemParameterId", OtherKey=@"Id", IsForeignKey=true)]
3223    [DataMember(Order=5, EmitDefaultValue=false)]
3224    public ProblemParameter ProblemParameter
3225    {
3226      get {
3227        return _ProblemParameter.Entity;
3228      }
3229      set {
3230        ProblemParameter previousValue = _ProblemParameter.Entity;
3231        if ((previousValue != value) || (!_ProblemParameter.HasLoadedOrAssignedValue)) {
3232          SendPropertyChanging();
3233          if (previousValue != null) {
3234            _ProblemParameter.Entity = null;
3235            previousValue.ProblemParameterBlobValues.Remove(this);
3236          }
3237          _ProblemParameter.Entity = value;
3238          if (value != null) {
3239            value.ProblemParameterBlobValues.Add(this);
3240            _ProblemParameterId = value.Id;
3241          }
3242          else {
3243            _ProblemParameterId = default(long);
3244          }
3245          SendPropertyChanged("ProblemParameter");
3246        }
3247      }
3248    }
3249
3250    #endregion
3251   
3252    #region Serialization
3253    [OnDeserializing()]
3254    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
3255    public  void OnDeserializing(StreamingContext context)
3256    {
3257      Initialize();
3258    }
3259    #endregion
3260  }
3261}
3262
3263namespace HeuristicLab.Services.OKB.DataAccess
3264{
3265  [DataContract(IsReference=true)]
3266  [Table(Name=@"dbo.AlgorithmParameterBoolValue")]
3267[KnownType(typeof(AlgorithmParameterBoolValue))]  public partial class AlgorithmParameterBoolValue : INotifyPropertyChanging, INotifyPropertyChanged
3268  {
3269    #region Property Change Event Handling
3270    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3271   
3272    public event PropertyChangingEventHandler PropertyChanging;
3273    public event PropertyChangedEventHandler PropertyChanged;
3274   
3275    public virtual void SendPropertyChanging()
3276    {
3277      if (PropertyChanging != null) {
3278        PropertyChanging(this, emptyChangingEventArgs);
3279      }
3280    }
3281     
3282    public virtual void SendPropertyChanged(String propertyName)
3283    {
3284      if (PropertyChanged != null) {
3285        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3286      }
3287    }
3288    #endregion
3289   
3290    #region Extensibility Method Definitions
3291    partial void OnLoaded();
3292    partial void OnValidate(ChangeAction action);
3293    partial void OnCreated();
3294    #endregion
3295
3296    #region Construction
3297    public AlgorithmParameterBoolValue()
3298    {
3299      Initialize();
3300    }
3301   
3302    private void Initialize()
3303    {
3304      _AlgorithmParameter = default(EntityRef<AlgorithmParameter>);
3305      _Experiment = default(EntityRef<Experiment>);
3306      OnCreated();
3307    }
3308    #endregion
3309
3310    #region Column Mappings
3311    partial void OnAlgorithmParameterIdChanging(long value);
3312    partial void OnAlgorithmParameterIdChanged();
3313    private long _AlgorithmParameterId;
3314    [Column(Storage=@"_AlgorithmParameterId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
3315    [DataMember(Order=1)]
3316    public long AlgorithmParameterId
3317    {
3318      get { return _AlgorithmParameterId; }
3319      set {
3320        if (_AlgorithmParameterId != value) {
3321          if (_AlgorithmParameter.HasLoadedOrAssignedValue) {
3322            throw new ForeignKeyReferenceAlreadyHasValueException();
3323          }
3324          OnAlgorithmParameterIdChanging(value);
3325          SendPropertyChanging();
3326          _AlgorithmParameterId = value;
3327          SendPropertyChanged("AlgorithmParameterId");
3328          OnAlgorithmParameterIdChanged();
3329        }
3330      }
3331    }
3332   
3333    partial void OnExperimentIdChanging(long value);
3334    partial void OnExperimentIdChanged();
3335    private long _ExperimentId;
3336    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
3337    [DataMember(Order=2)]
3338    public long ExperimentId
3339    {
3340      get { return _ExperimentId; }
3341      set {
3342        if (_ExperimentId != value) {
3343          if (_Experiment.HasLoadedOrAssignedValue) {
3344            throw new ForeignKeyReferenceAlreadyHasValueException();
3345          }
3346          OnExperimentIdChanging(value);
3347          SendPropertyChanging();
3348          _ExperimentId = value;
3349          SendPropertyChanged("ExperimentId");
3350          OnExperimentIdChanged();
3351        }
3352      }
3353    }
3354   
3355    partial void OnValueChanging(bool value);
3356    partial void OnValueChanged();
3357    private bool _Value;
3358    [Column(Storage=@"_Value", DbType=@"Bit NOT NULL", CanBeNull=false)]
3359    [DataMember(Order=3)]
3360    public bool Value
3361    {
3362      get { return _Value; }
3363      set {
3364        if (_Value != value) {
3365          OnValueChanging(value);
3366          SendPropertyChanging();
3367          _Value = value;
3368          SendPropertyChanged("Value");
3369          OnValueChanged();
3370        }
3371      }
3372    }
3373   
3374    #endregion
3375   
3376    #region Associations
3377    private EntityRef<AlgorithmParameter> _AlgorithmParameter;
3378    [Association(Name=@"AlgorithmParameter_AlgorithmParameterBoolValue", Storage=@"_AlgorithmParameter", ThisKey=@"AlgorithmParameterId", OtherKey=@"Id", IsForeignKey=true)]
3379    [DataMember(Order=4, EmitDefaultValue=false)]
3380    public AlgorithmParameter AlgorithmParameter
3381    {
3382      get {
3383        return _AlgorithmParameter.Entity;
3384      }
3385      set {
3386        AlgorithmParameter previousValue = _AlgorithmParameter.Entity;
3387        if ((previousValue != value) || (!_AlgorithmParameter.HasLoadedOrAssignedValue)) {
3388          SendPropertyChanging();
3389          if (previousValue != null) {
3390            _AlgorithmParameter.Entity = null;
3391            previousValue.AlgorithmParameterBoolValues.Remove(this);
3392          }
3393          _AlgorithmParameter.Entity = value;
3394          if (value != null) {
3395            value.AlgorithmParameterBoolValues.Add(this);
3396            _AlgorithmParameterId = value.Id;
3397          }
3398          else {
3399            _AlgorithmParameterId = default(long);
3400          }
3401          SendPropertyChanged("AlgorithmParameter");
3402        }
3403      }
3404    }
3405
3406    private EntityRef<Experiment> _Experiment;
3407    [Association(Name=@"Experiment_AlgorithmParameterBoolValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
3408    [DataMember(Order=5, EmitDefaultValue=false)]
3409    public Experiment Experiment
3410    {
3411      get {
3412        return _Experiment.Entity;
3413      }
3414      set {
3415        Experiment previousValue = _Experiment.Entity;
3416        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
3417          SendPropertyChanging();
3418          if (previousValue != null) {
3419            _Experiment.Entity = null;
3420            previousValue.AlgorithmParameterBoolValues.Remove(this);
3421          }
3422          _Experiment.Entity = value;
3423          if (value != null) {
3424            value.AlgorithmParameterBoolValues.Add(this);
3425            _ExperimentId = value.Id;
3426          }
3427          else {
3428            _ExperimentId = default(long);
3429          }
3430          SendPropertyChanged("Experiment");
3431        }
3432      }
3433    }
3434
3435    #endregion
3436   
3437    #region Serialization
3438    [OnDeserializing()]
3439    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
3440    public  void OnDeserializing(StreamingContext context)
3441    {
3442      Initialize();
3443    }
3444    #endregion
3445  }
3446}
3447
3448namespace HeuristicLab.Services.OKB.DataAccess
3449{
3450  [DataContract(IsReference=true)]
3451  [Table(Name=@"dbo.AlgorithmParameterFloatValue")]
3452[KnownType(typeof(AlgorithmParameterFloatValue))] public partial class AlgorithmParameterFloatValue : INotifyPropertyChanging, INotifyPropertyChanged
3453  {
3454    #region Property Change Event Handling
3455    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3456   
3457    public event PropertyChangingEventHandler PropertyChanging;
3458    public event PropertyChangedEventHandler PropertyChanged;
3459   
3460    public virtual void SendPropertyChanging()
3461    {
3462      if (PropertyChanging != null) {
3463        PropertyChanging(this, emptyChangingEventArgs);
3464      }
3465    }
3466     
3467    public virtual void SendPropertyChanged(String propertyName)
3468    {
3469      if (PropertyChanged != null) {
3470        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3471      }
3472    }
3473    #endregion
3474   
3475    #region Extensibility Method Definitions
3476    partial void OnLoaded();
3477    partial void OnValidate(ChangeAction action);
3478    partial void OnCreated();
3479    #endregion
3480
3481    #region Construction
3482    public AlgorithmParameterFloatValue()
3483    {
3484      Initialize();
3485    }
3486   
3487    private void Initialize()
3488    {
3489      _AlgorithmParameter = default(EntityRef<AlgorithmParameter>);
3490      _Experiment = default(EntityRef<Experiment>);
3491      OnCreated();
3492    }
3493    #endregion
3494
3495    #region Column Mappings
3496    partial void OnAlgorithmParameterIdChanging(long value);
3497    partial void OnAlgorithmParameterIdChanged();
3498    private long _AlgorithmParameterId;
3499    [Column(Storage=@"_AlgorithmParameterId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
3500    [DataMember(Order=1)]
3501    public long AlgorithmParameterId
3502    {
3503      get { return _AlgorithmParameterId; }
3504      set {
3505        if (_AlgorithmParameterId != value) {
3506          if (_AlgorithmParameter.HasLoadedOrAssignedValue) {
3507            throw new ForeignKeyReferenceAlreadyHasValueException();
3508          }
3509          OnAlgorithmParameterIdChanging(value);
3510          SendPropertyChanging();
3511          _AlgorithmParameterId = value;
3512          SendPropertyChanged("AlgorithmParameterId");
3513          OnAlgorithmParameterIdChanged();
3514        }
3515      }
3516    }
3517   
3518    partial void OnExperimentIdChanging(long value);
3519    partial void OnExperimentIdChanged();
3520    private long _ExperimentId;
3521    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
3522    [DataMember(Order=2)]
3523    public long ExperimentId
3524    {
3525      get { return _ExperimentId; }
3526      set {
3527        if (_ExperimentId != value) {
3528          if (_Experiment.HasLoadedOrAssignedValue) {
3529            throw new ForeignKeyReferenceAlreadyHasValueException();
3530          }
3531          OnExperimentIdChanging(value);
3532          SendPropertyChanging();
3533          _ExperimentId = value;
3534          SendPropertyChanged("ExperimentId");
3535          OnExperimentIdChanged();
3536        }
3537      }
3538    }
3539   
3540    partial void OnValueChanging(double value);
3541    partial void OnValueChanged();
3542    private double _Value;
3543    [Column(Storage=@"_Value", DbType=@"Float NOT NULL", CanBeNull=false)]
3544    [DataMember(Order=3)]
3545    public double Value
3546    {
3547      get { return _Value; }
3548      set {
3549        if (_Value != value) {
3550          OnValueChanging(value);
3551          SendPropertyChanging();
3552          _Value = value;
3553          SendPropertyChanged("Value");
3554          OnValueChanged();
3555        }
3556      }
3557    }
3558   
3559    #endregion
3560   
3561    #region Associations
3562    private EntityRef<AlgorithmParameter> _AlgorithmParameter;
3563    [Association(Name=@"AlgorithmParameter_AlgorithmParameterFloatValue", Storage=@"_AlgorithmParameter", ThisKey=@"AlgorithmParameterId", OtherKey=@"Id", IsForeignKey=true)]
3564    [DataMember(Order=4, EmitDefaultValue=false)]
3565    public AlgorithmParameter AlgorithmParameter
3566    {
3567      get {
3568        return _AlgorithmParameter.Entity;
3569      }
3570      set {
3571        AlgorithmParameter previousValue = _AlgorithmParameter.Entity;
3572        if ((previousValue != value) || (!_AlgorithmParameter.HasLoadedOrAssignedValue)) {
3573          SendPropertyChanging();
3574          if (previousValue != null) {
3575            _AlgorithmParameter.Entity = null;
3576            previousValue.AlgorithmParameterFloatValues.Remove(this);
3577          }
3578          _AlgorithmParameter.Entity = value;
3579          if (value != null) {
3580            value.AlgorithmParameterFloatValues.Add(this);
3581            _AlgorithmParameterId = value.Id;
3582          }
3583          else {
3584            _AlgorithmParameterId = default(long);
3585          }
3586          SendPropertyChanged("AlgorithmParameter");
3587        }
3588      }
3589    }
3590
3591    private EntityRef<Experiment> _Experiment;
3592    [Association(Name=@"Experiment_AlgorithmParameterFloatValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
3593    [DataMember(Order=5, EmitDefaultValue=false)]
3594    public Experiment Experiment
3595    {
3596      get {
3597        return _Experiment.Entity;
3598      }
3599      set {
3600        Experiment previousValue = _Experiment.Entity;
3601        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
3602          SendPropertyChanging();
3603          if (previousValue != null) {
3604            _Experiment.Entity = null;
3605            previousValue.AlgorithmParameterFloatValues.Remove(this);
3606          }
3607          _Experiment.Entity = value;
3608          if (value != null) {
3609            value.AlgorithmParameterFloatValues.Add(this);
3610            _ExperimentId = value.Id;
3611          }
3612          else {
3613            _ExperimentId = default(long);
3614          }
3615          SendPropertyChanged("Experiment");
3616        }
3617      }
3618    }
3619
3620    #endregion
3621   
3622    #region Serialization
3623    [OnDeserializing()]
3624    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
3625    public  void OnDeserializing(StreamingContext context)
3626    {
3627      Initialize();
3628    }
3629    #endregion
3630  }
3631}
3632
3633namespace HeuristicLab.Services.OKB.DataAccess
3634{
3635  [DataContract(IsReference=true)]
3636  [Table(Name=@"dbo.AlgorithmParameterIntValue")]
3637[KnownType(typeof(AlgorithmParameterIntValue))] public partial class AlgorithmParameterIntValue : INotifyPropertyChanging, INotifyPropertyChanged
3638  {
3639    #region Property Change Event Handling
3640    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3641   
3642    public event PropertyChangingEventHandler PropertyChanging;
3643    public event PropertyChangedEventHandler PropertyChanged;
3644   
3645    public virtual void SendPropertyChanging()
3646    {
3647      if (PropertyChanging != null) {
3648        PropertyChanging(this, emptyChangingEventArgs);
3649      }
3650    }
3651     
3652    public virtual void SendPropertyChanged(String propertyName)
3653    {
3654      if (PropertyChanged != null) {
3655        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3656      }
3657    }
3658    #endregion
3659   
3660    #region Extensibility Method Definitions
3661    partial void OnLoaded();
3662    partial void OnValidate(ChangeAction action);
3663    partial void OnCreated();
3664    #endregion
3665
3666    #region Construction
3667    public AlgorithmParameterIntValue()
3668    {
3669      Initialize();
3670    }
3671   
3672    private void Initialize()
3673    {
3674      _AlgorithmParameter = default(EntityRef<AlgorithmParameter>);
3675      _Experiment = default(EntityRef<Experiment>);
3676      OnCreated();
3677    }
3678    #endregion
3679
3680    #region Column Mappings
3681    partial void OnAlgorithmParameterIdChanging(long value);
3682    partial void OnAlgorithmParameterIdChanged();
3683    private long _AlgorithmParameterId;
3684    [Column(Storage=@"_AlgorithmParameterId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
3685    [DataMember(Order=1)]
3686    public long AlgorithmParameterId
3687    {
3688      get { return _AlgorithmParameterId; }
3689      set {
3690        if (_AlgorithmParameterId != value) {
3691          if (_AlgorithmParameter.HasLoadedOrAssignedValue) {
3692            throw new ForeignKeyReferenceAlreadyHasValueException();
3693          }
3694          OnAlgorithmParameterIdChanging(value);
3695          SendPropertyChanging();
3696          _AlgorithmParameterId = value;
3697          SendPropertyChanged("AlgorithmParameterId");
3698          OnAlgorithmParameterIdChanged();
3699        }
3700      }
3701    }
3702   
3703    partial void OnExperimentIdChanging(long value);
3704    partial void OnExperimentIdChanged();
3705    private long _ExperimentId;
3706    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
3707    [DataMember(Order=2)]
3708    public long ExperimentId
3709    {
3710      get { return _ExperimentId; }
3711      set {
3712        if (_ExperimentId != value) {
3713          if (_Experiment.HasLoadedOrAssignedValue) {
3714            throw new ForeignKeyReferenceAlreadyHasValueException();
3715          }
3716          OnExperimentIdChanging(value);
3717          SendPropertyChanging();
3718          _ExperimentId = value;
3719          SendPropertyChanged("ExperimentId");
3720          OnExperimentIdChanged();
3721        }
3722      }
3723    }
3724   
3725    partial void OnValueChanging(int value);
3726    partial void OnValueChanged();
3727    private int _Value;
3728    [Column(Storage=@"_Value", DbType=@"Int NOT NULL", CanBeNull=false)]
3729    [DataMember(Order=3)]
3730    public int Value
3731    {
3732      get { return _Value; }
3733      set {
3734        if (_Value != value) {
3735          OnValueChanging(value);
3736          SendPropertyChanging();
3737          _Value = value;
3738          SendPropertyChanged("Value");
3739          OnValueChanged();
3740        }
3741      }
3742    }
3743   
3744    #endregion
3745   
3746    #region Associations
3747    private EntityRef<AlgorithmParameter> _AlgorithmParameter;
3748    [Association(Name=@"AlgorithmParameter_AlgorithmParameterIntValue", Storage=@"_AlgorithmParameter", ThisKey=@"AlgorithmParameterId", OtherKey=@"Id", IsForeignKey=true)]
3749    [DataMember(Order=4, EmitDefaultValue=false)]
3750    public AlgorithmParameter AlgorithmParameter
3751    {
3752      get {
3753        return _AlgorithmParameter.Entity;
3754      }
3755      set {
3756        AlgorithmParameter previousValue = _AlgorithmParameter.Entity;
3757        if ((previousValue != value) || (!_AlgorithmParameter.HasLoadedOrAssignedValue)) {
3758          SendPropertyChanging();
3759          if (previousValue != null) {
3760            _AlgorithmParameter.Entity = null;
3761            previousValue.AlgorithmParameterIntValues.Remove(this);
3762          }
3763          _AlgorithmParameter.Entity = value;
3764          if (value != null) {
3765            value.AlgorithmParameterIntValues.Add(this);
3766            _AlgorithmParameterId = value.Id;
3767          }
3768          else {
3769            _AlgorithmParameterId = default(long);
3770          }
3771          SendPropertyChanged("AlgorithmParameter");
3772        }
3773      }
3774    }
3775
3776    private EntityRef<Experiment> _Experiment;
3777    [Association(Name=@"Experiment_AlgorithmParameterIntValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
3778    [DataMember(Order=5, EmitDefaultValue=false)]
3779    public Experiment Experiment
3780    {
3781      get {
3782        return _Experiment.Entity;
3783      }
3784      set {
3785        Experiment previousValue = _Experiment.Entity;
3786        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
3787          SendPropertyChanging();
3788          if (previousValue != null) {
3789            _Experiment.Entity = null;
3790            previousValue.AlgorithmParameterIntValues.Remove(this);
3791          }
3792          _Experiment.Entity = value;
3793          if (value != null) {
3794            value.AlgorithmParameterIntValues.Add(this);
3795            _ExperimentId = value.Id;
3796          }
3797          else {
3798            _ExperimentId = default(long);
3799          }
3800          SendPropertyChanged("Experiment");
3801        }
3802      }
3803    }
3804
3805    #endregion
3806   
3807    #region Serialization
3808    [OnDeserializing()]
3809    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
3810    public  void OnDeserializing(StreamingContext context)
3811    {
3812      Initialize();
3813    }
3814    #endregion
3815  }
3816}
3817
3818namespace HeuristicLab.Services.OKB.DataAccess
3819{
3820  [DataContract(IsReference=true)]
3821  [Table(Name=@"dbo.AlgorithmParameterStringValue")]
3822[KnownType(typeof(AlgorithmParameterStringValue))]  public partial class AlgorithmParameterStringValue : INotifyPropertyChanging, INotifyPropertyChanged
3823  {
3824    #region Property Change Event Handling
3825    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3826   
3827    public event PropertyChangingEventHandler PropertyChanging;
3828    public event PropertyChangedEventHandler PropertyChanged;
3829   
3830    public virtual void SendPropertyChanging()
3831    {
3832      if (PropertyChanging != null) {
3833        PropertyChanging(this, emptyChangingEventArgs);
3834      }
3835    }
3836     
3837    public virtual void SendPropertyChanged(String propertyName)
3838    {
3839      if (PropertyChanged != null) {
3840        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3841      }
3842    }
3843    #endregion
3844   
3845    #region Extensibility Method Definitions
3846    partial void OnLoaded();
3847    partial void OnValidate(ChangeAction action);
3848    partial void OnCreated();
3849    #endregion
3850
3851    #region Construction
3852    public AlgorithmParameterStringValue()
3853    {
3854      Initialize();
3855    }
3856   
3857    private void Initialize()
3858    {
3859      _AlgorithmParameter = default(EntityRef<AlgorithmParameter>);
3860      _Experiment = default(EntityRef<Experiment>);
3861      OnCreated();
3862    }
3863    #endregion
3864
3865    #region Column Mappings
3866    partial void OnAlgorithmParameterIdChanging(long value);
3867    partial void OnAlgorithmParameterIdChanged();
3868    private long _AlgorithmParameterId;
3869    [Column(Storage=@"_AlgorithmParameterId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
3870    [DataMember(Order=1)]
3871    public long AlgorithmParameterId
3872    {
3873      get { return _AlgorithmParameterId; }
3874      set {
3875        if (_AlgorithmParameterId != value) {
3876          if (_AlgorithmParameter.HasLoadedOrAssignedValue) {
3877            throw new ForeignKeyReferenceAlreadyHasValueException();
3878          }
3879          OnAlgorithmParameterIdChanging(value);
3880          SendPropertyChanging();
3881          _AlgorithmParameterId = value;
3882          SendPropertyChanged("AlgorithmParameterId");
3883          OnAlgorithmParameterIdChanged();
3884        }
3885      }
3886    }
3887   
3888    partial void OnExperimentIdChanging(long value);
3889    partial void OnExperimentIdChanged();
3890    private long _ExperimentId;
3891    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
3892    [DataMember(Order=2)]
3893    public long ExperimentId
3894    {
3895      get { return _ExperimentId; }
3896      set {
3897        if (_ExperimentId != value) {
3898          if (_Experiment.HasLoadedOrAssignedValue) {
3899            throw new ForeignKeyReferenceAlreadyHasValueException();
3900          }
3901          OnExperimentIdChanging(value);
3902          SendPropertyChanging();
3903          _ExperimentId = value;
3904          SendPropertyChanged("ExperimentId");
3905          OnExperimentIdChanged();
3906        }
3907      }
3908    }
3909   
3910    partial void OnValueChanging(string value);
3911    partial void OnValueChanged();
3912    private string _Value;
3913    [Column(Storage=@"_Value", DbType=@"NVarChar(MAX) NOT NULL", CanBeNull=false)]
3914    [DataMember(Order=3)]
3915    public string Value
3916    {
3917      get { return _Value; }
3918      set {
3919        if (_Value != value) {
3920          OnValueChanging(value);
3921          SendPropertyChanging();
3922          _Value = value;
3923          SendPropertyChanged("Value");
3924          OnValueChanged();
3925        }
3926      }
3927    }
3928   
3929    #endregion
3930   
3931    #region Associations
3932    private EntityRef<AlgorithmParameter> _AlgorithmParameter;
3933    [Association(Name=@"AlgorithmParameter_AlgorithmParameterStringValue", Storage=@"_AlgorithmParameter", ThisKey=@"AlgorithmParameterId", OtherKey=@"Id", IsForeignKey=true)]
3934    [DataMember(Order=4, EmitDefaultValue=false)]
3935    public AlgorithmParameter AlgorithmParameter
3936    {
3937      get {
3938        return _AlgorithmParameter.Entity;
3939      }
3940      set {
3941        AlgorithmParameter previousValue = _AlgorithmParameter.Entity;
3942        if ((previousValue != value) || (!_AlgorithmParameter.HasLoadedOrAssignedValue)) {
3943          SendPropertyChanging();
3944          if (previousValue != null) {
3945            _AlgorithmParameter.Entity = null;
3946            previousValue.AlgorithmParameterStringValues.Remove(this);
3947          }
3948          _AlgorithmParameter.Entity = value;
3949          if (value != null) {
3950            value.AlgorithmParameterStringValues.Add(this);
3951            _AlgorithmParameterId = value.Id;
3952          }
3953          else {
3954            _AlgorithmParameterId = default(long);
3955          }
3956          SendPropertyChanged("AlgorithmParameter");
3957        }
3958      }
3959    }
3960
3961    private EntityRef<Experiment> _Experiment;
3962    [Association(Name=@"Experiment_AlgorithmParameterStringValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
3963    [DataMember(Order=5, EmitDefaultValue=false)]
3964    public Experiment Experiment
3965    {
3966      get {
3967        return _Experiment.Entity;
3968      }
3969      set {
3970        Experiment previousValue = _Experiment.Entity;
3971        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
3972          SendPropertyChanging();
3973          if (previousValue != null) {
3974            _Experiment.Entity = null;
3975            previousValue.AlgorithmParameterStringValues.Remove(this);
3976          }
3977          _Experiment.Entity = value;
3978          if (value != null) {
3979            value.AlgorithmParameterStringValues.Add(this);
3980            _ExperimentId = value.Id;
3981          }
3982          else {
3983            _ExperimentId = default(long);
3984          }
3985          SendPropertyChanged("Experiment");
3986        }
3987      }
3988    }
3989
3990    #endregion
3991   
3992    #region Serialization
3993    [OnDeserializing()]
3994    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
3995    public  void OnDeserializing(StreamingContext context)
3996    {
3997      Initialize();
3998    }
3999    #endregion
4000  }
4001}
4002
4003namespace HeuristicLab.Services.OKB.DataAccess
4004{
4005  [DataContract(IsReference=true)]
4006  [Table(Name=@"dbo.ProblemParameterBoolValue")]
4007[KnownType(typeof(ProblemParameterBoolValue))]  public partial class ProblemParameterBoolValue : INotifyPropertyChanging, INotifyPropertyChanged
4008  {
4009    #region Property Change Event Handling
4010    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
4011   
4012    public event PropertyChangingEventHandler PropertyChanging;
4013    public event PropertyChangedEventHandler PropertyChanged;
4014   
4015    public virtual void SendPropertyChanging()
4016    {
4017      if (PropertyChanging != null) {
4018        PropertyChanging(this, emptyChangingEventArgs);
4019      }
4020    }
4021     
4022    public virtual void SendPropertyChanged(String propertyName)
4023    {
4024      if (PropertyChanged != null) {
4025        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
4026      }
4027    }
4028    #endregion
4029   
4030    #region Extensibility Method Definitions
4031    partial void OnLoaded();
4032    partial void OnValidate(ChangeAction action);
4033    partial void OnCreated();
4034    #endregion
4035
4036    #region Construction
4037    public ProblemParameterBoolValue()
4038    {
4039      Initialize();
4040    }
4041   
4042    private void Initialize()
4043    {
4044      _Experiment = default(EntityRef<Experiment>);
4045      _ProblemParameter = default(EntityRef<ProblemParameter>);
4046      OnCreated();
4047    }
4048    #endregion
4049
4050    #region Column Mappings
4051    partial void OnProblemParameterIdChanging(long value);
4052    partial void OnProblemParameterIdChanged();
4053    private long _ProblemParameterId;
4054    [Column(Storage=@"_ProblemParameterId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
4055    [DataMember(Order=1)]
4056    public long ProblemParameterId
4057    {
4058      get { return _ProblemParameterId; }
4059      set {
4060        if (_ProblemParameterId != value) {
4061          if (_ProblemParameter.HasLoadedOrAssignedValue) {
4062            throw new ForeignKeyReferenceAlreadyHasValueException();
4063          }
4064          OnProblemParameterIdChanging(value);
4065          SendPropertyChanging();
4066          _ProblemParameterId = value;
4067          SendPropertyChanged("ProblemParameterId");
4068          OnProblemParameterIdChanged();
4069        }
4070      }
4071    }
4072   
4073    partial void OnExperimentIdChanging(long value);
4074    partial void OnExperimentIdChanged();
4075    private long _ExperimentId;
4076    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
4077    [DataMember(Order=2)]
4078    public long ExperimentId
4079    {
4080      get { return _ExperimentId; }
4081      set {
4082        if (_ExperimentId != value) {
4083          if (_Experiment.HasLoadedOrAssignedValue) {
4084            throw new ForeignKeyReferenceAlreadyHasValueException();
4085          }
4086          OnExperimentIdChanging(value);
4087          SendPropertyChanging();
4088          _ExperimentId = value;
4089          SendPropertyChanged("ExperimentId");
4090          OnExperimentIdChanged();
4091        }
4092      }
4093    }
4094   
4095    partial void OnValueChanging(bool value);
4096    partial void OnValueChanged();
4097    private bool _Value;
4098    [Column(Storage=@"_Value", DbType=@"Bit NOT NULL", CanBeNull=false)]
4099    [DataMember(Order=3)]
4100    public bool Value
4101    {
4102      get { return _Value; }
4103      set {
4104        if (_Value != value) {
4105          OnValueChanging(value);
4106          SendPropertyChanging();
4107          _Value = value;
4108          SendPropertyChanged("Value");
4109          OnValueChanged();
4110        }
4111      }
4112    }
4113   
4114    #endregion
4115   
4116    #region Associations
4117    private EntityRef<Experiment> _Experiment;
4118    [Association(Name=@"Experiment_ProblemParameterBoolValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
4119    [DataMember(Order=4, EmitDefaultValue=false)]
4120    public Experiment Experiment
4121    {
4122      get {
4123        return _Experiment.Entity;
4124      }
4125      set {
4126        Experiment previousValue = _Experiment.Entity;
4127        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
4128          SendPropertyChanging();
4129          if (previousValue != null) {
4130            _Experiment.Entity = null;
4131            previousValue.ProblemParameterBoolValues.Remove(this);
4132          }
4133          _Experiment.Entity = value;
4134          if (value != null) {
4135            value.ProblemParameterBoolValues.Add(this);
4136            _ExperimentId = value.Id;
4137          }
4138          else {
4139            _ExperimentId = default(long);
4140          }
4141          SendPropertyChanged("Experiment");
4142        }
4143      }
4144    }
4145
4146    private EntityRef<ProblemParameter> _ProblemParameter;
4147    [Association(Name=@"ProblemParameter_ProblemParameterBoolValue", Storage=@"_ProblemParameter", ThisKey=@"ProblemParameterId", OtherKey=@"Id", IsForeignKey=true)]
4148    [DataMember(Order=5, EmitDefaultValue=false)]
4149    public ProblemParameter ProblemParameter
4150    {
4151      get {
4152        return _ProblemParameter.Entity;
4153      }
4154      set {
4155        ProblemParameter previousValue = _ProblemParameter.Entity;
4156        if ((previousValue != value) || (!_ProblemParameter.HasLoadedOrAssignedValue)) {
4157          SendPropertyChanging();
4158          if (previousValue != null) {
4159            _ProblemParameter.Entity = null;
4160            previousValue.ProblemParameterBoolValues.Remove(this);
4161          }
4162          _ProblemParameter.Entity = value;
4163          if (value != null) {
4164            value.ProblemParameterBoolValues.Add(this);
4165            _ProblemParameterId = value.Id;
4166          }
4167          else {
4168            _ProblemParameterId = default(long);
4169          }
4170          SendPropertyChanged("ProblemParameter");
4171        }
4172      }
4173    }
4174
4175    #endregion
4176   
4177    #region Serialization
4178    [OnDeserializing()]
4179    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
4180    public  void OnDeserializing(StreamingContext context)
4181    {
4182      Initialize();
4183    }
4184    #endregion
4185  }
4186}
4187
4188namespace HeuristicLab.Services.OKB.DataAccess
4189{
4190  [DataContract(IsReference=true)]
4191  [Table(Name=@"dbo.ProblemParameterFloatValue")]
4192[KnownType(typeof(ProblemParameterFloatValue))] public partial class ProblemParameterFloatValue : INotifyPropertyChanging, INotifyPropertyChanged
4193  {
4194    #region Property Change Event Handling
4195    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
4196   
4197    public event PropertyChangingEventHandler PropertyChanging;
4198    public event PropertyChangedEventHandler PropertyChanged;
4199   
4200    public virtual void SendPropertyChanging()
4201    {
4202      if (PropertyChanging != null) {
4203        PropertyChanging(this, emptyChangingEventArgs);
4204      }
4205    }
4206     
4207    public virtual void SendPropertyChanged(String propertyName)
4208    {
4209      if (PropertyChanged != null) {
4210        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
4211      }
4212    }
4213    #endregion
4214   
4215    #region Extensibility Method Definitions
4216    partial void OnLoaded();
4217    partial void OnValidate(ChangeAction action);
4218    partial void OnCreated();
4219    #endregion
4220
4221    #region Construction
4222    public ProblemParameterFloatValue()
4223    {
4224      Initialize();
4225    }
4226   
4227    private void Initialize()
4228    {
4229      _Experiment = default(EntityRef<Experiment>);
4230      _ProblemParameter = default(EntityRef<ProblemParameter>);
4231      OnCreated();
4232    }
4233    #endregion
4234
4235    #region Column Mappings
4236    partial void OnProblemParameterIdChanging(long value);
4237    partial void OnProblemParameterIdChanged();
4238    private long _ProblemParameterId;
4239    [Column(Storage=@"_ProblemParameterId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
4240    [DataMember(Order=1)]
4241    public long ProblemParameterId
4242    {
4243      get { return _ProblemParameterId; }
4244      set {
4245        if (_ProblemParameterId != value) {
4246          if (_ProblemParameter.HasLoadedOrAssignedValue) {
4247            throw new ForeignKeyReferenceAlreadyHasValueException();
4248          }
4249          OnProblemParameterIdChanging(value);
4250          SendPropertyChanging();
4251          _ProblemParameterId = value;
4252          SendPropertyChanged("ProblemParameterId");
4253          OnProblemParameterIdChanged();
4254        }
4255      }
4256    }
4257   
4258    partial void OnExperimentIdChanging(long value);
4259    partial void OnExperimentIdChanged();
4260    private long _ExperimentId;
4261    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
4262    [DataMember(Order=2)]
4263    public long ExperimentId
4264    {
4265      get { return _ExperimentId; }
4266      set {
4267        if (_ExperimentId != value) {
4268          if (_Experiment.HasLoadedOrAssignedValue) {
4269            throw new ForeignKeyReferenceAlreadyHasValueException();
4270          }
4271          OnExperimentIdChanging(value);
4272          SendPropertyChanging();
4273          _ExperimentId = value;
4274          SendPropertyChanged("ExperimentId");
4275          OnExperimentIdChanged();
4276        }
4277      }
4278    }
4279   
4280    partial void OnValueChanging(double value);
4281    partial void OnValueChanged();
4282    private double _Value;
4283    [Column(Storage=@"_Value", DbType=@"Float NOT NULL", CanBeNull=false)]
4284    [DataMember(Order=3)]
4285    public double Value
4286    {
4287      get { return _Value; }
4288      set {
4289        if (_Value != value) {
4290          OnValueChanging(value);
4291          SendPropertyChanging();
4292          _Value = value;
4293          SendPropertyChanged("Value");
4294          OnValueChanged();
4295        }
4296      }
4297    }
4298   
4299    #endregion
4300   
4301    #region Associations
4302    private EntityRef<Experiment> _Experiment;
4303    [Association(Name=@"Experiment_ProblemParameterFloatValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
4304    [DataMember(Order=4, EmitDefaultValue=false)]
4305    public Experiment Experiment
4306    {
4307      get {
4308        return _Experiment.Entity;
4309      }
4310      set {
4311        Experiment previousValue = _Experiment.Entity;
4312        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
4313          SendPropertyChanging();
4314          if (previousValue != null) {
4315            _Experiment.Entity = null;
4316            previousValue.ProblemParameterFloatValues.Remove(this);
4317          }
4318          _Experiment.Entity = value;
4319          if (value != null) {
4320            value.ProblemParameterFloatValues.Add(this);
4321            _ExperimentId = value.Id;
4322          }
4323          else {
4324            _ExperimentId = default(long);
4325          }
4326          SendPropertyChanged("Experiment");
4327        }
4328      }
4329    }
4330
4331    private EntityRef<ProblemParameter> _ProblemParameter;
4332    [Association(Name=@"ProblemParameter_ProblemParameterFloatValue", Storage=@"_ProblemParameter", ThisKey=@"ProblemParameterId", OtherKey=@"Id", IsForeignKey=true)]
4333    [DataMember(Order=5, EmitDefaultValue=false)]
4334    public ProblemParameter ProblemParameter
4335    {
4336      get {
4337        return _ProblemParameter.Entity;
4338      }
4339      set {
4340        ProblemParameter previousValue = _ProblemParameter.Entity;
4341        if ((previousValue != value) || (!_ProblemParameter.HasLoadedOrAssignedValue)) {
4342          SendPropertyChanging();
4343          if (previousValue != null) {
4344            _ProblemParameter.Entity = null;
4345            previousValue.ProblemParameterFloatValues.Remove(this);
4346          }
4347          _ProblemParameter.Entity = value;
4348          if (value != null) {
4349            value.ProblemParameterFloatValues.Add(this);
4350            _ProblemParameterId = value.Id;
4351          }
4352          else {
4353            _ProblemParameterId = default(long);
4354          }
4355          SendPropertyChanged("ProblemParameter");
4356        }
4357      }
4358    }
4359
4360    #endregion
4361   
4362    #region Serialization
4363    [OnDeserializing()]
4364    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
4365    public  void OnDeserializing(StreamingContext context)
4366    {
4367      Initialize();
4368    }
4369    #endregion
4370  }
4371}
4372
4373namespace HeuristicLab.Services.OKB.DataAccess
4374{
4375  [DataContract(IsReference=true)]
4376  [Table(Name=@"dbo.ProblemParameterIntValue")]
4377[KnownType(typeof(ProblemParameterIntValue))] public partial class ProblemParameterIntValue : INotifyPropertyChanging, INotifyPropertyChanged
4378  {
4379    #region Property Change Event Handling
4380    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
4381   
4382    public event PropertyChangingEventHandler PropertyChanging;
4383    public event PropertyChangedEventHandler PropertyChanged;
4384   
4385    public virtual void SendPropertyChanging()
4386    {
4387      if (PropertyChanging != null) {
4388        PropertyChanging(this, emptyChangingEventArgs);
4389      }
4390    }
4391     
4392    public virtual void SendPropertyChanged(String propertyName)
4393    {
4394      if (PropertyChanged != null) {
4395        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
4396      }
4397    }
4398    #endregion
4399   
4400    #region Extensibility Method Definitions
4401    partial void OnLoaded();
4402    partial void OnValidate(ChangeAction action);
4403    partial void OnCreated();
4404    #endregion
4405
4406    #region Construction
4407    public ProblemParameterIntValue()
4408    {
4409      Initialize();
4410    }
4411   
4412    private void Initialize()
4413    {
4414      _Experiment = default(EntityRef<Experiment>);
4415      _ProblemParameter = default(EntityRef<ProblemParameter>);
4416      OnCreated();
4417    }
4418    #endregion
4419
4420    #region Column Mappings
4421    partial void OnProblemParameterIdChanging(long value);
4422    partial void OnProblemParameterIdChanged();
4423    private long _ProblemParameterId;
4424    [Column(Storage=@"_ProblemParameterId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
4425    [DataMember(Order=1)]
4426    public long ProblemParameterId
4427    {
4428      get { return _ProblemParameterId; }
4429      set {
4430        if (_ProblemParameterId != value) {
4431          if (_ProblemParameter.HasLoadedOrAssignedValue) {
4432            throw new ForeignKeyReferenceAlreadyHasValueException();
4433          }
4434          OnProblemParameterIdChanging(value);
4435          SendPropertyChanging();
4436          _ProblemParameterId = value;
4437          SendPropertyChanged("ProblemParameterId");
4438          OnProblemParameterIdChanged();
4439        }
4440      }
4441    }
4442   
4443    partial void OnExperimentIdChanging(long value);
4444    partial void OnExperimentIdChanged();
4445    private long _ExperimentId;
4446    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
4447    [DataMember(Order=2)]
4448    public long ExperimentId
4449    {
4450      get { return _ExperimentId; }
4451      set {
4452        if (_ExperimentId != value) {
4453          if (_Experiment.HasLoadedOrAssignedValue) {
4454            throw new ForeignKeyReferenceAlreadyHasValueException();
4455          }
4456          OnExperimentIdChanging(value);
4457          SendPropertyChanging();
4458          _ExperimentId = value;
4459          SendPropertyChanged("ExperimentId");
4460          OnExperimentIdChanged();
4461        }
4462      }
4463    }
4464   
4465    partial void OnValueChanging(int value);
4466    partial void OnValueChanged();
4467    private int _Value;
4468    [Column(Storage=@"_Value", DbType=@"Int NOT NULL", CanBeNull=false)]
4469    [DataMember(Order=3)]
4470    public int Value
4471    {
4472      get { return _Value; }
4473      set {
4474        if (_Value != value) {
4475          OnValueChanging(value);
4476          SendPropertyChanging();
4477          _Value = value;
4478          SendPropertyChanged("Value");
4479          OnValueChanged();
4480        }
4481      }
4482    }
4483   
4484    #endregion
4485   
4486    #region Associations
4487    private EntityRef<Experiment> _Experiment;
4488    [Association(Name=@"Experiment_ProblemParameterIntValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
4489    [DataMember(Order=4, EmitDefaultValue=false)]
4490    public Experiment Experiment
4491    {
4492      get {
4493        return _Experiment.Entity;
4494      }
4495      set {
4496        Experiment previousValue = _Experiment.Entity;
4497        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
4498          SendPropertyChanging();
4499          if (previousValue != null) {
4500            _Experiment.Entity = null;
4501            previousValue.ProblemParameterIntValues.Remove(this);
4502          }
4503          _Experiment.Entity = value;
4504          if (value != null) {
4505            value.ProblemParameterIntValues.Add(this);
4506            _ExperimentId = value.Id;
4507          }
4508          else {
4509            _ExperimentId = default(long);
4510          }
4511          SendPropertyChanged("Experiment");
4512        }
4513      }
4514    }
4515
4516    private EntityRef<ProblemParameter> _ProblemParameter;
4517    [Association(Name=@"ProblemParameter_ProblemParameterIntValue", Storage=@"_ProblemParameter", ThisKey=@"ProblemParameterId", OtherKey=@"Id", IsForeignKey=true)]
4518    [DataMember(Order=5, EmitDefaultValue=false)]
4519    public ProblemParameter ProblemParameter
4520    {
4521      get {
4522        return _ProblemParameter.Entity;
4523      }
4524      set {
4525        ProblemParameter previousValue = _ProblemParameter.Entity;
4526        if ((previousValue != value) || (!_ProblemParameter.HasLoadedOrAssignedValue)) {
4527          SendPropertyChanging();
4528          if (previousValue != null) {
4529            _ProblemParameter.Entity = null;
4530            previousValue.ProblemParameterIntValues.Remove(this);
4531          }
4532          _ProblemParameter.Entity = value;
4533          if (value != null) {
4534            value.ProblemParameterIntValues.Add(this);
4535            _ProblemParameterId = value.Id;
4536          }
4537          else {
4538            _ProblemParameterId = default(long);
4539          }
4540          SendPropertyChanged("ProblemParameter");
4541        }
4542      }
4543    }
4544
4545    #endregion
4546   
4547    #region Serialization
4548    [OnDeserializing()]
4549    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
4550    public  void OnDeserializing(StreamingContext context)
4551    {
4552      Initialize();
4553    }
4554    #endregion
4555  }
4556}
4557
4558namespace HeuristicLab.Services.OKB.DataAccess
4559{
4560  [DataContract(IsReference=true)]
4561  [Table(Name=@"dbo.ProblemParameterStringValue")]
4562[KnownType(typeof(ProblemParameterStringValue))]  public partial class ProblemParameterStringValue : INotifyPropertyChanging, INotifyPropertyChanged
4563  {
4564    #region Property Change Event Handling
4565    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
4566   
4567    public event PropertyChangingEventHandler PropertyChanging;
4568    public event PropertyChangedEventHandler PropertyChanged;
4569   
4570    public virtual void SendPropertyChanging()
4571    {
4572      if (PropertyChanging != null) {
4573        PropertyChanging(this, emptyChangingEventArgs);
4574      }
4575    }
4576     
4577    public virtual void SendPropertyChanged(String propertyName)
4578    {
4579      if (PropertyChanged != null) {
4580        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
4581      }
4582    }
4583    #endregion
4584   
4585    #region Extensibility Method Definitions
4586    partial void OnLoaded();
4587    partial void OnValidate(ChangeAction action);
4588    partial void OnCreated();
4589    #endregion
4590
4591    #region Construction
4592    public ProblemParameterStringValue()
4593    {
4594      Initialize();
4595    }
4596   
4597    private void Initialize()
4598    {
4599      _Experiment = default(EntityRef<Experiment>);
4600      _ProblemParameter = default(EntityRef<ProblemParameter>);
4601      OnCreated();
4602    }
4603    #endregion
4604
4605    #region Column Mappings
4606    partial void OnProblemParameterIdChanging(long value);
4607    partial void OnProblemParameterIdChanged();
4608    private long _ProblemParameterId;
4609    [Column(Storage=@"_ProblemParameterId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
4610    [DataMember(Order=1)]
4611    public long ProblemParameterId
4612    {
4613      get { return _ProblemParameterId; }
4614      set {
4615        if (_ProblemParameterId != value) {
4616          if (_ProblemParameter.HasLoadedOrAssignedValue) {
4617            throw new ForeignKeyReferenceAlreadyHasValueException();
4618          }
4619          OnProblemParameterIdChanging(value);
4620          SendPropertyChanging();
4621          _ProblemParameterId = value;
4622          SendPropertyChanged("ProblemParameterId");
4623          OnProblemParameterIdChanged();
4624        }
4625      }
4626    }
4627   
4628    partial void OnExperimentIdChanging(long value);
4629    partial void OnExperimentIdChanged();
4630    private long _ExperimentId;
4631    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
4632    [DataMember(Order=2)]
4633    public long ExperimentId
4634    {
4635      get { return _ExperimentId; }
4636      set {
4637        if (_ExperimentId != value) {
4638          if (_Experiment.HasLoadedOrAssignedValue) {
4639            throw new ForeignKeyReferenceAlreadyHasValueException();
4640          }
4641          OnExperimentIdChanging(value);
4642          SendPropertyChanging();
4643          _ExperimentId = value;
4644          SendPropertyChanged("ExperimentId");
4645          OnExperimentIdChanged();
4646        }
4647      }
4648    }
4649   
4650    partial void OnValueChanging(string value);
4651    partial void OnValueChanged();
4652    private string _Value;
4653    [Column(Storage=@"_Value", DbType=@"NVarChar(MAX) NOT NULL", CanBeNull=false)]
4654    [DataMember(Order=3)]
4655    public string Value
4656    {
4657      get { return _Value; }
4658      set {
4659        if (_Value != value) {
4660          OnValueChanging(value);
4661          SendPropertyChanging();
4662          _Value = value;
4663          SendPropertyChanged("Value");
4664          OnValueChanged();
4665        }
4666      }
4667    }
4668   
4669    #endregion
4670   
4671    #region Associations
4672    private EntityRef<Experiment> _Experiment;
4673    [Association(Name=@"Experiment_ProblemParameterStringValue", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
4674    [DataMember(Order=4, EmitDefaultValue=false)]
4675    public Experiment Experiment
4676    {
4677      get {
4678        return _Experiment.Entity;
4679      }
4680      set {
4681        Experiment previousValue = _Experiment.Entity;
4682        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
4683          SendPropertyChanging();
4684          if (previousValue != null) {
4685            _Experiment.Entity = null;
4686            previousValue.ProblemParameterStringValues.Remove(this);
4687          }
4688          _Experiment.Entity = value;
4689          if (value != null) {
4690            value.ProblemParameterStringValues.Add(this);
4691            _ExperimentId = value.Id;
4692          }
4693          else {
4694            _ExperimentId = default(long);
4695          }
4696          SendPropertyChanged("Experiment");
4697        }
4698      }
4699    }
4700
4701    private EntityRef<ProblemParameter> _ProblemParameter;
4702    [Association(Name=@"ProblemParameter_ProblemParameterStringValue", Storage=@"_ProblemParameter", ThisKey=@"ProblemParameterId", OtherKey=@"Id", IsForeignKey=true)]
4703    [DataMember(Order=5, EmitDefaultValue=false)]
4704    public ProblemParameter ProblemParameter
4705    {
4706      get {
4707        return _ProblemParameter.Entity;
4708      }
4709      set {
4710        ProblemParameter previousValue = _ProblemParameter.Entity;
4711        if ((previousValue != value) || (!_ProblemParameter.HasLoadedOrAssignedValue)) {
4712          SendPropertyChanging();
4713          if (previousValue != null) {
4714            _ProblemParameter.Entity = null;
4715            previousValue.ProblemParameterStringValues.Remove(this);
4716          }
4717          _ProblemParameter.Entity = value;
4718          if (value != null) {
4719            value.ProblemParameterStringValues.Add(this);
4720            _ProblemParameterId = value.Id;
4721          }
4722          else {
4723            _ProblemParameterId = default(long);
4724          }
4725          SendPropertyChanged("ProblemParameter");
4726        }
4727      }
4728    }
4729
4730    #endregion
4731   
4732    #region Serialization
4733    [OnDeserializing()]
4734    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
4735    public  void OnDeserializing(StreamingContext context)
4736    {
4737      Initialize();
4738    }
4739    #endregion
4740  }
4741}
4742
4743namespace HeuristicLab.Services.OKB.DataAccess
4744{
4745  [DataContract(IsReference=true)]
4746  [Table(Name=@"dbo.AlgorithmData")]
4747[KnownType(typeof(AlgorithmData))]  public partial class AlgorithmData : INotifyPropertyChanging, INotifyPropertyChanged
4748  {
4749    #region Property Change Event Handling
4750    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
4751   
4752    public event PropertyChangingEventHandler PropertyChanging;
4753    public event PropertyChangedEventHandler PropertyChanged;
4754   
4755    public virtual void SendPropertyChanging()
4756    {
4757      if (PropertyChanging != null) {
4758        PropertyChanging(this, emptyChangingEventArgs);
4759      }
4760    }
4761     
4762    public virtual void SendPropertyChanged(String propertyName)
4763    {
4764      if (PropertyChanged != null) {
4765        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
4766      }
4767    }
4768    #endregion
4769   
4770    #region Extensibility Method Definitions
4771    partial void OnLoaded();
4772    partial void OnValidate(ChangeAction action);
4773    partial void OnCreated();
4774    #endregion
4775
4776    #region Construction
4777    public AlgorithmData()
4778    {
4779      Initialize();
4780    }
4781   
4782    private void Initialize()
4783    {
4784      _Algorithm = default(EntityRef<Algorithm>);
4785      OnCreated();
4786    }
4787    #endregion
4788
4789    #region Column Mappings
4790    partial void OnAlgorithmIdChanging(long value);
4791    partial void OnAlgorithmIdChanged();
4792    private long _AlgorithmId;
4793    [Column(Storage=@"_AlgorithmId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
4794    [DataMember(Order=1)]
4795    public long AlgorithmId
4796    {
4797      get { return _AlgorithmId; }
4798      set {
4799        if (_AlgorithmId != value) {
4800          if (_Algorithm.HasLoadedOrAssignedValue) {
4801            throw new ForeignKeyReferenceAlreadyHasValueException();
4802          }
4803          OnAlgorithmIdChanging(value);
4804          SendPropertyChanging();
4805          _AlgorithmId = value;
4806          SendPropertyChanged("AlgorithmId");
4807          OnAlgorithmIdChanged();
4808        }
4809      }
4810    }
4811   
4812    partial void OnDataChanging(Binary value);
4813    partial void OnDataChanged();
4814    private Binary _Data;
4815    [Column(Storage=@"_Data", DbType=@"VarBinary(MAX) NOT NULL", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
4816    [DataMember(Order=2)]
4817    public Binary Data
4818    {
4819      get { return _Data; }
4820      set {
4821        if (_Data != value) {
4822          OnDataChanging(value);
4823          SendPropertyChanging();
4824          _Data = value;
4825          SendPropertyChanged("Data");
4826          OnDataChanged();
4827        }
4828      }
4829    }
4830   
4831    #endregion
4832   
4833    #region Associations
4834    private EntityRef<Algorithm> _Algorithm;
4835    [Association(Name=@"Algorithm_AlgorithmData", Storage=@"_Algorithm", ThisKey=@"AlgorithmId", OtherKey=@"Id", IsForeignKey=true)]
4836    [DataMember(Order=3, EmitDefaultValue=false)]
4837    public Algorithm Algorithm
4838    {
4839      get {
4840        return _Algorithm.Entity;
4841      }
4842      set {
4843        Algorithm previousValue = _Algorithm.Entity;
4844        if ((previousValue != value) || (!_Algorithm.HasLoadedOrAssignedValue)) {
4845          SendPropertyChanging();
4846          if (previousValue != null) {
4847            _Algorithm.Entity = null;
4848            previousValue.AlgorithmData = null;
4849          }
4850          _Algorithm.Entity = value;
4851          if (value != null) {
4852            value.AlgorithmData = this;
4853            _AlgorithmId = value.Id;
4854          }
4855          else {
4856            _AlgorithmId = default(long);
4857          }
4858          SendPropertyChanged("Algorithm");
4859        }
4860      }
4861    }
4862
4863    #endregion
4864   
4865    #region Serialization
4866    [OnDeserializing()]
4867    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
4868    public  void OnDeserializing(StreamingContext context)
4869    {
4870      Initialize();
4871    }
4872    #endregion
4873  }
4874}
4875
4876namespace HeuristicLab.Services.OKB.DataAccess
4877{
4878  [DataContract(IsReference=true)]
4879  [Table(Name=@"dbo.[User]")]
4880[KnownType(typeof(User))] public partial class User : INotifyPropertyChanging, INotifyPropertyChanged
4881  {
4882    #region Property Change Event Handling
4883    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
4884   
4885    public event PropertyChangingEventHandler PropertyChanging;
4886    public event PropertyChangedEventHandler PropertyChanged;
4887   
4888    public virtual void SendPropertyChanging()
4889    {
4890      if (PropertyChanging != null) {
4891        PropertyChanging(this, emptyChangingEventArgs);
4892      }
4893    }
4894     
4895    public virtual void SendPropertyChanged(String propertyName)
4896    {
4897      if (PropertyChanged != null) {
4898        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
4899      }
4900    }
4901    #endregion
4902   
4903    #region Extensibility Method Definitions
4904    partial void OnLoaded();
4905    partial void OnValidate(ChangeAction action);
4906    partial void OnCreated();
4907    #endregion
4908
4909    #region Construction
4910    public User()
4911    {
4912      Initialize();
4913    }
4914   
4915    private void Initialize()
4916    {
4917      _AlgorithmUsers = new EntitySet<AlgorithmUser>(attach_AlgorithmUsers, detach_AlgorithmUsers);
4918      _ProblemUsers = new EntitySet<ProblemUser>(attach_ProblemUsers, detach_ProblemUsers);
4919      _Runs = new EntitySet<Run>(attach_Runs, detach_Runs);
4920      OnCreated();
4921    }
4922    #endregion
4923
4924    #region Column Mappings
4925    partial void OnIdChanging(Guid value);
4926    partial void OnIdChanged();
4927    private Guid _Id;
4928    [Column(Storage=@"_Id", DbType=@"UniqueIdentifier NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
4929    [DataMember(Order=1)]
4930    public Guid Id
4931    {
4932      get { return _Id; }
4933      set {
4934        if (_Id != value) {
4935          OnIdChanging(value);
4936          SendPropertyChanging();
4937          _Id = value;
4938          SendPropertyChanged("Id");
4939          OnIdChanged();
4940        }
4941      }
4942    }
4943   
4944    partial void OnNameChanging(string value);
4945    partial void OnNameChanged();
4946    private string _Name;
4947    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
4948    [DataMember(Order=2)]
4949    public string Name
4950    {
4951      get { return _Name; }
4952      set {
4953        if (_Name != value) {
4954          OnNameChanging(value);
4955          SendPropertyChanging();
4956          _Name = value;
4957          SendPropertyChanged("Name");
4958          OnNameChanged();
4959        }
4960      }
4961    }
4962   
4963    #endregion
4964   
4965    #region Associations
4966    private EntitySet<AlgorithmUser> _AlgorithmUsers;
4967    [Association(Name=@"User_AlgorithmUser", Storage=@"_AlgorithmUsers", ThisKey=@"Id", OtherKey=@"UserId")]
4968    [DataMember(Order=3, EmitDefaultValue=false)]
4969    public EntitySet<AlgorithmUser> AlgorithmUsers
4970    {
4971      get {
4972        if (serializing && !_AlgorithmUsers.HasLoadedOrAssignedValues) {
4973          return null;
4974        }
4975        return _AlgorithmUsers;
4976      }
4977      set {
4978        _AlgorithmUsers.Assign(value);
4979      }
4980    }
4981
4982    private void attach_AlgorithmUsers(AlgorithmUser entity)
4983    {
4984      SendPropertyChanging();
4985      entity.User = this;
4986    }
4987   
4988    private void detach_AlgorithmUsers(AlgorithmUser entity)
4989    {
4990      SendPropertyChanging();
4991      entity.User = null;
4992    }
4993    private EntitySet<ProblemUser> _ProblemUsers;
4994    [Association(Name=@"User_ProblemUser", Storage=@"_ProblemUsers", ThisKey=@"Id", OtherKey=@"UserId")]
4995    [DataMember(Order=4, EmitDefaultValue=false)]
4996    public EntitySet<ProblemUser> ProblemUsers
4997    {
4998      get {
4999        if (serializing && !_ProblemUsers.HasLoadedOrAssignedValues) {
5000          return null;
5001        }
5002        return _ProblemUsers;
5003      }
5004      set {
5005        _ProblemUsers.Assign(value);
5006      }
5007    }
5008
5009    private void attach_ProblemUsers(ProblemUser entity)
5010    {
5011      SendPropertyChanging();
5012      entity.User = this;
5013    }
5014   
5015    private void detach_ProblemUsers(ProblemUser entity)
5016    {
5017      SendPropertyChanging();
5018      entity.User = null;
5019    }
5020    private EntitySet<Run> _Runs;
5021    [Association(Name=@"User_Run", Storage=@"_Runs", ThisKey=@"Id", OtherKey=@"UserId")]
5022    [DataMember(Order=5, EmitDefaultValue=false)]
5023    public EntitySet<Run> Runs
5024    {
5025      get {
5026        if (serializing && !_Runs.HasLoadedOrAssignedValues) {
5027          return null;
5028        }
5029        return _Runs;
5030      }
5031      set {
5032        _Runs.Assign(value);
5033      }
5034    }
5035
5036    private void attach_Runs(Run entity)
5037    {
5038      SendPropertyChanging();
5039      entity.User = this;
5040    }
5041   
5042    private void detach_Runs(Run entity)
5043    {
5044      SendPropertyChanging();
5045      entity.User = null;
5046    }
5047    #endregion
5048   
5049    #region Serialization
5050    private bool serializing;
5051   
5052    [OnSerializing()]
5053    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
5054    public void OnSerializing(StreamingContext context)
5055    {
5056      serializing = true;
5057    }
5058   
5059    [OnSerialized()]
5060    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
5061    public void OnSerialized(StreamingContext context)
5062    {
5063      serializing = false;
5064    }
5065   
5066    [OnDeserializing()]
5067    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
5068    public  void OnDeserializing(StreamingContext context)
5069    {
5070      Initialize();
5071    }
5072    #endregion
5073  }
5074}
5075
5076namespace HeuristicLab.Services.OKB.DataAccess
5077{
5078  [DataContract(IsReference=true)]
5079  [Table(Name=@"dbo.ProblemData")]
5080[KnownType(typeof(ProblemData))]  public partial class ProblemData : INotifyPropertyChanging, INotifyPropertyChanged
5081  {
5082    #region Property Change Event Handling
5083    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
5084   
5085    public event PropertyChangingEventHandler PropertyChanging;
5086    public event PropertyChangedEventHandler PropertyChanged;
5087   
5088    public virtual void SendPropertyChanging()
5089    {
5090      if (PropertyChanging != null) {
5091        PropertyChanging(this, emptyChangingEventArgs);
5092      }
5093    }
5094     
5095    public virtual void SendPropertyChanged(String propertyName)
5096    {
5097      if (PropertyChanged != null) {
5098        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
5099      }
5100    }
5101    #endregion
5102   
5103    #region Extensibility Method Definitions
5104    partial void OnLoaded();
5105    partial void OnValidate(ChangeAction action);
5106    partial void OnCreated();
5107    #endregion
5108
5109    #region Construction
5110    public ProblemData()
5111    {
5112      Initialize();
5113    }
5114   
5115    private void Initialize()
5116    {
5117      _Problem = default(EntityRef<Problem>);
5118      OnCreated();
5119    }
5120    #endregion
5121
5122    #region Column Mappings
5123    partial void OnProblemIdChanging(long value);
5124    partial void OnProblemIdChanged();
5125    private long _ProblemId;
5126    [Column(Storage=@"_ProblemId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
5127    [DataMember(Order=1)]
5128    public long ProblemId
5129    {
5130      get { return _ProblemId; }
5131      set {
5132        if (_ProblemId != value) {
5133          if (_Problem.HasLoadedOrAssignedValue) {
5134            throw new ForeignKeyReferenceAlreadyHasValueException();
5135          }
5136          OnProblemIdChanging(value);
5137          SendPropertyChanging();
5138          _ProblemId = value;
5139          SendPropertyChanged("ProblemId");
5140          OnProblemIdChanged();
5141        }
5142      }
5143    }
5144   
5145    partial void OnDataChanging(Binary value);
5146    partial void OnDataChanged();
5147    private Binary _Data;
5148    [Column(Storage=@"_Data", DbType=@"VarBinary(MAX) NOT NULL", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
5149    [DataMember(Order=2)]
5150    public Binary Data
5151    {
5152      get { return _Data; }
5153      set {
5154        if (_Data != value) {
5155          OnDataChanging(value);
5156          SendPropertyChanging();
5157          _Data = value;
5158          SendPropertyChanged("Data");
5159          OnDataChanged();
5160        }
5161      }
5162    }
5163   
5164    #endregion
5165   
5166    #region Associations
5167    private EntityRef<Problem> _Problem;
5168    [Association(Name=@"Problem_ProblemData", Storage=@"_Problem", ThisKey=@"ProblemId", OtherKey=@"Id", IsForeignKey=true)]
5169    [DataMember(Order=3, EmitDefaultValue=false)]
5170    public Problem Problem
5171    {
5172      get {
5173        return _Problem.Entity;
5174      }
5175      set {
5176        Problem previousValue = _Problem.Entity;
5177        if ((previousValue != value) || (!_Problem.HasLoadedOrAssignedValue)) {
5178          SendPropertyChanging();
5179          if (previousValue != null) {
5180            _Problem.Entity = null;
5181            previousValue.ProblemData = null;
5182          }
5183          _Problem.Entity = value;
5184          if (value != null) {
5185            value.ProblemData = this;
5186            _ProblemId = value.Id;
5187          }
5188          else {
5189            _ProblemId = default(long);
5190          }
5191          SendPropertyChanged("Problem");
5192        }
5193      }
5194    }
5195
5196    #endregion
5197   
5198    #region Serialization
5199    [OnDeserializing()]
5200    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
5201    public  void OnDeserializing(StreamingContext context)
5202    {
5203      Initialize();
5204    }
5205    #endregion
5206  }
5207}
5208
5209namespace HeuristicLab.Services.OKB.DataAccess
5210{
5211  [DataContract(IsReference=true)]
5212  [Table(Name=@"dbo.AlgorithmUser")]
5213[KnownType(typeof(AlgorithmUser))]  public partial class AlgorithmUser : INotifyPropertyChanging, INotifyPropertyChanged
5214  {
5215    #region Property Change Event Handling
5216    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
5217   
5218    public event PropertyChangingEventHandler PropertyChanging;
5219    public event PropertyChangedEventHandler PropertyChanged;
5220   
5221    public virtual void SendPropertyChanging()
5222    {
5223      if (PropertyChanging != null) {
5224        PropertyChanging(this, emptyChangingEventArgs);
5225      }
5226    }
5227     
5228    public virtual void SendPropertyChanged(String propertyName)
5229    {
5230      if (PropertyChanged != null) {
5231        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
5232      }
5233    }
5234    #endregion
5235   
5236    #region Extensibility Method Definitions
5237    partial void OnLoaded();
5238    partial void OnValidate(ChangeAction action);
5239    partial void OnCreated();
5240    #endregion
5241
5242    #region Construction
5243    public AlgorithmUser()
5244    {
5245      Initialize();
5246    }
5247   
5248    private void Initialize()
5249    {
5250      _Algorithm = default(EntityRef<Algorithm>);
5251      _User = default(EntityRef<User>);
5252      OnCreated();
5253    }
5254    #endregion
5255
5256    #region Column Mappings
5257    partial void OnAlgorithmIdChanging(long value);
5258    partial void OnAlgorithmIdChanged();
5259    private long _AlgorithmId;
5260    [Column(Storage=@"_AlgorithmId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
5261    [DataMember(Order=1)]
5262    public long AlgorithmId
5263    {
5264      get { return _AlgorithmId; }
5265      set {
5266        if (_AlgorithmId != value) {
5267          if (_Algorithm.HasLoadedOrAssignedValue) {
5268            throw new ForeignKeyReferenceAlreadyHasValueException();
5269          }
5270          OnAlgorithmIdChanging(value);
5271          SendPropertyChanging();
5272          _AlgorithmId = value;
5273          SendPropertyChanged("AlgorithmId");
5274          OnAlgorithmIdChanged();
5275        }
5276      }
5277    }
5278   
5279    partial void OnUserIdChanging(Guid value);
5280    partial void OnUserIdChanged();
5281    private Guid _UserId;
5282    [Column(Storage=@"_UserId", DbType=@"UniqueIdentifier NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
5283    [DataMember(Order=2)]
5284    public Guid UserId
5285    {
5286      get { return _UserId; }
5287      set {
5288        if (_UserId != value) {
5289          if (_User.HasLoadedOrAssignedValue) {
5290            throw new ForeignKeyReferenceAlreadyHasValueException();
5291          }
5292          OnUserIdChanging(value);
5293          SendPropertyChanging();
5294          _UserId = value;
5295          SendPropertyChanged("UserId");
5296          OnUserIdChanged();
5297        }
5298      }
5299    }
5300   
5301    #endregion
5302   
5303    #region Associations
5304    private EntityRef<Algorithm> _Algorithm;
5305    [Association(Name=@"Algorithm_AlgorithmUser", Storage=@"_Algorithm", ThisKey=@"AlgorithmId", OtherKey=@"Id", IsForeignKey=true)]
5306    [DataMember(Order=3, EmitDefaultValue=false)]
5307    public Algorithm Algorithm
5308    {
5309      get {
5310        return _Algorithm.Entity;
5311      }
5312      set {
5313        Algorithm previousValue = _Algorithm.Entity;
5314        if ((previousValue != value) || (!_Algorithm.HasLoadedOrAssignedValue)) {
5315          SendPropertyChanging();
5316          if (previousValue != null) {
5317            _Algorithm.Entity = null;
5318            previousValue.AlgorithmUsers.Remove(this);
5319          }
5320          _Algorithm.Entity = value;
5321          if (value != null) {
5322            value.AlgorithmUsers.Add(this);
5323            _AlgorithmId = value.Id;
5324          }
5325          else {
5326            _AlgorithmId = default(long);
5327          }
5328          SendPropertyChanged("Algorithm");
5329        }
5330      }
5331    }
5332
5333    private EntityRef<User> _User;
5334    [Association(Name=@"User_AlgorithmUser", Storage=@"_User", ThisKey=@"UserId", OtherKey=@"Id", IsForeignKey=true)]
5335    [DataMember(Order=4, EmitDefaultValue=false)]
5336    public User User
5337    {
5338      get {
5339        return _User.Entity;
5340      }
5341      set {
5342        User previousValue = _User.Entity;
5343        if ((previousValue != value) || (!_User.HasLoadedOrAssignedValue)) {
5344          SendPropertyChanging();
5345          if (previousValue != null) {
5346            _User.Entity = null;
5347            previousValue.AlgorithmUsers.Remove(this);
5348          }
5349          _User.Entity = value;
5350          if (value != null) {
5351            value.AlgorithmUsers.Add(this);
5352            _UserId = value.Id;
5353          }
5354          else {
5355            _UserId = default(Guid);
5356          }
5357          SendPropertyChanged("User");
5358        }
5359      }
5360    }
5361
5362    #endregion
5363   
5364    #region Serialization
5365    [OnDeserializing()]
5366    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
5367    public  void OnDeserializing(StreamingContext context)
5368    {
5369      Initialize();
5370    }
5371    #endregion
5372  }
5373}
5374
5375namespace HeuristicLab.Services.OKB.DataAccess
5376{
5377  [DataContract(IsReference=true)]
5378  [Table(Name=@"dbo.ProblemUser")]
5379[KnownType(typeof(ProblemUser))]  public partial class ProblemUser : INotifyPropertyChanging, INotifyPropertyChanged
5380  {
5381    #region Property Change Event Handling
5382    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
5383   
5384    public event PropertyChangingEventHandler PropertyChanging;
5385    public event PropertyChangedEventHandler PropertyChanged;
5386   
5387    public virtual void SendPropertyChanging()
5388    {
5389      if (PropertyChanging != null) {
5390        PropertyChanging(this, emptyChangingEventArgs);
5391      }
5392    }
5393     
5394    public virtual void SendPropertyChanged(String propertyName)
5395    {
5396      if (PropertyChanged != null) {
5397        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
5398      }
5399    }
5400    #endregion
5401   
5402    #region Extensibility Method Definitions
5403    partial void OnLoaded();
5404    partial void OnValidate(ChangeAction action);
5405    partial void OnCreated();
5406    #endregion
5407
5408    #region Construction
5409    public ProblemUser()
5410    {
5411      Initialize();
5412    }
5413   
5414    private void Initialize()
5415    {
5416      _Problem = default(EntityRef<Problem>);
5417      _User = default(EntityRef<User>);
5418      OnCreated();
5419    }
5420    #endregion
5421
5422    #region Column Mappings
5423    partial void OnProblemIdChanging(long value);
5424    partial void OnProblemIdChanged();
5425    private long _ProblemId;
5426    [Column(Storage=@"_ProblemId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
5427    [DataMember(Order=1)]
5428    public long ProblemId
5429    {
5430      get { return _ProblemId; }
5431      set {
5432        if (_ProblemId != value) {
5433          if (_Problem.HasLoadedOrAssignedValue) {
5434            throw new ForeignKeyReferenceAlreadyHasValueException();
5435          }
5436          OnProblemIdChanging(value);
5437          SendPropertyChanging();
5438          _ProblemId = value;
5439          SendPropertyChanged("ProblemId");
5440          OnProblemIdChanged();
5441        }
5442      }
5443    }
5444   
5445    partial void OnUserIdChanging(Guid value);
5446    partial void OnUserIdChanged();
5447    private Guid _UserId;
5448    [Column(Storage=@"_UserId", DbType=@"UniqueIdentifier NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
5449    [DataMember(Order=2)]
5450    public Guid UserId
5451    {
5452      get { return _UserId; }
5453      set {
5454        if (_UserId != value) {
5455          if (_User.HasLoadedOrAssignedValue) {
5456            throw new ForeignKeyReferenceAlreadyHasValueException();
5457          }
5458          OnUserIdChanging(value);
5459          SendPropertyChanging();
5460          _UserId = value;
5461          SendPropertyChanged("UserId");
5462          OnUserIdChanged();
5463        }
5464      }
5465    }
5466   
5467    #endregion
5468   
5469    #region Associations
5470    private EntityRef<Problem> _Problem;
5471    [Association(Name=@"Problem_ProblemUser", Storage=@"_Problem", ThisKey=@"ProblemId", OtherKey=@"Id", IsForeignKey=true)]
5472    [DataMember(Order=3, EmitDefaultValue=false)]
5473    public Problem Problem
5474    {
5475      get {
5476        return _Problem.Entity;
5477      }
5478      set {
5479        Problem previousValue = _Problem.Entity;
5480        if ((previousValue != value) || (!_Problem.HasLoadedOrAssignedValue)) {
5481          SendPropertyChanging();
5482          if (previousValue != null) {
5483            _Problem.Entity = null;
5484            previousValue.ProblemUsers.Remove(this);
5485          }
5486          _Problem.Entity = value;
5487          if (value != null) {
5488            value.ProblemUsers.Add(this);
5489            _ProblemId = value.Id;
5490          }
5491          else {
5492            _ProblemId = default(long);
5493          }
5494          SendPropertyChanged("Problem");
5495        }
5496      }
5497    }
5498
5499    private EntityRef<User> _User;
5500    [Association(Name=@"User_ProblemUser", Storage=@"_User", ThisKey=@"UserId", OtherKey=@"Id", IsForeignKey=true)]
5501    [DataMember(Order=4, EmitDefaultValue=false)]
5502    public User User
5503    {
5504      get {
5505        return _User.Entity;
5506      }
5507      set {
5508        User previousValue = _User.Entity;
5509        if ((previousValue != value) || (!_User.HasLoadedOrAssignedValue)) {
5510          SendPropertyChanging();
5511          if (previousValue != null) {
5512            _User.Entity = null;
5513            previousValue.ProblemUsers.Remove(this);
5514          }
5515          _User.Entity = value;
5516          if (value != null) {
5517            value.ProblemUsers.Add(this);
5518            _UserId = value.Id;
5519          }
5520          else {
5521            _UserId = default(Guid);
5522          }
5523          SendPropertyChanged("User");
5524        }
5525      }
5526    }
5527
5528    #endregion
5529   
5530    #region Serialization
5531    [OnDeserializing()]
5532    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
5533    public  void OnDeserializing(StreamingContext context)
5534    {
5535      Initialize();
5536    }
5537    #endregion
5538  }
5539}
5540
5541namespace HeuristicLab.Services.OKB.DataAccess
5542{
5543  [DataContract(IsReference=true)]
5544  [Table(Name=@"dbo.Platform")]
5545[KnownType(typeof(Platform))] public partial class Platform : INotifyPropertyChanging, INotifyPropertyChanged
5546  {
5547    #region Property Change Event Handling
5548    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
5549   
5550    public event PropertyChangingEventHandler PropertyChanging;
5551    public event PropertyChangedEventHandler PropertyChanged;
5552   
5553    public virtual void SendPropertyChanging()
5554    {
5555      if (PropertyChanging != null) {
5556        PropertyChanging(this, emptyChangingEventArgs);
5557      }
5558    }
5559     
5560    public virtual void SendPropertyChanged(String propertyName)
5561    {
5562      if (PropertyChanged != null) {
5563        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
5564      }
5565    }
5566    #endregion
5567   
5568    #region Extensibility Method Definitions
5569    partial void OnLoaded();
5570    partial void OnValidate(ChangeAction action);
5571    partial void OnCreated();
5572    #endregion
5573
5574    #region Construction
5575    public Platform()
5576    {
5577      Initialize();
5578    }
5579   
5580    private void Initialize()
5581    {
5582      _Algorithms = new EntitySet<Algorithm>(attach_Algorithms, detach_Algorithms);
5583      _Problems = new EntitySet<Problem>(attach_Problems, detach_Problems);
5584      OnCreated();
5585    }
5586    #endregion
5587
5588    #region Column Mappings
5589    partial void OnIdChanging(long value);
5590    partial void OnIdChanged();
5591    private long _Id;
5592    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
5593    [DataMember(Order=1)]
5594    public long Id
5595    {
5596      get { return _Id; }
5597      set {
5598        if (_Id != value) {
5599          OnIdChanging(value);
5600          SendPropertyChanging();
5601          _Id = value;
5602          SendPropertyChanged("Id");
5603          OnIdChanged();
5604        }
5605      }
5606    }
5607   
5608    partial void OnNameChanging(string value);
5609    partial void OnNameChanged();
5610    private string _Name;
5611    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
5612    [DataMember(Order=2)]
5613    public string Name
5614    {
5615      get { return _Name; }
5616      set {
5617        if (_Name != value) {
5618          OnNameChanging(value);
5619          SendPropertyChanging();
5620          _Name = value;
5621          SendPropertyChanged("Name");
5622          OnNameChanged();
5623        }
5624      }
5625    }
5626   
5627    partial void OnDescriptionChanging(string value);
5628    partial void OnDescriptionChanged();
5629    private string _Description;
5630    [Column(Storage=@"_Description", DbType=@"NVarChar(MAX)")]
5631    [DataMember(Order=3)]
5632    public string Description
5633    {
5634      get { return _Description; }
5635      set {
5636        if (_Description != value) {
5637          OnDescriptionChanging(value);
5638          SendPropertyChanging();
5639          _Description = value;
5640          SendPropertyChanged("Description");
5641          OnDescriptionChanged();
5642        }
5643      }
5644    }
5645   
5646    #endregion
5647   
5648    #region Associations
5649    private EntitySet<Algorithm> _Algorithms;
5650    [Association(Name=@"Platform_Algorithm", Storage=@"_Algorithms", ThisKey=@"Id", OtherKey=@"PlatformId")]
5651    [DataMember(Order=4, EmitDefaultValue=false)]
5652    public EntitySet<Algorithm> Algorithms
5653    {
5654      get {
5655        if (serializing && !_Algorithms.HasLoadedOrAssignedValues) {
5656          return null;
5657        }
5658        return _Algorithms;
5659      }
5660      set {
5661        _Algorithms.Assign(value);
5662      }
5663    }
5664
5665    private void attach_Algorithms(Algorithm entity)
5666    {
5667      SendPropertyChanging();
5668      entity.Platform = this;
5669    }
5670   
5671    private void detach_Algorithms(Algorithm entity)
5672    {
5673      SendPropertyChanging();
5674      entity.Platform = null;
5675    }
5676    private EntitySet<Problem> _Problems;
5677    [Association(Name=@"Platform_Problem", Storage=@"_Problems", ThisKey=@"Id", OtherKey=@"PlatformId")]
5678    [DataMember(Order=5, EmitDefaultValue=false)]
5679    public EntitySet<Problem> Problems
5680    {
5681      get {
5682        if (serializing && !_Problems.HasLoadedOrAssignedValues) {
5683          return null;
5684        }
5685        return _Problems;
5686      }
5687      set {
5688        _Problems.Assign(value);
5689      }
5690    }
5691
5692    private void attach_Problems(Problem entity)
5693    {
5694      SendPropertyChanging();
5695      entity.Platform = this;
5696    }
5697   
5698    private void detach_Problems(Problem entity)
5699    {
5700      SendPropertyChanging();
5701      entity.Platform = null;
5702    }
5703    #endregion
5704   
5705    #region Serialization
5706    private bool serializing;
5707   
5708    [OnSerializing()]
5709    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
5710    public void OnSerializing(StreamingContext context)
5711    {
5712      serializing = true;
5713    }
5714   
5715    [OnSerialized()]
5716    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
5717    public void OnSerialized(StreamingContext context)
5718    {
5719      serializing = false;
5720    }
5721   
5722    [OnDeserializing()]
5723    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
5724    public  void OnDeserializing(StreamingContext context)
5725    {
5726      Initialize();
5727    }
5728    #endregion
5729  }
5730}
5731
5732namespace HeuristicLab.Services.OKB.DataAccess
5733{
5734  [DataContract(IsReference=true)]
5735  [Table(Name=@"dbo.SolutionRepresentation")]
5736[KnownType(typeof(SolutionRepresentation))] public partial class SolutionRepresentation : INotifyPropertyChanging, INotifyPropertyChanged
5737  {
5738    #region Property Change Event Handling
5739    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
5740   
5741    public event PropertyChangingEventHandler PropertyChanging;
5742    public event PropertyChangedEventHandler PropertyChanged;
5743   
5744    public virtual void SendPropertyChanging()
5745    {
5746      if (PropertyChanging != null) {
5747        PropertyChanging(this, emptyChangingEventArgs);
5748      }
5749    }
5750     
5751    public virtual void SendPropertyChanged(String propertyName)
5752    {
5753      if (PropertyChanged != null) {
5754        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
5755      }
5756    }
5757    #endregion
5758   
5759    #region Extensibility Method Definitions
5760    partial void OnLoaded();
5761    partial void OnValidate(ChangeAction action);
5762    partial void OnCreated();
5763    #endregion
5764
5765    #region Construction
5766    public SolutionRepresentation()
5767    {
5768      Initialize();
5769    }
5770   
5771    private void Initialize()
5772    {
5773      _Problems = new EntitySet<Problem>(attach_Problems, detach_Problems);
5774      OnCreated();
5775    }
5776    #endregion
5777
5778    #region Column Mappings
5779    partial void OnIdChanging(long value);
5780    partial void OnIdChanged();
5781    private long _Id;
5782    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
5783    [DataMember(Order=1)]
5784    public long Id
5785    {
5786      get { return _Id; }
5787      set {
5788        if (_Id != value) {
5789          OnIdChanging(value);
5790          SendPropertyChanging();
5791          _Id = value;
5792          SendPropertyChanged("Id");
5793          OnIdChanged();
5794        }
5795      }
5796    }
5797   
5798    partial void OnNameChanging(string value);
5799    partial void OnNameChanged();
5800    private string _Name;
5801    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
5802    [DataMember(Order=2)]
5803    public string Name
5804    {
5805      get { return _Name; }
5806      set {
5807        if (_Name != value) {
5808          OnNameChanging(value);
5809          SendPropertyChanging();
5810          _Name = value;
5811          SendPropertyChanged("Name");
5812          OnNameChanged();
5813        }
5814      }
5815    }
5816   
5817    partial void OnDescriptionChanging(string value);
5818    partial void OnDescriptionChanged();
5819    private string _Description;
5820    [Column(Storage=@"_Description", DbType=@"NVarChar(MAX)")]
5821    [DataMember(Order=3)]
5822    public string Description
5823    {
5824      get { return _Description; }
5825      set {
5826        if (_Description != value) {
5827          OnDescriptionChanging(value);
5828          SendPropertyChanging();
5829          _Description = value;
5830          SendPropertyChanged("Description");
5831          OnDescriptionChanged();
5832        }
5833      }
5834    }
5835   
5836    #endregion
5837   
5838    #region Associations
5839    private EntitySet<Problem> _Problems;
5840    [Association(Name=@"SolutionRepresentation_Problem", Storage=@"_Problems", ThisKey=@"Id", OtherKey=@"SolutionRepresentationId")]
5841    [DataMember(Order=4, EmitDefaultValue=false)]
5842    public EntitySet<Problem> Problems
5843    {
5844      get {
5845        if (serializing && !_Problems.HasLoadedOrAssignedValues) {
5846          return null;
5847        }
5848        return _Problems;
5849      }
5850      set {
5851        _Problems.Assign(value);
5852      }
5853    }
5854
5855    private void attach_Problems(Problem entity)
5856    {
5857      SendPropertyChanging();
5858      entity.SolutionRepresentation = this;
5859    }
5860   
5861    private void detach_Problems(Problem entity)
5862    {
5863      SendPropertyChanging();
5864      entity.SolutionRepresentation = null;
5865    }
5866    #endregion
5867   
5868    #region Serialization
5869    private bool serializing;
5870   
5871    [OnSerializing()]
5872    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
5873    public void OnSerializing(StreamingContext context)
5874    {
5875      serializing = true;
5876    }
5877   
5878    [OnSerialized()]
5879    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
5880    public void OnSerialized(StreamingContext context)
5881    {
5882      serializing = false;
5883    }
5884   
5885    [OnDeserializing()]
5886    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
5887    public  void OnDeserializing(StreamingContext context)
5888    {
5889      Initialize();
5890    }
5891    #endregion
5892  }
5893}
5894
5895namespace HeuristicLab.Services.OKB.DataAccess
5896{
5897  [DataContract(IsReference=true)]
5898  [Table(Name=@"dbo.Run")]
5899[KnownType(typeof(Run))]  public partial class Run : INotifyPropertyChanging, INotifyPropertyChanged
5900  {
5901    #region Property Change Event Handling
5902    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
5903   
5904    public event PropertyChangingEventHandler PropertyChanging;
5905    public event PropertyChangedEventHandler PropertyChanged;
5906   
5907    public virtual void SendPropertyChanging()
5908    {
5909      if (PropertyChanging != null) {
5910        PropertyChanging(this, emptyChangingEventArgs);
5911      }
5912    }
5913     
5914    public virtual void SendPropertyChanged(String propertyName)
5915    {
5916      if (PropertyChanged != null) {
5917        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
5918      }
5919    }
5920    #endregion
5921   
5922    #region Extensibility Method Definitions
5923    partial void OnLoaded();
5924    partial void OnValidate(ChangeAction action);
5925    partial void OnCreated();
5926    #endregion
5927
5928    #region Construction
5929    public Run()
5930    {
5931      Initialize();
5932    }
5933   
5934    private void Initialize()
5935    {
5936      _ResultBlobValues = new EntitySet<ResultBlobValue>(attach_ResultBlobValues, detach_ResultBlobValues);
5937      _ResultBoolValues = new EntitySet<ResultBoolValue>(attach_ResultBoolValues, detach_ResultBoolValues);
5938      _ResultFloatValues = new EntitySet<ResultFloatValue>(attach_ResultFloatValues, detach_ResultFloatValues);
5939      _ResultIntValues = new EntitySet<ResultIntValue>(attach_ResultIntValues, detach_ResultIntValues);
5940      _ResultStringValues = new EntitySet<ResultStringValue>(attach_ResultStringValues, detach_ResultStringValues);
5941      _Experiment = default(EntityRef<Experiment>);
5942      _User = default(EntityRef<User>);
5943      _Client = default(EntityRef<Client>);
5944      OnCreated();
5945    }
5946    #endregion
5947
5948    #region Column Mappings
5949    partial void OnIdChanging(long value);
5950    partial void OnIdChanged();
5951    private long _Id;
5952    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
5953    [DataMember(Order=1)]
5954    public long Id
5955    {
5956      get { return _Id; }
5957      set {
5958        if (_Id != value) {
5959          OnIdChanging(value);
5960          SendPropertyChanging();
5961          _Id = value;
5962          SendPropertyChanged("Id");
5963          OnIdChanged();
5964        }
5965      }
5966    }
5967   
5968    partial void OnExperimentIdChanging(long value);
5969    partial void OnExperimentIdChanged();
5970    private long _ExperimentId;
5971    [Column(Storage=@"_ExperimentId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
5972    [DataMember(Order=2)]
5973    public long ExperimentId
5974    {
5975      get { return _ExperimentId; }
5976      set {
5977        if (_ExperimentId != value) {
5978          if (_Experiment.HasLoadedOrAssignedValue) {
5979            throw new ForeignKeyReferenceAlreadyHasValueException();
5980          }
5981          OnExperimentIdChanging(value);
5982          SendPropertyChanging();
5983          _ExperimentId = value;
5984          SendPropertyChanged("ExperimentId");
5985          OnExperimentIdChanged();
5986        }
5987      }
5988    }
5989   
5990    partial void OnRandomSeedChanging(int value);
5991    partial void OnRandomSeedChanged();
5992    private int _RandomSeed;
5993    [Column(Storage=@"_RandomSeed", DbType=@"Int NOT NULL", CanBeNull=false)]
5994    [DataMember(Order=3)]
5995    public int RandomSeed
5996    {
5997      get { return _RandomSeed; }
5998      set {
5999        if (_RandomSeed != value) {
6000          OnRandomSeedChanging(value);
6001          SendPropertyChanging();
6002          _RandomSeed = value;
6003          SendPropertyChanged("RandomSeed");
6004          OnRandomSeedChanged();
6005        }
6006      }
6007    }
6008   
6009    partial void OnFinishedDateChanging(DateTime? value);
6010    partial void OnFinishedDateChanged();
6011    private DateTime? _FinishedDate;
6012    [Column(Storage=@"_FinishedDate", DbType=@"DateTime2")]
6013    [DataMember(Order=4)]
6014    public DateTime? FinishedDate
6015    {
6016      get { return _FinishedDate; }
6017      set {
6018        if (_FinishedDate != value) {
6019          OnFinishedDateChanging(value);
6020          SendPropertyChanging();
6021          _FinishedDate = value;
6022          SendPropertyChanged("FinishedDate");
6023          OnFinishedDateChanged();
6024        }
6025      }
6026    }
6027   
6028    partial void OnUserIdChanging(Guid value);
6029    partial void OnUserIdChanged();
6030    private Guid _UserId;
6031    [Column(Storage=@"_UserId", DbType=@"UniqueIdentifier NOT NULL", CanBeNull=false)]
6032    [DataMember(Order=5)]
6033    public Guid UserId
6034    {
6035      get { return _UserId; }
6036      set {
6037        if (_UserId != value) {
6038          if (_User.HasLoadedOrAssignedValue) {
6039            throw new ForeignKeyReferenceAlreadyHasValueException();
6040          }
6041          OnUserIdChanging(value);
6042          SendPropertyChanging();
6043          _UserId = value;
6044          SendPropertyChanged("UserId");
6045          OnUserIdChanged();
6046        }
6047      }
6048    }
6049   
6050    partial void OnClientIdChanging(Guid value);
6051    partial void OnClientIdChanged();
6052    private Guid _ClientId;
6053    [Column(Storage=@"_ClientId", DbType=@"UniqueIdentifier NOT NULL", CanBeNull=false)]
6054    [DataMember(Order=6)]
6055    public Guid ClientId
6056    {
6057      get { return _ClientId; }
6058      set {
6059        if (_ClientId != value) {
6060          if (_Client.HasLoadedOrAssignedValue) {
6061            throw new ForeignKeyReferenceAlreadyHasValueException();
6062          }
6063          OnClientIdChanging(value);
6064          SendPropertyChanging();
6065          _ClientId = value;
6066          SendPropertyChanged("ClientId");
6067          OnClientIdChanged();
6068        }
6069      }
6070    }
6071   
6072    #endregion
6073   
6074    #region Associations
6075    private EntitySet<ResultBlobValue> _ResultBlobValues;
6076    [Association(Name=@"Run_ResultBlobValue", Storage=@"_ResultBlobValues", ThisKey=@"Id", OtherKey=@"RunId")]
6077    [DataMember(Order=7, EmitDefaultValue=false)]
6078    public EntitySet<ResultBlobValue> ResultBlobValues
6079    {
6080      get {
6081        if (serializing && !_ResultBlobValues.HasLoadedOrAssignedValues) {
6082          return null;
6083        }
6084        return _ResultBlobValues;
6085      }
6086      set {
6087        _ResultBlobValues.Assign(value);
6088      }
6089    }
6090
6091    private void attach_ResultBlobValues(ResultBlobValue entity)
6092    {
6093      SendPropertyChanging();
6094      entity.Run = this;
6095    }
6096   
6097    private void detach_ResultBlobValues(ResultBlobValue entity)
6098    {
6099      SendPropertyChanging();
6100      entity.Run = null;
6101    }
6102    private EntitySet<ResultBoolValue> _ResultBoolValues;
6103    [Association(Name=@"Run_ResultBoolValue", Storage=@"_ResultBoolValues", ThisKey=@"Id", OtherKey=@"RunId")]
6104    [DataMember(Order=8, EmitDefaultValue=false)]
6105    public EntitySet<ResultBoolValue> ResultBoolValues
6106    {
6107      get {
6108        if (serializing && !_ResultBoolValues.HasLoadedOrAssignedValues) {
6109          return null;
6110        }
6111        return _ResultBoolValues;
6112      }
6113      set {
6114        _ResultBoolValues.Assign(value);
6115      }
6116    }
6117
6118    private void attach_ResultBoolValues(ResultBoolValue entity)
6119    {
6120      SendPropertyChanging();
6121      entity.Run = this;
6122    }
6123   
6124    private void detach_ResultBoolValues(ResultBoolValue entity)
6125    {
6126      SendPropertyChanging();
6127      entity.Run = null;
6128    }
6129    private EntitySet<ResultFloatValue> _ResultFloatValues;
6130    [Association(Name=@"Run_ResultFloatValue", Storage=@"_ResultFloatValues", ThisKey=@"Id", OtherKey=@"RunId")]
6131    [DataMember(Order=9, EmitDefaultValue=false)]
6132    public EntitySet<ResultFloatValue> ResultFloatValues
6133    {
6134      get {
6135        if (serializing && !_ResultFloatValues.HasLoadedOrAssignedValues) {
6136          return null;
6137        }
6138        return _ResultFloatValues;
6139      }
6140      set {
6141        _ResultFloatValues.Assign(value);
6142      }
6143    }
6144
6145    private void attach_ResultFloatValues(ResultFloatValue entity)
6146    {
6147      SendPropertyChanging();
6148      entity.Run = this;
6149    }
6150   
6151    private void detach_ResultFloatValues(ResultFloatValue entity)
6152    {
6153      SendPropertyChanging();
6154      entity.Run = null;
6155    }
6156    private EntitySet<ResultIntValue> _ResultIntValues;
6157    [Association(Name=@"Run_ResultIntValue", Storage=@"_ResultIntValues", ThisKey=@"Id", OtherKey=@"RunId")]
6158    [DataMember(Order=10, EmitDefaultValue=false)]
6159    public EntitySet<ResultIntValue> ResultIntValues
6160    {
6161      get {
6162        if (serializing && !_ResultIntValues.HasLoadedOrAssignedValues) {
6163          return null;
6164        }
6165        return _ResultIntValues;
6166      }
6167      set {
6168        _ResultIntValues.Assign(value);
6169      }
6170    }
6171
6172    private void attach_ResultIntValues(ResultIntValue entity)
6173    {
6174      SendPropertyChanging();
6175      entity.Run = this;
6176    }
6177   
6178    private void detach_ResultIntValues(ResultIntValue entity)
6179    {
6180      SendPropertyChanging();
6181      entity.Run = null;
6182    }
6183    private EntitySet<ResultStringValue> _ResultStringValues;
6184    [Association(Name=@"Run_ResultStringValue", Storage=@"_ResultStringValues", ThisKey=@"Id", OtherKey=@"RunId")]
6185    [DataMember(Order=11, EmitDefaultValue=false)]
6186    public EntitySet<ResultStringValue> ResultStringValues
6187    {
6188      get {
6189        if (serializing && !_ResultStringValues.HasLoadedOrAssignedValues) {
6190          return null;
6191        }
6192        return _ResultStringValues;
6193      }
6194      set {
6195        _ResultStringValues.Assign(value);
6196      }
6197    }
6198
6199    private void attach_ResultStringValues(ResultStringValue entity)
6200    {
6201      SendPropertyChanging();
6202      entity.Run = this;
6203    }
6204   
6205    private void detach_ResultStringValues(ResultStringValue entity)
6206    {
6207      SendPropertyChanging();
6208      entity.Run = null;
6209    }
6210    private EntityRef<Experiment> _Experiment;
6211    [Association(Name=@"Experiment_Run", Storage=@"_Experiment", ThisKey=@"ExperimentId", OtherKey=@"Id", IsForeignKey=true)]
6212    [DataMember(Order=12, EmitDefaultValue=false)]
6213    public Experiment Experiment
6214    {
6215      get {
6216        if (serializing && !_Experiment.HasLoadedOrAssignedValue) {
6217          return null;
6218        }
6219        return _Experiment.Entity;
6220      }
6221      set {
6222        Experiment previousValue = _Experiment.Entity;
6223        if ((previousValue != value) || (!_Experiment.HasLoadedOrAssignedValue)) {
6224          SendPropertyChanging();
6225          if (previousValue != null) {
6226            _Experiment.Entity = null;
6227            previousValue.Runs.Remove(this);
6228          }
6229          _Experiment.Entity = value;
6230          if (value != null) {
6231            value.Runs.Add(this);
6232            _ExperimentId = value.Id;
6233          }
6234          else {
6235            _ExperimentId = default(long);
6236          }
6237          SendPropertyChanged("Experiment");
6238        }
6239      }
6240    }
6241
6242    private EntityRef<User> _User;
6243    [Association(Name=@"User_Run", Storage=@"_User", ThisKey=@"UserId", OtherKey=@"Id", IsForeignKey=true)]
6244    [DataMember(Order=13, EmitDefaultValue=false)]
6245    public User User
6246    {
6247      get {
6248        if (serializing && !_User.HasLoadedOrAssignedValue) {
6249          return null;
6250        }
6251        return _User.Entity;
6252      }
6253      set {
6254        User previousValue = _User.Entity;
6255        if ((previousValue != value) || (!_User.HasLoadedOrAssignedValue)) {
6256          SendPropertyChanging();
6257          if (previousValue != null) {
6258            _User.Entity = null;
6259            previousValue.Runs.Remove(this);
6260          }
6261          _User.Entity = value;
6262          if (value != null) {
6263            value.Runs.Add(this);
6264            _UserId = value.Id;
6265          }
6266          else {
6267            _UserId = default(Guid);
6268          }
6269          SendPropertyChanged("User");
6270        }
6271      }
6272    }
6273
6274    private EntityRef<Client> _Client;
6275    [Association(Name=@"Client_Run", Storage=@"_Client", ThisKey=@"ClientId", OtherKey=@"Id", IsForeignKey=true)]
6276    [DataMember(Order=14, EmitDefaultValue=false)]
6277    public Client Client
6278    {
6279      get {
6280        if (serializing && !_Client.HasLoadedOrAssignedValue) {
6281          return null;
6282        }
6283        return _Client.Entity;
6284      }
6285      set {
6286        Client previousValue = _Client.Entity;
6287        if ((previousValue != value) || (!_Client.HasLoadedOrAssignedValue)) {
6288          SendPropertyChanging();
6289          if (previousValue != null) {
6290            _Client.Entity = null;
6291            previousValue.Runs.Remove(this);
6292          }
6293          _Client.Entity = value;
6294          if (value != null) {
6295            value.Runs.Add(this);
6296            _ClientId = value.Id;
6297          }
6298          else {
6299            _ClientId = default(Guid);
6300          }
6301          SendPropertyChanged("Client");
6302        }
6303      }
6304    }
6305
6306    #endregion
6307   
6308    #region Serialization
6309    private bool serializing;
6310   
6311    [OnSerializing()]
6312    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
6313    public void OnSerializing(StreamingContext context)
6314    {
6315      serializing = true;
6316    }
6317   
6318    [OnSerialized()]
6319    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
6320    public void OnSerialized(StreamingContext context)
6321    {
6322      serializing = false;
6323    }
6324   
6325    [OnDeserializing()]
6326    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
6327    public  void OnDeserializing(StreamingContext context)
6328    {
6329      Initialize();
6330    }
6331    #endregion
6332  }
6333}
6334
6335namespace HeuristicLab.Services.OKB.DataAccess
6336{
6337  [DataContract(IsReference=true)]
6338  [Table(Name=@"dbo.Result")]
6339[KnownType(typeof(Result))] public partial class Result : INotifyPropertyChanging, INotifyPropertyChanged
6340  {
6341    #region Property Change Event Handling
6342    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
6343   
6344    public event PropertyChangingEventHandler PropertyChanging;
6345    public event PropertyChangedEventHandler PropertyChanged;
6346   
6347    public virtual void SendPropertyChanging()
6348    {
6349      if (PropertyChanging != null) {
6350        PropertyChanging(this, emptyChangingEventArgs);
6351      }
6352    }
6353     
6354    public virtual void SendPropertyChanged(String propertyName)
6355    {
6356      if (PropertyChanged != null) {
6357        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
6358      }
6359    }
6360    #endregion
6361   
6362    #region Extensibility Method Definitions
6363    partial void OnLoaded();
6364    partial void OnValidate(ChangeAction action);
6365    partial void OnCreated();
6366    #endregion
6367
6368    #region Construction
6369    public Result()
6370    {
6371      Initialize();
6372    }
6373   
6374    private void Initialize()
6375    {
6376      _ResultBlobValues = new EntitySet<ResultBlobValue>(attach_ResultBlobValues, detach_ResultBlobValues);
6377      _ResultBoolValues = new EntitySet<ResultBoolValue>(attach_ResultBoolValues, detach_ResultBoolValues);
6378      _ResultFloatValues = new EntitySet<ResultFloatValue>(attach_ResultFloatValues, detach_ResultFloatValues);
6379      _ResultIntValues = new EntitySet<ResultIntValue>(attach_ResultIntValues, detach_ResultIntValues);
6380      _ResultStringValues = new EntitySet<ResultStringValue>(attach_ResultStringValues, detach_ResultStringValues);
6381      _Algorithm = default(EntityRef<Algorithm>);
6382      _DataType = default(EntityRef<DataType>);
6383      OnCreated();
6384    }
6385    #endregion
6386
6387    #region Column Mappings
6388    partial void OnIdChanging(long value);
6389    partial void OnIdChanged();
6390    private long _Id;
6391    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
6392    [DataMember(Order=1)]
6393    public long Id
6394    {
6395      get { return _Id; }
6396      set {
6397        if (_Id != value) {
6398          OnIdChanging(value);
6399          SendPropertyChanging();
6400          _Id = value;
6401          SendPropertyChanged("Id");
6402          OnIdChanged();
6403        }
6404      }
6405    }
6406   
6407    partial void OnAlgorithmIdChanging(long value);
6408    partial void OnAlgorithmIdChanged();
6409    private long _AlgorithmId;
6410    [Column(Storage=@"_AlgorithmId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
6411    [DataMember(Order=2)]
6412    public long AlgorithmId
6413    {
6414      get { return _AlgorithmId; }
6415      set {
6416        if (_AlgorithmId != value) {
6417          if (_Algorithm.HasLoadedOrAssignedValue) {
6418            throw new ForeignKeyReferenceAlreadyHasValueException();
6419          }
6420          OnAlgorithmIdChanging(value);
6421          SendPropertyChanging();
6422          _AlgorithmId = value;
6423          SendPropertyChanged("AlgorithmId");
6424          OnAlgorithmIdChanged();
6425        }
6426      }
6427    }
6428   
6429    partial void OnNameChanging(string value);
6430    partial void OnNameChanged();
6431    private string _Name;
6432    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
6433    [DataMember(Order=3)]
6434    public string Name
6435    {
6436      get { return _Name; }
6437      set {
6438        if (_Name != value) {
6439          OnNameChanging(value);
6440          SendPropertyChanging();
6441          _Name = value;
6442          SendPropertyChanged("Name");
6443          OnNameChanged();
6444        }
6445      }
6446    }
6447   
6448    partial void OnAliasChanging(string value);
6449    partial void OnAliasChanged();
6450    private string _Alias;
6451    [Column(Storage=@"_Alias", DbType=@"NVarChar(200)")]
6452    [DataMember(Order=4)]
6453    public string Alias
6454    {
6455      get { return _Alias; }
6456      set {
6457        if (_Alias != value) {
6458          OnAliasChanging(value);
6459          SendPropertyChanging();
6460          _Alias = value;
6461          SendPropertyChanged("Alias");
6462          OnAliasChanged();
6463        }
6464      }
6465    }
6466   
6467    partial void OnDescriptionChanging(string value);
6468    partial void OnDescriptionChanged();
6469    private string _Description;
6470    [Column(Storage=@"_Description", DbType=@"NVarChar(MAX)")]
6471    [DataMember(Order=5)]
6472    public string Description
6473    {
6474      get { return _Description; }
6475      set {
6476        if (_Description != value) {
6477          OnDescriptionChanging(value);
6478          SendPropertyChanging();
6479          _Description = value;
6480          SendPropertyChanged("Description");
6481          OnDescriptionChanged();
6482        }
6483      }
6484    }
6485   
6486    partial void OnDataTypeIdChanging(long value);
6487    partial void OnDataTypeIdChanged();
6488    private long _DataTypeId;
6489    [Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
6490    [DataMember(Order=6)]
6491    public long DataTypeId
6492    {
6493      get { return _DataTypeId; }
6494      set {
6495        if (_DataTypeId != value) {
6496          if (_DataType.HasLoadedOrAssignedValue) {
6497            throw new ForeignKeyReferenceAlreadyHasValueException();
6498          }
6499          OnDataTypeIdChanging(value);
6500          SendPropertyChanging();
6501          _DataTypeId = value;
6502          SendPropertyChanged("DataTypeId");
6503          OnDataTypeIdChanged();
6504        }
6505      }
6506    }
6507   
6508    #endregion
6509   
6510    #region Associations
6511    private EntitySet<ResultBlobValue> _ResultBlobValues;
6512    [Association(Name=@"Result_ResultBlobValue", Storage=@"_ResultBlobValues", ThisKey=@"Id", OtherKey=@"ResultId")]
6513    [DataMember(Order=7, EmitDefaultValue=false)]
6514    public EntitySet<ResultBlobValue> ResultBlobValues
6515    {
6516      get {
6517        if (serializing && !_ResultBlobValues.HasLoadedOrAssignedValues) {
6518          return null;
6519        }
6520        return _ResultBlobValues;
6521      }
6522      set {
6523        _ResultBlobValues.Assign(value);
6524      }
6525    }
6526
6527    private void attach_ResultBlobValues(ResultBlobValue entity)
6528    {
6529      SendPropertyChanging();
6530      entity.Result = this;
6531    }
6532   
6533    private void detach_ResultBlobValues(ResultBlobValue entity)
6534    {
6535      SendPropertyChanging();
6536      entity.Result = null;
6537    }
6538    private EntitySet<ResultBoolValue> _ResultBoolValues;
6539    [Association(Name=@"Result_ResultBoolValue", Storage=@"_ResultBoolValues", ThisKey=@"Id", OtherKey=@"ResultId")]
6540    [DataMember(Order=8, EmitDefaultValue=false)]
6541    public EntitySet<ResultBoolValue> ResultBoolValues
6542    {
6543      get {
6544        if (serializing && !_ResultBoolValues.HasLoadedOrAssignedValues) {
6545          return null;
6546        }
6547        return _ResultBoolValues;
6548      }
6549      set {
6550        _ResultBoolValues.Assign(value);
6551      }
6552    }
6553
6554    private void attach_ResultBoolValues(ResultBoolValue entity)
6555    {
6556      SendPropertyChanging();
6557      entity.Result = this;
6558    }
6559   
6560    private void detach_ResultBoolValues(ResultBoolValue entity)
6561    {
6562      SendPropertyChanging();
6563      entity.Result = null;
6564    }
6565    private EntitySet<ResultFloatValue> _ResultFloatValues;
6566    [Association(Name=@"Result_ResultFloatValue", Storage=@"_ResultFloatValues", ThisKey=@"Id", OtherKey=@"ResultId")]
6567    [DataMember(Order=9, EmitDefaultValue=false)]
6568    public EntitySet<ResultFloatValue> ResultFloatValues
6569    {
6570      get {
6571        if (serializing && !_ResultFloatValues.HasLoadedOrAssignedValues) {
6572          return null;
6573        }
6574        return _ResultFloatValues;
6575      }
6576      set {
6577        _ResultFloatValues.Assign(value);
6578      }
6579    }
6580
6581    private void attach_ResultFloatValues(ResultFloatValue entity)
6582    {
6583      SendPropertyChanging();
6584      entity.Result = this;
6585    }
6586   
6587    private void detach_ResultFloatValues(ResultFloatValue entity)
6588    {
6589      SendPropertyChanging();
6590      entity.Result = null;
6591    }
6592    private EntitySet<ResultIntValue> _ResultIntValues;
6593    [Association(Name=@"Result_ResultIntValue", Storage=@"_ResultIntValues", ThisKey=@"Id", OtherKey=@"ResultId")]
6594    [DataMember(Order=10, EmitDefaultValue=false)]
6595    public EntitySet<ResultIntValue> ResultIntValues
6596    {
6597      get {
6598        if (serializing && !_ResultIntValues.HasLoadedOrAssignedValues) {
6599          return null;
6600        }
6601        return _ResultIntValues;
6602      }
6603      set {
6604        _ResultIntValues.Assign(value);
6605      }
6606    }
6607
6608    private void attach_ResultIntValues(ResultIntValue entity)
6609    {
6610      SendPropertyChanging();
6611      entity.Result = this;
6612    }
6613   
6614    private void detach_ResultIntValues(ResultIntValue entity)
6615    {
6616      SendPropertyChanging();
6617      entity.Result = null;
6618    }
6619    private EntitySet<ResultStringValue> _ResultStringValues;
6620    [Association(Name=@"Result_ResultStringValue", Storage=@"_ResultStringValues", ThisKey=@"Id", OtherKey=@"ResultId")]
6621    [DataMember(Order=11, EmitDefaultValue=false)]
6622    public EntitySet<ResultStringValue> ResultStringValues
6623    {
6624      get {
6625        if (serializing && !_ResultStringValues.HasLoadedOrAssignedValues) {
6626          return null;
6627        }
6628        return _ResultStringValues;
6629      }
6630      set {
6631        _ResultStringValues.Assign(value);
6632      }
6633    }
6634
6635    private void attach_ResultStringValues(ResultStringValue entity)
6636    {
6637      SendPropertyChanging();
6638      entity.Result = this;
6639    }
6640   
6641    private void detach_ResultStringValues(ResultStringValue entity)
6642    {
6643      SendPropertyChanging();
6644      entity.Result = null;
6645    }
6646    private EntityRef<Algorithm> _Algorithm;
6647    [Association(Name=@"Algorithm_Result", Storage=@"_Algorithm", ThisKey=@"AlgorithmId", OtherKey=@"Id", IsForeignKey=true)]
6648    [DataMember(Order=12, EmitDefaultValue=false)]
6649    public Algorithm Algorithm
6650    {
6651      get {
6652        if (serializing && !_Algorithm.HasLoadedOrAssignedValue) {
6653          return null;
6654        }
6655        return _Algorithm.Entity;
6656      }
6657      set {
6658        Algorithm previousValue = _Algorithm.Entity;
6659        if ((previousValue != value) || (!_Algorithm.HasLoadedOrAssignedValue)) {
6660          SendPropertyChanging();
6661          if (previousValue != null) {
6662            _Algorithm.Entity = null;
6663            previousValue.Results.Remove(this);
6664          }
6665          _Algorithm.Entity = value;
6666          if (value != null) {
6667            value.Results.Add(this);
6668            _AlgorithmId = value.Id;
6669          }
6670          else {
6671            _AlgorithmId = default(long);
6672          }
6673          SendPropertyChanged("Algorithm");
6674        }
6675      }
6676    }
6677
6678    private EntityRef<DataType> _DataType;
6679    [Association(Name=@"DataType_Result", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
6680    [DataMember(Order=13, EmitDefaultValue=false)]
6681    public DataType DataType
6682    {
6683      get {
6684        if (serializing && !_DataType.HasLoadedOrAssignedValue) {
6685          return null;
6686        }
6687        return _DataType.Entity;
6688      }
6689      set {
6690        DataType previousValue = _DataType.Entity;
6691        if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
6692          SendPropertyChanging();
6693          if (previousValue != null) {
6694            _DataType.Entity = null;
6695            previousValue.Results.Remove(this);
6696          }
6697          _DataType.Entity = value;
6698          if (value != null) {
6699            value.Results.Add(this);
6700            _DataTypeId = value.Id;
6701          }
6702          else {
6703            _DataTypeId = default(long);
6704          }
6705          SendPropertyChanged("DataType");
6706        }
6707      }
6708    }
6709
6710    #endregion
6711   
6712    #region Serialization
6713    private bool serializing;
6714   
6715    [OnSerializing()]
6716    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
6717    public void OnSerializing(StreamingContext context)
6718    {
6719      serializing = true;
6720    }
6721   
6722    [OnSerialized()]
6723    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
6724    public void OnSerialized(StreamingContext context)
6725    {
6726      serializing = false;
6727    }
6728   
6729    [OnDeserializing()]
6730    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
6731    public  void OnDeserializing(StreamingContext context)
6732    {
6733      Initialize();
6734    }
6735    #endregion
6736  }
6737}
6738
6739namespace HeuristicLab.Services.OKB.DataAccess
6740{
6741  [DataContract(IsReference=true)]
6742  [Table(Name=@"dbo.ResultBlobValue")]
6743[KnownType(typeof(ResultBlobValue))]  public partial class ResultBlobValue : INotifyPropertyChanging, INotifyPropertyChanged
6744  {
6745    #region Property Change Event Handling
6746    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
6747   
6748    public event PropertyChangingEventHandler PropertyChanging;
6749    public event PropertyChangedEventHandler PropertyChanged;
6750   
6751    public virtual void SendPropertyChanging()
6752    {
6753      if (PropertyChanging != null) {
6754        PropertyChanging(this, emptyChangingEventArgs);
6755      }
6756    }
6757     
6758    public virtual void SendPropertyChanged(String propertyName)
6759    {
6760      if (PropertyChanged != null) {
6761        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
6762      }
6763    }
6764    #endregion
6765   
6766    #region Extensibility Method Definitions
6767    partial void OnLoaded();
6768    partial void OnValidate(ChangeAction action);
6769    partial void OnCreated();
6770    #endregion
6771
6772    #region Construction
6773    public ResultBlobValue()
6774    {
6775      Initialize();
6776    }
6777   
6778    private void Initialize()
6779    {
6780      _Result = default(EntityRef<Result>);
6781      _Run = default(EntityRef<Run>);
6782      OnCreated();
6783    }
6784    #endregion
6785
6786    #region Column Mappings
6787    partial void OnResultIdChanging(long value);
6788    partial void OnResultIdChanged();
6789    private long _ResultId;
6790    [Column(Storage=@"_ResultId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
6791    [DataMember(Order=1)]
6792    public long ResultId
6793    {
6794      get { return _ResultId; }
6795      set {
6796        if (_ResultId != value) {
6797          if (_Result.HasLoadedOrAssignedValue) {
6798            throw new ForeignKeyReferenceAlreadyHasValueException();
6799          }
6800          OnResultIdChanging(value);
6801          SendPropertyChanging();
6802          _ResultId = value;
6803          SendPropertyChanged("ResultId");
6804          OnResultIdChanged();
6805        }
6806      }
6807    }
6808   
6809    partial void OnRunIdChanging(long value);
6810    partial void OnRunIdChanged();
6811    private long _RunId;
6812    [Column(Storage=@"_RunId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
6813    [DataMember(Order=2)]
6814    public long RunId
6815    {
6816      get { return _RunId; }
6817      set {
6818        if (_RunId != value) {
6819          if (_Run.HasLoadedOrAssignedValue) {
6820            throw new ForeignKeyReferenceAlreadyHasValueException();
6821          }
6822          OnRunIdChanging(value);
6823          SendPropertyChanging();
6824          _RunId = value;
6825          SendPropertyChanged("RunId");
6826          OnRunIdChanged();
6827        }
6828      }
6829    }
6830   
6831    partial void OnValueChanging(Binary value);
6832    partial void OnValueChanged();
6833    private Binary _Value;
6834    [Column(Storage=@"_Value", DbType=@"VarBinary(MAX) NOT NULL", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
6835    [DataMember(Order=3)]
6836    public Binary Value
6837    {
6838      get { return _Value; }
6839      set {
6840        if (_Value != value) {
6841          OnValueChanging(value);
6842          SendPropertyChanging();
6843          _Value = value;
6844          SendPropertyChanged("Value");
6845          OnValueChanged();
6846        }
6847      }
6848    }
6849   
6850    #endregion
6851   
6852    #region Associations
6853    private EntityRef<Result> _Result;
6854    [Association(Name=@"Result_ResultBlobValue", Storage=@"_Result", ThisKey=@"ResultId", OtherKey=@"Id", IsForeignKey=true)]
6855    [DataMember(Order=4, EmitDefaultValue=false)]
6856    public Result Result
6857    {
6858      get {
6859        return _Result.Entity;
6860      }
6861      set {
6862        Result previousValue = _Result.Entity;
6863        if ((previousValue != value) || (!_Result.HasLoadedOrAssignedValue)) {
6864          SendPropertyChanging();
6865          if (previousValue != null) {
6866            _Result.Entity = null;
6867            previousValue.ResultBlobValues.Remove(this);
6868          }
6869          _Result.Entity = value;
6870          if (value != null) {
6871            value.ResultBlobValues.Add(this);
6872            _ResultId = value.Id;
6873          }
6874          else {
6875            _ResultId = default(long);
6876          }
6877          SendPropertyChanged("Result");
6878        }
6879      }
6880    }
6881
6882    private EntityRef<Run> _Run;
6883    [Association(Name=@"Run_ResultBlobValue", Storage=@"_Run", ThisKey=@"RunId", OtherKey=@"Id", IsForeignKey=true)]
6884    [DataMember(Order=5, EmitDefaultValue=false)]
6885    public Run Run
6886    {
6887      get {
6888        return _Run.Entity;
6889      }
6890      set {
6891        Run previousValue = _Run.Entity;
6892        if ((previousValue != value) || (!_Run.HasLoadedOrAssignedValue)) {
6893          SendPropertyChanging();
6894          if (previousValue != null) {
6895            _Run.Entity = null;
6896            previousValue.ResultBlobValues.Remove(this);
6897          }
6898          _Run.Entity = value;
6899          if (value != null) {
6900            value.ResultBlobValues.Add(this);
6901            _RunId = value.Id;
6902          }
6903          else {
6904            _RunId = default(long);
6905          }
6906          SendPropertyChanged("Run");
6907        }
6908      }
6909    }
6910
6911    #endregion
6912   
6913    #region Serialization
6914    [OnDeserializing()]
6915    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
6916    public  void OnDeserializing(StreamingContext context)
6917    {
6918      Initialize();
6919    }
6920    #endregion
6921  }
6922}
6923
6924namespace HeuristicLab.Services.OKB.DataAccess
6925{
6926  [DataContract(IsReference=true)]
6927  [Table(Name=@"dbo.ResultBoolValue")]
6928[KnownType(typeof(ResultBoolValue))]  public partial class ResultBoolValue : INotifyPropertyChanging, INotifyPropertyChanged
6929  {
6930    #region Property Change Event Handling
6931    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
6932   
6933    public event PropertyChangingEventHandler PropertyChanging;
6934    public event PropertyChangedEventHandler PropertyChanged;
6935   
6936    public virtual void SendPropertyChanging()
6937    {
6938      if (PropertyChanging != null) {
6939        PropertyChanging(this, emptyChangingEventArgs);
6940      }
6941    }
6942     
6943    public virtual void SendPropertyChanged(String propertyName)
6944    {
6945      if (PropertyChanged != null) {
6946        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
6947      }
6948    }
6949    #endregion
6950   
6951    #region Extensibility Method Definitions
6952    partial void OnLoaded();
6953    partial void OnValidate(ChangeAction action);
6954    partial void OnCreated();
6955    #endregion
6956
6957    #region Construction
6958    public ResultBoolValue()
6959    {
6960      Initialize();
6961    }
6962   
6963    private void Initialize()
6964    {
6965      _Result = default(EntityRef<Result>);
6966      _Run = default(EntityRef<Run>);
6967      OnCreated();
6968    }
6969    #endregion
6970
6971    #region Column Mappings
6972    partial void OnResultIdChanging(long value);
6973    partial void OnResultIdChanged();
6974    private long _ResultId;
6975    [Column(Storage=@"_ResultId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
6976    [DataMember(Order=1)]
6977    public long ResultId
6978    {
6979      get { return _ResultId; }
6980      set {
6981        if (_ResultId != value) {
6982          if (_Result.HasLoadedOrAssignedValue) {
6983            throw new ForeignKeyReferenceAlreadyHasValueException();
6984          }
6985          OnResultIdChanging(value);
6986          SendPropertyChanging();
6987          _ResultId = value;
6988          SendPropertyChanged("ResultId");
6989          OnResultIdChanged();
6990        }
6991      }
6992    }
6993   
6994    partial void OnRunIdChanging(long value);
6995    partial void OnRunIdChanged();
6996    private long _RunId;
6997    [Column(Storage=@"_RunId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
6998    [DataMember(Order=2)]
6999    public long RunId
7000    {
7001      get { return _RunId; }
7002      set {
7003        if (_RunId != value) {
7004          if (_Run.HasLoadedOrAssignedValue) {
7005            throw new ForeignKeyReferenceAlreadyHasValueException();
7006          }
7007          OnRunIdChanging(value);
7008          SendPropertyChanging();
7009          _RunId = value;
7010          SendPropertyChanged("RunId");
7011          OnRunIdChanged();
7012        }
7013      }
7014    }
7015   
7016    partial void OnValueChanging(bool value);
7017    partial void OnValueChanged();
7018    private bool _Value;
7019    [Column(Storage=@"_Value", DbType=@"Bit NOT NULL", CanBeNull=false)]
7020    [DataMember(Order=3)]
7021    public bool Value
7022    {
7023      get { return _Value; }
7024      set {
7025        if (_Value != value) {
7026          OnValueChanging(value);
7027          SendPropertyChanging();
7028          _Value = value;
7029          SendPropertyChanged("Value");
7030          OnValueChanged();
7031        }
7032      }
7033    }
7034   
7035    #endregion
7036   
7037    #region Associations
7038    private EntityRef<Result> _Result;
7039    [Association(Name=@"Result_ResultBoolValue", Storage=@"_Result", ThisKey=@"ResultId", OtherKey=@"Id", IsForeignKey=true)]
7040    [DataMember(Order=4, EmitDefaultValue=false)]
7041    public Result Result
7042    {
7043      get {
7044        return _Result.Entity;
7045      }
7046      set {
7047        Result previousValue = _Result.Entity;
7048        if ((previousValue != value) || (!_Result.HasLoadedOrAssignedValue)) {
7049          SendPropertyChanging();
7050          if (previousValue != null) {
7051            _Result.Entity = null;
7052            previousValue.ResultBoolValues.Remove(this);
7053          }
7054          _Result.Entity = value;
7055          if (value != null) {
7056            value.ResultBoolValues.Add(this);
7057            _ResultId = value.Id;
7058          }
7059          else {
7060            _ResultId = default(long);
7061          }
7062          SendPropertyChanged("Result");
7063        }
7064      }
7065    }
7066
7067    private EntityRef<Run> _Run;
7068    [Association(Name=@"Run_ResultBoolValue", Storage=@"_Run", ThisKey=@"RunId", OtherKey=@"Id", IsForeignKey=true)]
7069    [DataMember(Order=5, EmitDefaultValue=false)]
7070    public Run Run
7071    {
7072      get {
7073        return _Run.Entity;
7074      }
7075      set {
7076        Run previousValue = _Run.Entity;
7077        if ((previousValue != value) || (!_Run.HasLoadedOrAssignedValue)) {
7078          SendPropertyChanging();
7079          if (previousValue != null) {
7080            _Run.Entity = null;
7081            previousValue.ResultBoolValues.Remove(this);
7082          }
7083          _Run.Entity = value;
7084          if (value != null) {
7085            value.ResultBoolValues.Add(this);
7086            _RunId = value.Id;
7087          }
7088          else {
7089            _RunId = default(long);
7090          }
7091          SendPropertyChanged("Run");
7092        }
7093      }
7094    }
7095
7096    #endregion
7097   
7098    #region Serialization
7099    [OnDeserializing()]
7100    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
7101    public  void OnDeserializing(StreamingContext context)
7102    {
7103      Initialize();
7104    }
7105    #endregion
7106  }
7107}
7108
7109namespace HeuristicLab.Services.OKB.DataAccess
7110{
7111  [DataContract(IsReference=true)]
7112  [Table(Name=@"dbo.ResultFloatValue")]
7113[KnownType(typeof(ResultFloatValue))] public partial class ResultFloatValue : INotifyPropertyChanging, INotifyPropertyChanged
7114  {
7115    #region Property Change Event Handling
7116    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
7117   
7118    public event PropertyChangingEventHandler PropertyChanging;
7119    public event PropertyChangedEventHandler PropertyChanged;
7120   
7121    public virtual void SendPropertyChanging()
7122    {
7123      if (PropertyChanging != null) {
7124        PropertyChanging(this, emptyChangingEventArgs);
7125      }
7126    }
7127     
7128    public virtual void SendPropertyChanged(String propertyName)
7129    {
7130      if (PropertyChanged != null) {
7131        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
7132      }
7133    }
7134    #endregion
7135   
7136    #region Extensibility Method Definitions
7137    partial void OnLoaded();
7138    partial void OnValidate(ChangeAction action);
7139    partial void OnCreated();
7140    #endregion
7141
7142    #region Construction
7143    public ResultFloatValue()
7144    {
7145      Initialize();
7146    }
7147   
7148    private void Initialize()
7149    {
7150      _Result = default(EntityRef<Result>);
7151      _Run = default(EntityRef<Run>);
7152      OnCreated();
7153    }
7154    #endregion
7155
7156    #region Column Mappings
7157    partial void OnResultIdChanging(long value);
7158    partial void OnResultIdChanged();
7159    private long _ResultId;
7160    [Column(Storage=@"_ResultId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
7161    [DataMember(Order=1)]
7162    public long ResultId
7163    {
7164      get { return _ResultId; }
7165      set {
7166        if (_ResultId != value) {
7167          if (_Result.HasLoadedOrAssignedValue) {
7168            throw new ForeignKeyReferenceAlreadyHasValueException();
7169          }
7170          OnResultIdChanging(value);
7171          SendPropertyChanging();
7172          _ResultId = value;
7173          SendPropertyChanged("ResultId");
7174          OnResultIdChanged();
7175        }
7176      }
7177    }
7178   
7179    partial void OnRunIdChanging(long value);
7180    partial void OnRunIdChanged();
7181    private long _RunId;
7182    [Column(Storage=@"_RunId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
7183    [DataMember(Order=2)]
7184    public long RunId
7185    {
7186      get { return _RunId; }
7187      set {
7188        if (_RunId != value) {
7189          if (_Run.HasLoadedOrAssignedValue) {
7190            throw new ForeignKeyReferenceAlreadyHasValueException();
7191          }
7192          OnRunIdChanging(value);
7193          SendPropertyChanging();
7194          _RunId = value;
7195          SendPropertyChanged("RunId");
7196          OnRunIdChanged();
7197        }
7198      }
7199    }
7200   
7201    partial void OnValueChanging(double value);
7202    partial void OnValueChanged();
7203    private double _Value;
7204    [Column(Storage=@"_Value", DbType=@"Float NOT NULL", CanBeNull=false)]
7205    [DataMember(Order=3)]
7206    public double Value
7207    {
7208      get { return _Value; }
7209      set {
7210        if (_Value != value) {
7211          OnValueChanging(value);
7212          SendPropertyChanging();
7213          _Value = value;
7214          SendPropertyChanged("Value");
7215          OnValueChanged();
7216        }
7217      }
7218    }
7219   
7220    #endregion
7221   
7222    #region Associations
7223    private EntityRef<Result> _Result;
7224    [Association(Name=@"Result_ResultFloatValue", Storage=@"_Result", ThisKey=@"ResultId", OtherKey=@"Id", IsForeignKey=true)]
7225    [DataMember(Order=4, EmitDefaultValue=false)]
7226    public Result Result
7227    {
7228      get {
7229        return _Result.Entity;
7230      }
7231      set {
7232        Result previousValue = _Result.Entity;
7233        if ((previousValue != value) || (!_Result.HasLoadedOrAssignedValue)) {
7234          SendPropertyChanging();
7235          if (previousValue != null) {
7236            _Result.Entity = null;
7237            previousValue.ResultFloatValues.Remove(this);
7238          }
7239          _Result.Entity = value;
7240          if (value != null) {
7241            value.ResultFloatValues.Add(this);
7242            _ResultId = value.Id;
7243          }
7244          else {
7245            _ResultId = default(long);
7246          }
7247          SendPropertyChanged("Result");
7248        }
7249      }
7250    }
7251
7252    private EntityRef<Run> _Run;
7253    [Association(Name=@"Run_ResultFloatValue", Storage=@"_Run", ThisKey=@"RunId", OtherKey=@"Id", IsForeignKey=true)]
7254    [DataMember(Order=5, EmitDefaultValue=false)]
7255    public Run Run
7256    {
7257      get {
7258        return _Run.Entity;
7259      }
7260      set {
7261        Run previousValue = _Run.Entity;
7262        if ((previousValue != value) || (!_Run.HasLoadedOrAssignedValue)) {
7263          SendPropertyChanging();
7264          if (previousValue != null) {
7265            _Run.Entity = null;
7266            previousValue.ResultFloatValues.Remove(this);
7267          }
7268          _Run.Entity = value;
7269          if (value != null) {
7270            value.ResultFloatValues.Add(this);
7271            _RunId = value.Id;
7272          }
7273          else {
7274            _RunId = default(long);
7275          }
7276          SendPropertyChanged("Run");
7277        }
7278      }
7279    }
7280
7281    #endregion
7282   
7283    #region Serialization
7284    [OnDeserializing()]
7285    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
7286    public  void OnDeserializing(StreamingContext context)
7287    {
7288      Initialize();
7289    }
7290    #endregion
7291  }
7292}
7293
7294namespace HeuristicLab.Services.OKB.DataAccess
7295{
7296  [DataContract(IsReference=true)]
7297  [Table(Name=@"dbo.ResultIntValue")]
7298[KnownType(typeof(ResultIntValue))] public partial class ResultIntValue : INotifyPropertyChanging, INotifyPropertyChanged
7299  {
7300    #region Property Change Event Handling
7301    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
7302   
7303    public event PropertyChangingEventHandler PropertyChanging;
7304    public event PropertyChangedEventHandler PropertyChanged;
7305   
7306    public virtual void SendPropertyChanging()
7307    {
7308      if (PropertyChanging != null) {
7309        PropertyChanging(this, emptyChangingEventArgs);
7310      }
7311    }
7312     
7313    public virtual void SendPropertyChanged(String propertyName)
7314    {
7315      if (PropertyChanged != null) {
7316        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
7317      }
7318    }
7319    #endregion
7320   
7321    #region Extensibility Method Definitions
7322    partial void OnLoaded();
7323    partial void OnValidate(ChangeAction action);
7324    partial void OnCreated();
7325    #endregion
7326
7327    #region Construction
7328    public ResultIntValue()
7329    {
7330      Initialize();
7331    }
7332   
7333    private void Initialize()
7334    {
7335      _Result = default(EntityRef<Result>);
7336      _Run = default(EntityRef<Run>);
7337      OnCreated();
7338    }
7339    #endregion
7340
7341    #region Column Mappings
7342    partial void OnResultIdChanging(long value);
7343    partial void OnResultIdChanged();
7344    private long _ResultId;
7345    [Column(Storage=@"_ResultId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
7346    [DataMember(Order=1)]
7347    public long ResultId
7348    {
7349      get { return _ResultId; }
7350      set {
7351        if (_ResultId != value) {
7352          if (_Result.HasLoadedOrAssignedValue) {
7353            throw new ForeignKeyReferenceAlreadyHasValueException();
7354          }
7355          OnResultIdChanging(value);
7356          SendPropertyChanging();
7357          _ResultId = value;
7358          SendPropertyChanged("ResultId");
7359          OnResultIdChanged();
7360        }
7361      }
7362    }
7363   
7364    partial void OnRunIdChanging(long value);
7365    partial void OnRunIdChanged();
7366    private long _RunId;
7367    [Column(Storage=@"_RunId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
7368    [DataMember(Order=2)]
7369    public long RunId
7370    {
7371      get { return _RunId; }
7372      set {
7373        if (_RunId != value) {
7374          if (_Run.HasLoadedOrAssignedValue) {
7375            throw new ForeignKeyReferenceAlreadyHasValueException();
7376          }
7377          OnRunIdChanging(value);
7378          SendPropertyChanging();
7379          _RunId = value;
7380          SendPropertyChanged("RunId");
7381          OnRunIdChanged();
7382        }
7383      }
7384    }
7385   
7386    partial void OnValueChanging(int value);
7387    partial void OnValueChanged();
7388    private int _Value;
7389    [Column(Storage=@"_Value", DbType=@"Int NOT NULL", CanBeNull=false)]
7390    [DataMember(Order=3)]
7391    public int Value
7392    {
7393      get { return _Value; }
7394      set {
7395        if (_Value != value) {
7396          OnValueChanging(value);
7397          SendPropertyChanging();
7398          _Value = value;
7399          SendPropertyChanged("Value");
7400          OnValueChanged();
7401        }
7402      }
7403    }
7404   
7405    #endregion
7406   
7407    #region Associations
7408    private EntityRef<Result> _Result;
7409    [Association(Name=@"Result_ResultIntValue", Storage=@"_Result", ThisKey=@"ResultId", OtherKey=@"Id", IsForeignKey=true)]
7410    [DataMember(Order=4, EmitDefaultValue=false)]
7411    public Result Result
7412    {
7413      get {
7414        return _Result.Entity;
7415      }
7416      set {
7417        Result previousValue = _Result.Entity;
7418        if ((previousValue != value) || (!_Result.HasLoadedOrAssignedValue)) {
7419          SendPropertyChanging();
7420          if (previousValue != null) {
7421            _Result.Entity = null;
7422            previousValue.ResultIntValues.Remove(this);
7423          }
7424          _Result.Entity = value;
7425          if (value != null) {
7426            value.ResultIntValues.Add(this);
7427            _ResultId = value.Id;
7428          }
7429          else {
7430            _ResultId = default(long);
7431          }
7432          SendPropertyChanged("Result");
7433        }
7434      }
7435    }
7436
7437    private EntityRef<Run> _Run;
7438    [Association(Name=@"Run_ResultIntValue", Storage=@"_Run", ThisKey=@"RunId", OtherKey=@"Id", IsForeignKey=true)]
7439    [DataMember(Order=5, EmitDefaultValue=false)]
7440    public Run Run
7441    {
7442      get {
7443        return _Run.Entity;
7444      }
7445      set {
7446        Run previousValue = _Run.Entity;
7447        if ((previousValue != value) || (!_Run.HasLoadedOrAssignedValue)) {
7448          SendPropertyChanging();
7449          if (previousValue != null) {
7450            _Run.Entity = null;
7451            previousValue.ResultIntValues.Remove(this);
7452          }
7453          _Run.Entity = value;
7454          if (value != null) {
7455            value.ResultIntValues.Add(this);
7456            _RunId = value.Id;
7457          }
7458          else {
7459            _RunId = default(long);
7460          }
7461          SendPropertyChanged("Run");
7462        }
7463      }
7464    }
7465
7466    #endregion
7467   
7468    #region Serialization
7469    [OnDeserializing()]
7470    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
7471    public  void OnDeserializing(StreamingContext context)
7472    {
7473      Initialize();
7474    }
7475    #endregion
7476  }
7477}
7478
7479namespace HeuristicLab.Services.OKB.DataAccess
7480{
7481  [DataContract(IsReference=true)]
7482  [Table(Name=@"dbo.ResultStringValue")]
7483[KnownType(typeof(ResultStringValue))]  public partial class ResultStringValue : INotifyPropertyChanging, INotifyPropertyChanged
7484  {
7485    #region Property Change Event Handling
7486    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
7487   
7488    public event PropertyChangingEventHandler PropertyChanging;
7489    public event PropertyChangedEventHandler PropertyChanged;
7490   
7491    public virtual void SendPropertyChanging()
7492    {
7493      if (PropertyChanging != null) {
7494        PropertyChanging(this, emptyChangingEventArgs);
7495      }
7496    }
7497     
7498    public virtual void SendPropertyChanged(String propertyName)
7499    {
7500      if (PropertyChanged != null) {
7501        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
7502      }
7503    }
7504    #endregion
7505   
7506    #region Extensibility Method Definitions
7507    partial void OnLoaded();
7508    partial void OnValidate(ChangeAction action);
7509    partial void OnCreated();
7510    #endregion
7511
7512    #region Construction
7513    public ResultStringValue()
7514    {
7515      Initialize();
7516    }
7517   
7518    private void Initialize()
7519    {
7520      _Result = default(EntityRef<Result>);
7521      _Run = default(EntityRef<Run>);
7522      OnCreated();
7523    }
7524    #endregion
7525
7526    #region Column Mappings
7527    partial void OnResultIdChanging(long value);
7528    partial void OnResultIdChanged();
7529    private long _ResultId;
7530    [Column(Storage=@"_ResultId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
7531    [DataMember(Order=1)]
7532    public long ResultId
7533    {
7534      get { return _ResultId; }
7535      set {
7536        if (_ResultId != value) {
7537          if (_Result.HasLoadedOrAssignedValue) {
7538            throw new ForeignKeyReferenceAlreadyHasValueException();
7539          }
7540          OnResultIdChanging(value);
7541          SendPropertyChanging();
7542          _ResultId = value;
7543          SendPropertyChanged("ResultId");
7544          OnResultIdChanged();
7545        }
7546      }
7547    }
7548   
7549    partial void OnRunIdChanging(long value);
7550    partial void OnRunIdChanged();
7551    private long _RunId;
7552    [Column(Storage=@"_RunId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
7553    [DataMember(Order=2)]
7554    public long RunId
7555    {
7556      get { return _RunId; }
7557      set {
7558        if (_RunId != value) {
7559          if (_Run.HasLoadedOrAssignedValue) {
7560            throw new ForeignKeyReferenceAlreadyHasValueException();
7561          }
7562          OnRunIdChanging(value);
7563          SendPropertyChanging();
7564          _RunId = value;
7565          SendPropertyChanged("RunId");
7566          OnRunIdChanged();
7567        }
7568      }
7569    }
7570   
7571    partial void OnValueChanging(string value);
7572    partial void OnValueChanged();
7573    private string _Value;
7574    [Column(Storage=@"_Value", DbType=@"NVarChar(MAX) NOT NULL", CanBeNull=false)]
7575    [DataMember(Order=3)]
7576    public string Value
7577    {
7578      get { return _Value; }
7579      set {
7580        if (_Value != value) {
7581          OnValueChanging(value);
7582          SendPropertyChanging();
7583          _Value = value;
7584          SendPropertyChanged("Value");
7585          OnValueChanged();
7586        }
7587      }
7588    }
7589   
7590    #endregion
7591   
7592    #region Associations
7593    private EntityRef<Result> _Result;
7594    [Association(Name=@"Result_ResultStringValue", Storage=@"_Result", ThisKey=@"ResultId", OtherKey=@"Id", IsForeignKey=true)]
7595    [DataMember(Order=4, EmitDefaultValue=false)]
7596    public Result Result
7597    {
7598      get {
7599        return _Result.Entity;
7600      }
7601      set {
7602        Result previousValue = _Result.Entity;
7603        if ((previousValue != value) || (!_Result.HasLoadedOrAssignedValue)) {
7604          SendPropertyChanging();
7605          if (previousValue != null) {
7606            _Result.Entity = null;
7607            previousValue.ResultStringValues.Remove(this);
7608          }
7609          _Result.Entity = value;
7610          if (value != null) {
7611            value.ResultStringValues.Add(this);
7612            _ResultId = value.Id;
7613          }
7614          else {
7615            _ResultId = default(long);
7616          }
7617          SendPropertyChanged("Result");
7618        }
7619      }
7620    }
7621
7622    private EntityRef<Run> _Run;
7623    [Association(Name=@"Run_ResultStringValue", Storage=@"_Run", ThisKey=@"RunId", OtherKey=@"Id", IsForeignKey=true)]
7624    [DataMember(Order=5, EmitDefaultValue=false)]
7625    public Run Run
7626    {
7627      get {
7628        return _Run.Entity;
7629      }
7630      set {
7631        Run previousValue = _Run.Entity;
7632        if ((previousValue != value) || (!_Run.HasLoadedOrAssignedValue)) {
7633          SendPropertyChanging();
7634          if (previousValue != null) {
7635            _Run.Entity = null;
7636            previousValue.ResultStringValues.Remove(this);
7637          }
7638          _Run.Entity = value;
7639          if (value != null) {
7640            value.ResultStringValues.Add(this);
7641            _RunId = value.Id;
7642          }
7643          else {
7644            _RunId = default(long);
7645          }
7646          SendPropertyChanged("Run");
7647        }
7648      }
7649    }
7650
7651    #endregion
7652   
7653    #region Serialization
7654    [OnDeserializing()]
7655    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
7656    public  void OnDeserializing(StreamingContext context)
7657    {
7658      Initialize();
7659    }
7660    #endregion
7661  }
7662}
7663
7664namespace HeuristicLab.Services.OKB.DataAccess
7665{
7666  [DataContract(IsReference=true)]
7667  [Table(Name=@"dbo.Client")]
7668[KnownType(typeof(Client))] public partial class Client : INotifyPropertyChanging, INotifyPropertyChanged
7669  {
7670    #region Property Change Event Handling
7671    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
7672   
7673    public event PropertyChangingEventHandler PropertyChanging;
7674    public event PropertyChangedEventHandler PropertyChanged;
7675   
7676    public virtual void SendPropertyChanging()
7677    {
7678      if (PropertyChanging != null) {
7679        PropertyChanging(this, emptyChangingEventArgs);
7680      }
7681    }
7682     
7683    public virtual void SendPropertyChanged(String propertyName)
7684    {
7685      if (PropertyChanged != null) {
7686        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
7687      }
7688    }
7689    #endregion
7690   
7691    #region Extensibility Method Definitions
7692    partial void OnLoaded();
7693    partial void OnValidate(ChangeAction action);
7694    partial void OnCreated();
7695    #endregion
7696
7697    #region Construction
7698    public Client()
7699    {
7700      Initialize();
7701    }
7702   
7703    private void Initialize()
7704    {
7705      _Runs = new EntitySet<Run>(attach_Runs, detach_Runs);
7706      OnCreated();
7707    }
7708    #endregion
7709
7710    #region Column Mappings
7711    partial void OnIdChanging(Guid value);
7712    partial void OnIdChanged();
7713    private Guid _Id;
7714    [Column(Storage=@"_Id", DbType=@"UniqueIdentifier NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
7715    [DataMember(Order=1)]
7716    public Guid Id
7717    {
7718      get { return _Id; }
7719      set {
7720        if (_Id != value) {
7721          OnIdChanging(value);
7722          SendPropertyChanging();
7723          _Id = value;
7724          SendPropertyChanged("Id");
7725          OnIdChanged();
7726        }
7727      }
7728    }
7729   
7730    partial void OnNameChanging(string value);
7731    partial void OnNameChanged();
7732    private string _Name;
7733    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
7734    [DataMember(Order=2)]
7735    public string Name
7736    {
7737      get { return _Name; }
7738      set {
7739        if (_Name != value) {
7740          OnNameChanging(value);
7741          SendPropertyChanging();
7742          _Name = value;
7743          SendPropertyChanged("Name");
7744          OnNameChanged();
7745        }
7746      }
7747    }
7748   
7749    #endregion
7750   
7751    #region Associations
7752    private EntitySet<Run> _Runs;
7753    [Association(Name=@"Client_Run", Storage=@"_Runs", ThisKey=@"Id", OtherKey=@"ClientId")]
7754    [DataMember(Order=3, EmitDefaultValue=false)]
7755    public EntitySet<Run> Runs
7756    {
7757      get {
7758        if (serializing && !_Runs.HasLoadedOrAssignedValues) {
7759          return null;
7760        }
7761        return _Runs;
7762      }
7763      set {
7764        _Runs.Assign(value);
7765      }
7766    }
7767
7768    private void attach_Runs(Run entity)
7769    {
7770      SendPropertyChanging();
7771      entity.Client = this;
7772    }
7773   
7774    private void detach_Runs(Run entity)
7775    {
7776      SendPropertyChanging();
7777      entity.Client = null;
7778    }
7779    #endregion
7780   
7781    #region Serialization
7782    private bool serializing;
7783   
7784    [OnSerializing()]
7785    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
7786    public void OnSerializing(StreamingContext context)
7787    {
7788      serializing = true;
7789    }
7790   
7791    [OnSerialized()]
7792    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
7793    public void OnSerialized(StreamingContext context)
7794    {
7795      serializing = false;
7796    }
7797   
7798    [OnDeserializing()]
7799    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
7800    public  void OnDeserializing(StreamingContext context)
7801    {
7802      Initialize();
7803    }
7804    #endregion
7805  }
7806}
7807
7808namespace HeuristicLab.Services.OKB.DataAccess
7809{
7810  [DataContract(IsReference=true)]
7811  [Table(Name=@"dbo.DataType")]
7812[KnownType(typeof(DataType))] public partial class DataType : INotifyPropertyChanging, INotifyPropertyChanged
7813  {
7814    #region Property Change Event Handling
7815    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
7816   
7817    public event PropertyChangingEventHandler PropertyChanging;
7818    public event PropertyChangedEventHandler PropertyChanged;
7819   
7820    public virtual void SendPropertyChanging()
7821    {
7822      if (PropertyChanging != null) {
7823        PropertyChanging(this, emptyChangingEventArgs);
7824      }
7825    }
7826     
7827    public virtual void SendPropertyChanged(String propertyName)
7828    {
7829      if (PropertyChanged != null) {
7830        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
7831      }
7832    }
7833    #endregion
7834   
7835    #region Extensibility Method Definitions
7836    partial void OnLoaded();
7837    partial void OnValidate(ChangeAction action);
7838    partial void OnCreated();
7839    #endregion
7840
7841    #region Construction
7842    public DataType()
7843    {
7844      Initialize();
7845    }
7846   
7847    private void Initialize()
7848    {
7849      _AlgorithmParameters = new EntitySet<AlgorithmParameter>(attach_AlgorithmParameters, detach_AlgorithmParameters);
7850      _ProblemParameters = new EntitySet<ProblemParameter>(attach_ProblemParameters, detach_ProblemParameters);
7851      _Results = new EntitySet<Result>(attach_Results, detach_Results);
7852      _ProblemCharacteristics = new EntitySet<ProblemCharacteristic>(attach_ProblemCharacteristics, detach_ProblemCharacteristics);
7853      OnCreated();
7854    }
7855    #endregion
7856
7857    #region Column Mappings
7858    partial void OnIdChanging(long value);
7859    partial void OnIdChanged();
7860    private long _Id;
7861    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
7862    [DataMember(Order=1)]
7863    public long Id
7864    {
7865      get { return _Id; }
7866      set {
7867        if (_Id != value) {
7868          OnIdChanging(value);
7869          SendPropertyChanging();
7870          _Id = value;
7871          SendPropertyChanged("Id");
7872          OnIdChanged();
7873        }
7874      }
7875    }
7876   
7877    partial void OnSqlNameChanging(string value);
7878    partial void OnSqlNameChanged();
7879    private string _SqlName;
7880    [Column(Storage=@"_SqlName", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
7881    [DataMember(Order=2)]
7882    public string SqlName
7883    {
7884      get { return _SqlName; }
7885      set {
7886        if (_SqlName != value) {
7887          OnSqlNameChanging(value);
7888          SendPropertyChanging();
7889          _SqlName = value;
7890          SendPropertyChanged("SqlName");
7891          OnSqlNameChanged();
7892        }
7893      }
7894    }
7895   
7896    partial void OnClrNameChanging(string value);
7897    partial void OnClrNameChanged();
7898    private string _ClrName;
7899    [Column(Storage=@"_ClrName", DbType=@"NVarChar(MAX) NOT NULL", CanBeNull=false)]
7900    [DataMember(Order=3)]
7901    public string ClrName
7902    {
7903      get { return _ClrName; }
7904      set {
7905        if (_ClrName != value) {
7906          OnClrNameChanging(value);
7907          SendPropertyChanging();
7908          _ClrName = value;
7909          SendPropertyChanged("ClrName");
7910          OnClrNameChanged();
7911        }
7912      }
7913    }
7914   
7915    #endregion
7916   
7917    #region Associations
7918    private EntitySet<AlgorithmParameter> _AlgorithmParameters;
7919    [Association(Name=@"DataType_AlgorithmParameter", Storage=@"_AlgorithmParameters", ThisKey=@"Id", OtherKey=@"DataTypeId")]
7920    [DataMember(Order=4, EmitDefaultValue=false)]
7921    public EntitySet<AlgorithmParameter> AlgorithmParameters
7922    {
7923      get {
7924        if (serializing && !_AlgorithmParameters.HasLoadedOrAssignedValues) {
7925          return null;
7926        }
7927        return _AlgorithmParameters;
7928      }
7929      set {
7930        _AlgorithmParameters.Assign(value);
7931      }
7932    }
7933
7934    private void attach_AlgorithmParameters(AlgorithmParameter entity)
7935    {
7936      SendPropertyChanging();
7937      entity.DataType = this;
7938    }
7939   
7940    private void detach_AlgorithmParameters(AlgorithmParameter entity)
7941    {
7942      SendPropertyChanging();
7943      entity.DataType = null;
7944    }
7945    private EntitySet<ProblemParameter> _ProblemParameters;
7946    [Association(Name=@"DataType_ProblemParameter", Storage=@"_ProblemParameters", ThisKey=@"Id", OtherKey=@"DataTypeId")]
7947    [DataMember(Order=5, EmitDefaultValue=false)]
7948    public EntitySet<ProblemParameter> ProblemParameters
7949    {
7950      get {
7951        if (serializing && !_ProblemParameters.HasLoadedOrAssignedValues) {
7952          return null;
7953        }
7954        return _ProblemParameters;
7955      }
7956      set {
7957        _ProblemParameters.Assign(value);
7958      }
7959    }
7960
7961    private void attach_ProblemParameters(ProblemParameter entity)
7962    {
7963      SendPropertyChanging();
7964      entity.DataType = this;
7965    }
7966   
7967    private void detach_ProblemParameters(ProblemParameter entity)
7968    {
7969      SendPropertyChanging();
7970      entity.DataType = null;
7971    }
7972    private EntitySet<Result> _Results;
7973    [Association(Name=@"DataType_Result", Storage=@"_Results", ThisKey=@"Id", OtherKey=@"DataTypeId")]
7974    [DataMember(Order=6, EmitDefaultValue=false)]
7975    public EntitySet<Result> Results
7976    {
7977      get {
7978        if (serializing && !_Results.HasLoadedOrAssignedValues) {
7979          return null;
7980        }
7981        return _Results;
7982      }
7983      set {
7984        _Results.Assign(value);
7985      }
7986    }
7987
7988    private void attach_Results(Result entity)
7989    {
7990      SendPropertyChanging();
7991      entity.DataType = this;
7992    }
7993   
7994    private void detach_Results(Result entity)
7995    {
7996      SendPropertyChanging();
7997      entity.DataType = null;
7998    }
7999    private EntitySet<ProblemCharacteristic> _ProblemCharacteristics;
8000    [Association(Name=@"DataType_ProblemCharacteristic", Storage=@"_ProblemCharacteristics", ThisKey=@"Id", OtherKey=@"DataTypeId")]
8001    [DataMember(Order=7, EmitDefaultValue=false)]
8002    public EntitySet<ProblemCharacteristic> ProblemCharacteristics
8003    {
8004      get {
8005        if (serializing && !_ProblemCharacteristics.HasLoadedOrAssignedValues) {
8006          return null;
8007        }
8008        return _ProblemCharacteristics;
8009      }
8010      set {
8011        _ProblemCharacteristics.Assign(value);
8012      }
8013    }
8014
8015    private void attach_ProblemCharacteristics(ProblemCharacteristic entity)
8016    {
8017      SendPropertyChanging();
8018      entity.DataType = this;
8019    }
8020   
8021    private void detach_ProblemCharacteristics(ProblemCharacteristic entity)
8022    {
8023      SendPropertyChanging();
8024      entity.DataType = null;
8025    }
8026    #endregion
8027   
8028    #region Serialization
8029    private bool serializing;
8030   
8031    [OnSerializing()]
8032    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
8033    public void OnSerializing(StreamingContext context)
8034    {
8035      serializing = true;
8036    }
8037   
8038    [OnSerialized()]
8039    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
8040    public void OnSerialized(StreamingContext context)
8041    {
8042      serializing = false;
8043    }
8044   
8045    [OnDeserializing()]
8046    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
8047    public  void OnDeserializing(StreamingContext context)
8048    {
8049      Initialize();
8050    }
8051    #endregion
8052  }
8053}
8054
8055namespace HeuristicLab.Services.OKB.DataAccess
8056{
8057  [DataContract(IsReference=true)]
8058  [Table(Name=@"dbo.ProblemCharacteristic")]
8059[KnownType(typeof(ProblemCharacteristic))]  public partial class ProblemCharacteristic : INotifyPropertyChanging, INotifyPropertyChanged
8060  {
8061    #region Property Change Event Handling
8062    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
8063   
8064    public event PropertyChangingEventHandler PropertyChanging;
8065    public event PropertyChangedEventHandler PropertyChanged;
8066   
8067    public virtual void SendPropertyChanging()
8068    {
8069      if (PropertyChanging != null) {
8070        PropertyChanging(this, emptyChangingEventArgs);
8071      }
8072    }
8073     
8074    public virtual void SendPropertyChanged(String propertyName)
8075    {
8076      if (PropertyChanged != null) {
8077        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
8078      }
8079    }
8080    #endregion
8081   
8082    #region Extensibility Method Definitions
8083    partial void OnLoaded();
8084    partial void OnValidate(ChangeAction action);
8085    partial void OnCreated();
8086    #endregion
8087
8088    #region Construction
8089    public ProblemCharacteristic()
8090    {
8091      Initialize();
8092    }
8093   
8094    private void Initialize()
8095    {
8096      _ProblemCharacteristicFloatValues = new EntitySet<ProblemCharacteristicFloatValue>(attach_ProblemCharacteristicFloatValues, detach_ProblemCharacteristicFloatValues);
8097      _ProblemCharacteristicIntValues = new EntitySet<ProblemCharacteristicIntValue>(attach_ProblemCharacteristicIntValues, detach_ProblemCharacteristicIntValues);
8098      _ProblemCharacteristicStringValues = new EntitySet<ProblemCharacteristicStringValue>(attach_ProblemCharacteristicStringValues, detach_ProblemCharacteristicStringValues);
8099      _DataType = default(EntityRef<DataType>);
8100      OnCreated();
8101    }
8102    #endregion
8103
8104    #region Column Mappings
8105    partial void OnIdChanging(long value);
8106    partial void OnIdChanged();
8107    private long _Id;
8108    [Column(Storage=@"_Id", AutoSync=AutoSync.OnInsert, DbType=@"BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
8109    [DataMember(Order=1)]
8110    public long Id
8111    {
8112      get { return _Id; }
8113      set {
8114        if (_Id != value) {
8115          OnIdChanging(value);
8116          SendPropertyChanging();
8117          _Id = value;
8118          SendPropertyChanged("Id");
8119          OnIdChanged();
8120        }
8121      }
8122    }
8123   
8124    partial void OnNameChanging(string value);
8125    partial void OnNameChanged();
8126    private string _Name;
8127    [Column(Storage=@"_Name", DbType=@"NVarChar(200) NOT NULL", CanBeNull=false)]
8128    [DataMember(Order=2)]
8129    public string Name
8130    {
8131      get { return _Name; }
8132      set {
8133        if (_Name != value) {
8134          OnNameChanging(value);
8135          SendPropertyChanging();
8136          _Name = value;
8137          SendPropertyChanged("Name");
8138          OnNameChanged();
8139        }
8140      }
8141    }
8142   
8143    partial void OnDescriptionChanging(string value);
8144    partial void OnDescriptionChanged();
8145    private string _Description;
8146    [Column(Storage=@"_Description", DbType=@"NVarChar(MAX)")]
8147    [DataMember(Order=3)]
8148    public string Description
8149    {
8150      get { return _Description; }
8151      set {
8152        if (_Description != value) {
8153          OnDescriptionChanging(value);
8154          SendPropertyChanging();
8155          _Description = value;
8156          SendPropertyChanged("Description");
8157          OnDescriptionChanged();
8158        }
8159      }
8160    }
8161   
8162    partial void OnDataTypeIdChanging(long value);
8163    partial void OnDataTypeIdChanged();
8164    private long _DataTypeId;
8165    [Column(Storage=@"_DataTypeId", DbType=@"BigInt NOT NULL", CanBeNull=false)]
8166    [DataMember(Order=4)]
8167    public long DataTypeId
8168    {
8169      get { return _DataTypeId; }
8170      set {
8171        if (_DataTypeId != value) {
8172          if (_DataType.HasLoadedOrAssignedValue) {
8173            throw new ForeignKeyReferenceAlreadyHasValueException();
8174          }
8175          OnDataTypeIdChanging(value);
8176          SendPropertyChanging();
8177          _DataTypeId = value;
8178          SendPropertyChanged("DataTypeId");
8179          OnDataTypeIdChanged();
8180        }
8181      }
8182    }
8183   
8184    #endregion
8185   
8186    #region Associations
8187    private EntitySet<ProblemCharacteristicFloatValue> _ProblemCharacteristicFloatValues;
8188    [Association(Name=@"ProblemCharacteristic_ProblemCharacteristicFloatValue", Storage=@"_ProblemCharacteristicFloatValues", ThisKey=@"Id", OtherKey=@"ProblemCharacteristicId")]
8189    [DataMember(Order=5, EmitDefaultValue=false)]
8190    public EntitySet<ProblemCharacteristicFloatValue> ProblemCharacteristicFloatValues
8191    {
8192      get {
8193        if (serializing && !_ProblemCharacteristicFloatValues.HasLoadedOrAssignedValues) {
8194          return null;
8195        }
8196        return _ProblemCharacteristicFloatValues;
8197      }
8198      set {
8199        _ProblemCharacteristicFloatValues.Assign(value);
8200      }
8201    }
8202
8203    private void attach_ProblemCharacteristicFloatValues(ProblemCharacteristicFloatValue entity)
8204    {
8205      SendPropertyChanging();
8206      entity.ProblemCharacteristic = this;
8207    }
8208   
8209    private void detach_ProblemCharacteristicFloatValues(ProblemCharacteristicFloatValue entity)
8210    {
8211      SendPropertyChanging();
8212      entity.ProblemCharacteristic = null;
8213    }
8214    private EntitySet<ProblemCharacteristicIntValue> _ProblemCharacteristicIntValues;
8215    [Association(Name=@"ProblemCharacteristic_ProblemCharacteristicIntValue", Storage=@"_ProblemCharacteristicIntValues", ThisKey=@"Id", OtherKey=@"ProblemCharacteristicId")]
8216    [DataMember(Order=6, EmitDefaultValue=false)]
8217    public EntitySet<ProblemCharacteristicIntValue> ProblemCharacteristicIntValues
8218    {
8219      get {
8220        if (serializing && !_ProblemCharacteristicIntValues.HasLoadedOrAssignedValues) {
8221          return null;
8222        }
8223        return _ProblemCharacteristicIntValues;
8224      }
8225      set {
8226        _ProblemCharacteristicIntValues.Assign(value);
8227      }
8228    }
8229
8230    private void attach_ProblemCharacteristicIntValues(ProblemCharacteristicIntValue entity)
8231    {
8232      SendPropertyChanging();
8233      entity.ProblemCharacteristic = this;
8234    }
8235   
8236    private void detach_ProblemCharacteristicIntValues(ProblemCharacteristicIntValue entity)
8237    {
8238      SendPropertyChanging();
8239      entity.ProblemCharacteristic = null;
8240    }
8241    private EntitySet<ProblemCharacteristicStringValue> _ProblemCharacteristicStringValues;
8242    [Association(Name=@"ProblemCharacteristic_ProblemCharacteristicStringValue", Storage=@"_ProblemCharacteristicStringValues", ThisKey=@"Id", OtherKey=@"ProblemCharacteristicId")]
8243    [DataMember(Order=7, EmitDefaultValue=false)]
8244    public EntitySet<ProblemCharacteristicStringValue> ProblemCharacteristicStringValues
8245    {
8246      get {
8247        if (serializing && !_ProblemCharacteristicStringValues.HasLoadedOrAssignedValues) {
8248          return null;
8249        }
8250        return _ProblemCharacteristicStringValues;
8251      }
8252      set {
8253        _ProblemCharacteristicStringValues.Assign(value);
8254      }
8255    }
8256
8257    private void attach_ProblemCharacteristicStringValues(ProblemCharacteristicStringValue entity)
8258    {
8259      SendPropertyChanging();
8260      entity.ProblemCharacteristic = this;
8261    }
8262   
8263    private void detach_ProblemCharacteristicStringValues(ProblemCharacteristicStringValue entity)
8264    {
8265      SendPropertyChanging();
8266      entity.ProblemCharacteristic = null;
8267    }
8268    private EntityRef<DataType> _DataType;
8269    [Association(Name=@"DataType_ProblemCharacteristic", Storage=@"_DataType", ThisKey=@"DataTypeId", OtherKey=@"Id", IsForeignKey=true)]
8270    [DataMember(Order=8, EmitDefaultValue=false)]
8271    public DataType DataType
8272    {
8273      get {
8274        if (serializing && !_DataType.HasLoadedOrAssignedValue) {
8275          return null;
8276        }
8277        return _DataType.Entity;
8278      }
8279      set {
8280        DataType previousValue = _DataType.Entity;
8281        if ((previousValue != value) || (!_DataType.HasLoadedOrAssignedValue)) {
8282          SendPropertyChanging();
8283          if (previousValue != null) {
8284            _DataType.Entity = null;
8285            previousValue.ProblemCharacteristics.Remove(this);
8286          }
8287          _DataType.Entity = value;
8288          if (value != null) {
8289            value.ProblemCharacteristics.Add(this);
8290            _DataTypeId = value.Id;
8291          }
8292          else {
8293            _DataTypeId = default(long);
8294          }
8295          SendPropertyChanged("DataType");
8296        }
8297      }
8298    }
8299
8300    #endregion
8301   
8302    #region Serialization
8303    private bool serializing;
8304   
8305    [OnSerializing()]
8306    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
8307    public void OnSerializing(StreamingContext context)
8308    {
8309      serializing = true;
8310    }
8311   
8312    [OnSerialized()]
8313    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
8314    public void OnSerialized(StreamingContext context)
8315    {
8316      serializing = false;
8317    }
8318   
8319    [OnDeserializing()]
8320    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
8321    public  void OnDeserializing(StreamingContext context)
8322    {
8323      Initialize();
8324    }
8325    #endregion
8326  }
8327}
8328
8329namespace HeuristicLab.Services.OKB.DataAccess
8330{
8331  [DataContract(IsReference=true)]
8332  [Table(Name=@"dbo.ProblemCharacteristicFloatValue")]
8333[KnownType(typeof(ProblemCharacteristicFloatValue))]  public partial class ProblemCharacteristicFloatValue : INotifyPropertyChanging, INotifyPropertyChanged
8334  {
8335    #region Property Change Event Handling
8336    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
8337   
8338    public event PropertyChangingEventHandler PropertyChanging;
8339    public event PropertyChangedEventHandler PropertyChanged;
8340   
8341    public virtual void SendPropertyChanging()
8342    {
8343      if (PropertyChanging != null) {
8344        PropertyChanging(this, emptyChangingEventArgs);
8345      }
8346    }
8347     
8348    public virtual void SendPropertyChanged(String propertyName)
8349    {
8350      if (PropertyChanged != null) {
8351        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
8352      }
8353    }
8354    #endregion
8355   
8356    #region Extensibility Method Definitions
8357    partial void OnLoaded();
8358    partial void OnValidate(ChangeAction action);
8359    partial void OnCreated();
8360    #endregion
8361
8362    #region Construction
8363    public ProblemCharacteristicFloatValue()
8364    {
8365      Initialize();
8366    }
8367   
8368    private void Initialize()
8369    {
8370      _Problem = default(EntityRef<Problem>);
8371      _ProblemCharacteristic = default(EntityRef<ProblemCharacteristic>);
8372      OnCreated();
8373    }
8374    #endregion
8375
8376    #region Column Mappings
8377    partial void OnProblemCharacteristicIdChanging(long value);
8378    partial void OnProblemCharacteristicIdChanged();
8379    private long _ProblemCharacteristicId;
8380    [Column(Storage=@"_ProblemCharacteristicId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
8381    [DataMember(Order=1)]
8382    public long ProblemCharacteristicId
8383    {
8384      get { return _ProblemCharacteristicId; }
8385      set {
8386        if (_ProblemCharacteristicId != value) {
8387          if (_ProblemCharacteristic.HasLoadedOrAssignedValue) {
8388            throw new ForeignKeyReferenceAlreadyHasValueException();
8389          }
8390          OnProblemCharacteristicIdChanging(value);
8391          SendPropertyChanging();
8392          _ProblemCharacteristicId = value;
8393          SendPropertyChanged("ProblemCharacteristicId");
8394          OnProblemCharacteristicIdChanged();
8395        }
8396      }
8397    }
8398   
8399    partial void OnProblemIdChanging(long value);
8400    partial void OnProblemIdChanged();
8401    private long _ProblemId;
8402    [Column(Storage=@"_ProblemId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
8403    [DataMember(Order=2)]
8404    public long ProblemId
8405    {
8406      get { return _ProblemId; }
8407      set {
8408        if (_ProblemId != value) {
8409          if (_Problem.HasLoadedOrAssignedValue) {
8410            throw new ForeignKeyReferenceAlreadyHasValueException();
8411          }
8412          OnProblemIdChanging(value);
8413          SendPropertyChanging();
8414          _ProblemId = value;
8415          SendPropertyChanged("ProblemId");
8416          OnProblemIdChanged();
8417        }
8418      }
8419    }
8420   
8421    partial void OnValueChanging(double value);
8422    partial void OnValueChanged();
8423    private double _Value;
8424    [Column(Storage=@"_Value", DbType=@"Float NOT NULL", CanBeNull=false)]
8425    [DataMember(Order=3)]
8426    public double Value
8427    {
8428      get { return _Value; }
8429      set {
8430        if (_Value != value) {
8431          OnValueChanging(value);
8432          SendPropertyChanging();
8433          _Value = value;
8434          SendPropertyChanged("Value");
8435          OnValueChanged();
8436        }
8437      }
8438    }
8439   
8440    #endregion
8441   
8442    #region Associations
8443    private EntityRef<Problem> _Problem;
8444    [Association(Name=@"Problem_ProblemCharacteristicFloatValue", Storage=@"_Problem", ThisKey=@"ProblemId", OtherKey=@"Id", IsForeignKey=true)]
8445    [DataMember(Order=4, EmitDefaultValue=false)]
8446    public Problem Problem
8447    {
8448      get {
8449        return _Problem.Entity;
8450      }
8451      set {
8452        Problem previousValue = _Problem.Entity;
8453        if ((previousValue != value) || (!_Problem.HasLoadedOrAssignedValue)) {
8454          SendPropertyChanging();
8455          if (previousValue != null) {
8456            _Problem.Entity = null;
8457            previousValue.ProblemCharacteristicFloatValues.Remove(this);
8458          }
8459          _Problem.Entity = value;
8460          if (value != null) {
8461            value.ProblemCharacteristicFloatValues.Add(this);
8462            _ProblemId = value.Id;
8463          }
8464          else {
8465            _ProblemId = default(long);
8466          }
8467          SendPropertyChanged("Problem");
8468        }
8469      }
8470    }
8471
8472    private EntityRef<ProblemCharacteristic> _ProblemCharacteristic;
8473    [Association(Name=@"ProblemCharacteristic_ProblemCharacteristicFloatValue", Storage=@"_ProblemCharacteristic", ThisKey=@"ProblemCharacteristicId", OtherKey=@"Id", IsForeignKey=true)]
8474    [DataMember(Order=5, EmitDefaultValue=false)]
8475    public ProblemCharacteristic ProblemCharacteristic
8476    {
8477      get {
8478        return _ProblemCharacteristic.Entity;
8479      }
8480      set {
8481        ProblemCharacteristic previousValue = _ProblemCharacteristic.Entity;
8482        if ((previousValue != value) || (!_ProblemCharacteristic.HasLoadedOrAssignedValue)) {
8483          SendPropertyChanging();
8484          if (previousValue != null) {
8485            _ProblemCharacteristic.Entity = null;
8486            previousValue.ProblemCharacteristicFloatValues.Remove(this);
8487          }
8488          _ProblemCharacteristic.Entity = value;
8489          if (value != null) {
8490            value.ProblemCharacteristicFloatValues.Add(this);
8491            _ProblemCharacteristicId = value.Id;
8492          }
8493          else {
8494            _ProblemCharacteristicId = default(long);
8495          }
8496          SendPropertyChanged("ProblemCharacteristic");
8497        }
8498      }
8499    }
8500
8501    #endregion
8502   
8503    #region Serialization
8504    [OnDeserializing()]
8505    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
8506    public  void OnDeserializing(StreamingContext context)
8507    {
8508      Initialize();
8509    }
8510    #endregion
8511  }
8512}
8513
8514namespace HeuristicLab.Services.OKB.DataAccess
8515{
8516  [DataContract(IsReference=true)]
8517  [Table(Name=@"dbo.ProblemCharacteristicIntValue")]
8518[KnownType(typeof(ProblemCharacteristicIntValue))]  public partial class ProblemCharacteristicIntValue : INotifyPropertyChanging, INotifyPropertyChanged
8519  {
8520    #region Property Change Event Handling
8521    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
8522   
8523    public event PropertyChangingEventHandler PropertyChanging;
8524    public event PropertyChangedEventHandler PropertyChanged;
8525   
8526    public virtual void SendPropertyChanging()
8527    {
8528      if (PropertyChanging != null) {
8529        PropertyChanging(this, emptyChangingEventArgs);
8530      }
8531    }
8532     
8533    public virtual void SendPropertyChanged(String propertyName)
8534    {
8535      if (PropertyChanged != null) {
8536        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
8537      }
8538    }
8539    #endregion
8540   
8541    #region Extensibility Method Definitions
8542    partial void OnLoaded();
8543    partial void OnValidate(ChangeAction action);
8544    partial void OnCreated();
8545    #endregion
8546
8547    #region Construction
8548    public ProblemCharacteristicIntValue()
8549    {
8550      Initialize();
8551    }
8552   
8553    private void Initialize()
8554    {
8555      _Problem = default(EntityRef<Problem>);
8556      _ProblemCharacteristic = default(EntityRef<ProblemCharacteristic>);
8557      OnCreated();
8558    }
8559    #endregion
8560
8561    #region Column Mappings
8562    partial void OnProblemCharacteristicIdChanging(long value);
8563    partial void OnProblemCharacteristicIdChanged();
8564    private long _ProblemCharacteristicId;
8565    [Column(Storage=@"_ProblemCharacteristicId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
8566    [DataMember(Order=1)]
8567    public long ProblemCharacteristicId
8568    {
8569      get { return _ProblemCharacteristicId; }
8570      set {
8571        if (_ProblemCharacteristicId != value) {
8572          if (_ProblemCharacteristic.HasLoadedOrAssignedValue) {
8573            throw new ForeignKeyReferenceAlreadyHasValueException();
8574          }
8575          OnProblemCharacteristicIdChanging(value);
8576          SendPropertyChanging();
8577          _ProblemCharacteristicId = value;
8578          SendPropertyChanged("ProblemCharacteristicId");
8579          OnProblemCharacteristicIdChanged();
8580        }
8581      }
8582    }
8583   
8584    partial void OnProblemIdChanging(long value);
8585    partial void OnProblemIdChanged();
8586    private long _ProblemId;
8587    [Column(Storage=@"_ProblemId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
8588    [DataMember(Order=2)]
8589    public long ProblemId
8590    {
8591      get { return _ProblemId; }
8592      set {
8593        if (_ProblemId != value) {
8594          if (_Problem.HasLoadedOrAssignedValue) {
8595            throw new ForeignKeyReferenceAlreadyHasValueException();
8596          }
8597          OnProblemIdChanging(value);
8598          SendPropertyChanging();
8599          _ProblemId = value;
8600          SendPropertyChanged("ProblemId");
8601          OnProblemIdChanged();
8602        }
8603      }
8604    }
8605   
8606    partial void OnValueChanging(int value);
8607    partial void OnValueChanged();
8608    private int _Value;
8609    [Column(Storage=@"_Value", DbType=@"Int NOT NULL", CanBeNull=false)]
8610    [DataMember(Order=3)]
8611    public int Value
8612    {
8613      get { return _Value; }
8614      set {
8615        if (_Value != value) {
8616          OnValueChanging(value);
8617          SendPropertyChanging();
8618          _Value = value;
8619          SendPropertyChanged("Value");
8620          OnValueChanged();
8621        }
8622      }
8623    }
8624   
8625    #endregion
8626   
8627    #region Associations
8628    private EntityRef<Problem> _Problem;
8629    [Association(Name=@"Problem_ProblemCharacteristicIntValue", Storage=@"_Problem", ThisKey=@"ProblemId", OtherKey=@"Id", IsForeignKey=true)]
8630    [DataMember(Order=4, EmitDefaultValue=false)]
8631    public Problem Problem
8632    {
8633      get {
8634        return _Problem.Entity;
8635      }
8636      set {
8637        Problem previousValue = _Problem.Entity;
8638        if ((previousValue != value) || (!_Problem.HasLoadedOrAssignedValue)) {
8639          SendPropertyChanging();
8640          if (previousValue != null) {
8641            _Problem.Entity = null;
8642            previousValue.ProblemCharacteristicIntValues.Remove(this);
8643          }
8644          _Problem.Entity = value;
8645          if (value != null) {
8646            value.ProblemCharacteristicIntValues.Add(this);
8647            _ProblemId = value.Id;
8648          }
8649          else {
8650            _ProblemId = default(long);
8651          }
8652          SendPropertyChanged("Problem");
8653        }
8654      }
8655    }
8656
8657    private EntityRef<ProblemCharacteristic> _ProblemCharacteristic;
8658    [Association(Name=@"ProblemCharacteristic_ProblemCharacteristicIntValue", Storage=@"_ProblemCharacteristic", ThisKey=@"ProblemCharacteristicId", OtherKey=@"Id", IsForeignKey=true)]
8659    [DataMember(Order=5, EmitDefaultValue=false)]
8660    public ProblemCharacteristic ProblemCharacteristic
8661    {
8662      get {
8663        return _ProblemCharacteristic.Entity;
8664      }
8665      set {
8666        ProblemCharacteristic previousValue = _ProblemCharacteristic.Entity;
8667        if ((previousValue != value) || (!_ProblemCharacteristic.HasLoadedOrAssignedValue)) {
8668          SendPropertyChanging();
8669          if (previousValue != null) {
8670            _ProblemCharacteristic.Entity = null;
8671            previousValue.ProblemCharacteristicIntValues.Remove(this);
8672          }
8673          _ProblemCharacteristic.Entity = value;
8674          if (value != null) {
8675            value.ProblemCharacteristicIntValues.Add(this);
8676            _ProblemCharacteristicId = value.Id;
8677          }
8678          else {
8679            _ProblemCharacteristicId = default(long);
8680          }
8681          SendPropertyChanged("ProblemCharacteristic");
8682        }
8683      }
8684    }
8685
8686    #endregion
8687   
8688    #region Serialization
8689    [OnDeserializing()]
8690    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
8691    public  void OnDeserializing(StreamingContext context)
8692    {
8693      Initialize();
8694    }
8695    #endregion
8696  }
8697}
8698
8699namespace HeuristicLab.Services.OKB.DataAccess
8700{
8701  [DataContract(IsReference=true)]
8702  [Table(Name=@"dbo.ProblemCharacteristicStringValue")]
8703[KnownType(typeof(ProblemCharacteristicStringValue))] public partial class ProblemCharacteristicStringValue : INotifyPropertyChanging, INotifyPropertyChanged
8704  {
8705    #region Property Change Event Handling
8706    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
8707   
8708    public event PropertyChangingEventHandler PropertyChanging;
8709    public event PropertyChangedEventHandler PropertyChanged;
8710   
8711    public virtual void SendPropertyChanging()
8712    {
8713      if (PropertyChanging != null) {
8714        PropertyChanging(this, emptyChangingEventArgs);
8715      }
8716    }
8717     
8718    public virtual void SendPropertyChanged(String propertyName)
8719    {
8720      if (PropertyChanged != null) {
8721        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
8722      }
8723    }
8724    #endregion
8725   
8726    #region Extensibility Method Definitions
8727    partial void OnLoaded();
8728    partial void OnValidate(ChangeAction action);
8729    partial void OnCreated();
8730    #endregion
8731
8732    #region Construction
8733    public ProblemCharacteristicStringValue()
8734    {
8735      Initialize();
8736    }
8737   
8738    private void Initialize()
8739    {
8740      _Problem = default(EntityRef<Problem>);
8741      _ProblemCharacteristic = default(EntityRef<ProblemCharacteristic>);
8742      OnCreated();
8743    }
8744    #endregion
8745
8746    #region Column Mappings
8747    partial void OnProblemCharacteristicIdChanging(long value);
8748    partial void OnProblemCharacteristicIdChanged();
8749    private long _ProblemCharacteristicId;
8750    [Column(Storage=@"_ProblemCharacteristicId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
8751    [DataMember(Order=1)]
8752    public long ProblemCharacteristicId
8753    {
8754      get { return _ProblemCharacteristicId; }
8755      set {
8756        if (_ProblemCharacteristicId != value) {
8757          if (_ProblemCharacteristic.HasLoadedOrAssignedValue) {
8758            throw new ForeignKeyReferenceAlreadyHasValueException();
8759          }
8760          OnProblemCharacteristicIdChanging(value);
8761          SendPropertyChanging();
8762          _ProblemCharacteristicId = value;
8763          SendPropertyChanged("ProblemCharacteristicId");
8764          OnProblemCharacteristicIdChanged();
8765        }
8766      }
8767    }
8768   
8769    partial void OnProblemIdChanging(long value);
8770    partial void OnProblemIdChanged();
8771    private long _ProblemId;
8772    [Column(Storage=@"_ProblemId", DbType=@"BigInt NOT NULL", IsPrimaryKey=true, UpdateCheck=UpdateCheck.Never)]
8773    [DataMember(Order=2)]
8774    public long ProblemId
8775    {
8776      get { return _ProblemId; }
8777      set {
8778        if (_ProblemId != value) {
8779          if (_Problem.HasLoadedOrAssignedValue) {
8780            throw new ForeignKeyReferenceAlreadyHasValueException();
8781          }
8782          OnProblemIdChanging(value);
8783          SendPropertyChanging();
8784          _ProblemId = value;
8785          SendPropertyChanged("ProblemId");
8786          OnProblemIdChanged();
8787        }
8788      }
8789    }
8790   
8791    partial void OnValueChanging(string value);
8792    partial void OnValueChanged();
8793    private string _Value;
8794    [Column(Storage=@"_Value", DbType=@"NVarChar(MAX) NOT NULL", CanBeNull=false)]
8795    [DataMember(Order=3)]
8796    public string Value
8797    {
8798      get { return _Value; }
8799      set {
8800        if (_Value != value) {
8801          OnValueChanging(value);
8802          SendPropertyChanging();
8803          _Value = value;
8804          SendPropertyChanged("Value");
8805          OnValueChanged();
8806        }
8807      }
8808    }
8809   
8810    #endregion
8811   
8812    #region Associations
8813    private EntityRef<Problem> _Problem;
8814    [Association(Name=@"Problem_ProblemCharacteristicStringValue", Storage=@"_Problem", ThisKey=@"ProblemId", OtherKey=@"Id", IsForeignKey=true)]
8815    [DataMember(Order=4, EmitDefaultValue=false)]
8816    public Problem Problem
8817    {
8818      get {
8819        return _Problem.Entity;
8820      }
8821      set {
8822        Problem previousValue = _Problem.Entity;
8823        if ((previousValue != value) || (!_Problem.HasLoadedOrAssignedValue)) {
8824          SendPropertyChanging();
8825          if (previousValue != null) {
8826            _Problem.Entity = null;
8827            previousValue.ProblemCharacteristicStringValues.Remove(this);
8828          }
8829          _Problem.Entity = value;
8830          if (value != null) {
8831            value.ProblemCharacteristicStringValues.Add(this);
8832            _ProblemId = value.Id;
8833          }
8834          else {
8835            _ProblemId = default(long);
8836          }
8837          SendPropertyChanged("Problem");
8838        }
8839      }
8840    }
8841
8842    private EntityRef<ProblemCharacteristic> _ProblemCharacteristic;
8843    [Association(Name=@"ProblemCharacteristic_ProblemCharacteristicStringValue", Storage=@"_ProblemCharacteristic", ThisKey=@"ProblemCharacteristicId", OtherKey=@"Id", IsForeignKey=true)]
8844    [DataMember(Order=5, EmitDefaultValue=false)]
8845    public ProblemCharacteristic ProblemCharacteristic
8846    {
8847      get {
8848        return _ProblemCharacteristic.Entity;
8849      }
8850      set {
8851        ProblemCharacteristic previousValue = _ProblemCharacteristic.Entity;
8852        if ((previousValue != value) || (!_ProblemCharacteristic.HasLoadedOrAssignedValue)) {
8853          SendPropertyChanging();
8854          if (previousValue != null) {
8855            _ProblemCharacteristic.Entity = null;
8856            previousValue.ProblemCharacteristicStringValues.Remove(this);
8857          }
8858          _ProblemCharacteristic.Entity = value;
8859          if (value != null) {
8860            value.ProblemCharacteristicStringValues.Add(this);
8861            _ProblemCharacteristicId = value.Id;
8862          }
8863          else {
8864            _ProblemCharacteristicId = default(long);
8865          }
8866          SendPropertyChanged("ProblemCharacteristic");
8867        }
8868      }
8869    }
8870
8871    #endregion
8872   
8873    #region Serialization
8874    [OnDeserializing()]
8875    [EditorBrowsableAttribute(EditorBrowsableState.Never)]
8876    public  void OnDeserializing(StreamingContext context)
8877    {
8878      Initialize();
8879    }
8880    #endregion
8881  }
8882}
8883#pragma warning restore 1591
Note: See TracBrowser for help on using the repository browser.