Free cookie consent management tool by TermsFeed Policy Generator

source: stable/HeuristicLab.Services.OKB.DataAccess/3.3/OKB.designer.cs @ 18235

Last change on this file since 18235 was 15082, checked in by gkronber, 7 years ago

#2588 merged r13682, r13683, r13684, r13690:13693, r13709, r13746 from trunk to stable
File size: 107.5 KB
Line 
1#pragma warning disable 1591
2//------------------------------------------------------------------------------
3// <auto-generated>
4//     This code was generated by a tool.
5//     Runtime Version:4.0.30319.34209
6//
7//     Changes to this file may cause incorrect behavior and will be lost if
8//     the code is regenerated.
9// </auto-generated>
10//------------------------------------------------------------------------------
11
12namespace HeuristicLab.Services.OKB.DataAccess
13{
14  using System.Data.Linq;
15  using System.Data.Linq.Mapping;
16  using System.Data;
17  using System.Collections.Generic;
18  using System.Reflection;
19  using System.Linq;
20  using System.Linq.Expressions;
21  using System.ComponentModel;
22  using System;
23 
24 
25  [global::System.Data.Linq.Mapping.DatabaseAttribute(Name="HeuristicLab.OKB")]
26  public partial class OKBDataContext : System.Data.Linq.DataContext
27  {
28   
29    private static System.Data.Linq.Mapping.MappingSource mappingSource = new AttributeMappingSource();
30   
31    #region Extensibility Method Definitions
32    partial void OnCreated();
33    partial void InsertAlgorithmClass(AlgorithmClass instance);
34    partial void UpdateAlgorithmClass(AlgorithmClass instance);
35    partial void DeleteAlgorithmClass(AlgorithmClass instance);
36    partial void InsertProblemClass(ProblemClass instance);
37    partial void UpdateProblemClass(ProblemClass instance);
38    partial void DeleteProblemClass(ProblemClass instance);
39    partial void InsertAlgorithmUser(AlgorithmUser instance);
40    partial void UpdateAlgorithmUser(AlgorithmUser instance);
41    partial void DeleteAlgorithmUser(AlgorithmUser instance);
42    partial void InsertProblemUser(ProblemUser instance);
43    partial void UpdateProblemUser(ProblemUser instance);
44    partial void DeleteProblemUser(ProblemUser instance);
45    partial void InsertPlatform(Platform instance);
46    partial void UpdatePlatform(Platform instance);
47    partial void DeletePlatform(Platform instance);
48    partial void InsertDataType(DataType instance);
49    partial void UpdateDataType(DataType instance);
50    partial void DeleteDataType(DataType instance);
51    partial void InsertValueName(ValueName instance);
52    partial void UpdateValueName(ValueName instance);
53    partial void DeleteValueName(ValueName instance);
54    partial void InsertAlgorithm(Algorithm instance);
55    partial void UpdateAlgorithm(Algorithm instance);
56    partial void DeleteAlgorithm(Algorithm instance);
57    partial void InsertProblem(Problem instance);
58    partial void UpdateProblem(Problem instance);
59    partial void DeleteProblem(Problem instance);
60    partial void InsertBinaryData(BinaryData instance);
61    partial void UpdateBinaryData(BinaryData instance);
62    partial void DeleteBinaryData(BinaryData instance);
63    partial void InsertRun(Run instance);
64    partial void UpdateRun(Run instance);
65    partial void DeleteRun(Run instance);
66    partial void InsertValue(Value instance);
67    partial void UpdateValue(Value instance);
68    partial void DeleteValue(Value instance);
69    partial void InsertCharacteristic(Characteristic instance);
70    partial void UpdateCharacteristic(Characteristic instance);
71    partial void DeleteCharacteristic(Characteristic instance);
72    partial void InsertCharacteristicValue(CharacteristicValue instance);
73    partial void UpdateCharacteristicValue(CharacteristicValue instance);
74    partial void DeleteCharacteristicValue(CharacteristicValue instance);
75    partial void InsertSingleObjectiveSolution(SingleObjectiveSolution instance);
76    partial void UpdateSingleObjectiveSolution(SingleObjectiveSolution instance);
77    partial void DeleteSingleObjectiveSolution(SingleObjectiveSolution instance);
78    #endregion
79   
80    public OKBDataContext() :
81        base(global::HeuristicLab.Services.OKB.DataAccess.Properties.Settings.Default.OKBConnectionString, mappingSource)
82    {
83      OnCreated();
84    }
85   
86    public OKBDataContext(string connection) :
87        base(connection, mappingSource)
88    {
89      OnCreated();
90    }
91   
92    public OKBDataContext(System.Data.IDbConnection connection) :
93        base(connection, mappingSource)
94    {
95      OnCreated();
96    }
97   
98    public OKBDataContext(string connection, System.Data.Linq.Mapping.MappingSource mappingSource) :
99        base(connection, mappingSource)
100    {
101      OnCreated();
102    }
103   
104    public OKBDataContext(System.Data.IDbConnection connection, System.Data.Linq.Mapping.MappingSource mappingSource) :
105        base(connection, mappingSource)
106    {
107      OnCreated();
108    }
109   
110    public System.Data.Linq.Table<AlgorithmClass> AlgorithmClasses
111    {
112      get
113      {
114        return this.GetTable<AlgorithmClass>();
115      }
116    }
117   
118    public System.Data.Linq.Table<ProblemClass> ProblemClasses
119    {
120      get
121      {
122        return this.GetTable<ProblemClass>();
123      }
124    }
125   
126    public System.Data.Linq.Table<AlgorithmUser> AlgorithmUsers
127    {
128      get
129      {
130        return this.GetTable<AlgorithmUser>();
131      }
132    }
133   
134    public System.Data.Linq.Table<ProblemUser> ProblemUsers
135    {
136      get
137      {
138        return this.GetTable<ProblemUser>();
139      }
140    }
141   
142    public System.Data.Linq.Table<Platform> Platforms
143    {
144      get
145      {
146        return this.GetTable<Platform>();
147      }
148    }
149   
150    public System.Data.Linq.Table<DataType> DataTypes
151    {
152      get
153      {
154        return this.GetTable<DataType>();
155      }
156    }
157   
158    public System.Data.Linq.Table<ValueName> ValueNames
159    {
160      get
161      {
162        return this.GetTable<ValueName>();
163      }
164    }
165   
166    public System.Data.Linq.Table<Algorithm> Algorithms
167    {
168      get
169      {
170        return this.GetTable<Algorithm>();
171      }
172    }
173   
174    public System.Data.Linq.Table<Problem> Problems
175    {
176      get
177      {
178        return this.GetTable<Problem>();
179      }
180    }
181   
182    public System.Data.Linq.Table<BinaryData> BinaryDatas
183    {
184      get
185      {
186        return this.GetTable<BinaryData>();
187      }
188    }
189   
190    public System.Data.Linq.Table<Run> Runs
191    {
192      get
193      {
194        return this.GetTable<Run>();
195      }
196    }
197   
198    public System.Data.Linq.Table<Value> Values
199    {
200      get
201      {
202        return this.GetTable<Value>();
203      }
204    }
205   
206    public System.Data.Linq.Table<Characteristic> Characteristics
207    {
208      get
209      {
210        return this.GetTable<Characteristic>();
211      }
212    }
213   
214    public System.Data.Linq.Table<CharacteristicValue> CharacteristicValues
215    {
216      get
217      {
218        return this.GetTable<CharacteristicValue>();
219      }
220    }
221   
222    public System.Data.Linq.Table<SingleObjectiveSolution> SingleObjectiveSolutions
223    {
224      get
225      {
226        return this.GetTable<SingleObjectiveSolution>();
227      }
228    }
229  }
230 
231  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.AlgorithmClass")]
232  public partial class AlgorithmClass : INotifyPropertyChanging, INotifyPropertyChanged
233  {
234   
235    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
236   
237    private long _Id;
238   
239    private string _Name;
240   
241    private string _Description;
242   
243    private EntitySet<Algorithm> _Algorithms;
244   
245    #region Extensibility Method Definitions
246    partial void OnLoaded();
247    partial void OnValidate(System.Data.Linq.ChangeAction action);
248    partial void OnCreated();
249    partial void OnIdChanging(long value);
250    partial void OnIdChanged();
251    partial void OnNameChanging(string value);
252    partial void OnNameChanged();
253    partial void OnDescriptionChanging(string value);
254    partial void OnDescriptionChanged();
255    #endregion
256   
257    public AlgorithmClass()
258    {
259      this._Algorithms = new EntitySet<Algorithm>(new Action<Algorithm>(this.attach_Algorithms), new Action<Algorithm>(this.detach_Algorithms));
260      OnCreated();
261    }
262   
263    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true)]
264    public long Id
265    {
266      get
267      {
268        return this._Id;
269      }
270      set
271      {
272        if ((this._Id != value))
273        {
274          this.OnIdChanging(value);
275          this.SendPropertyChanging();
276          this._Id = value;
277          this.SendPropertyChanged("Id");
278          this.OnIdChanged();
279        }
280      }
281    }
282   
283    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(200) NOT NULL", CanBeNull=false)]
284    public string Name
285    {
286      get
287      {
288        return this._Name;
289      }
290      set
291      {
292        if ((this._Name != value))
293        {
294          this.OnNameChanging(value);
295          this.SendPropertyChanging();
296          this._Name = value;
297          this.SendPropertyChanged("Name");
298          this.OnNameChanged();
299        }
300      }
301    }
302   
303    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Description", DbType="NVarChar(MAX)")]
304    public string Description
305    {
306      get
307      {
308        return this._Description;
309      }
310      set
311      {
312        if ((this._Description != value))
313        {
314          this.OnDescriptionChanging(value);
315          this.SendPropertyChanging();
316          this._Description = value;
317          this.SendPropertyChanged("Description");
318          this.OnDescriptionChanged();
319        }
320      }
321    }
322   
323    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="AlgorithmClass_Algorithm", Storage="_Algorithms", ThisKey="Id", OtherKey="AlgorithmClassId")]
324    public EntitySet<Algorithm> Algorithms
325    {
326      get
327      {
328        return this._Algorithms;
329      }
330      set
331      {
332        this._Algorithms.Assign(value);
333      }
334    }
335   
336    public event PropertyChangingEventHandler PropertyChanging;
337   
338    public event PropertyChangedEventHandler PropertyChanged;
339   
340    protected virtual void SendPropertyChanging()
341    {
342      if ((this.PropertyChanging != null))
343      {
344        this.PropertyChanging(this, emptyChangingEventArgs);
345      }
346    }
347   
348    protected virtual void SendPropertyChanged(String propertyName)
349    {
350      if ((this.PropertyChanged != null))
351      {
352        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
353      }
354    }
355   
356    private void attach_Algorithms(Algorithm entity)
357    {
358      this.SendPropertyChanging();
359      entity.AlgorithmClass = this;
360    }
361   
362    private void detach_Algorithms(Algorithm entity)
363    {
364      this.SendPropertyChanging();
365      entity.AlgorithmClass = null;
366    }
367  }
368 
369  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ProblemClass")]
370  public partial class ProblemClass : INotifyPropertyChanging, INotifyPropertyChanged
371  {
372   
373    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
374   
375    private long _Id;
376   
377    private string _Name;
378   
379    private string _Description;
380   
381    private EntitySet<Problem> _Problems;
382   
383    #region Extensibility Method Definitions
384    partial void OnLoaded();
385    partial void OnValidate(System.Data.Linq.ChangeAction action);
386    partial void OnCreated();
387    partial void OnIdChanging(long value);
388    partial void OnIdChanged();
389    partial void OnNameChanging(string value);
390    partial void OnNameChanged();
391    partial void OnDescriptionChanging(string value);
392    partial void OnDescriptionChanged();
393    #endregion
394   
395    public ProblemClass()
396    {
397      this._Problems = new EntitySet<Problem>(new Action<Problem>(this.attach_Problems), new Action<Problem>(this.detach_Problems));
398      OnCreated();
399    }
400   
401    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true)]
402    public long Id
403    {
404      get
405      {
406        return this._Id;
407      }
408      set
409      {
410        if ((this._Id != value))
411        {
412          this.OnIdChanging(value);
413          this.SendPropertyChanging();
414          this._Id = value;
415          this.SendPropertyChanged("Id");
416          this.OnIdChanged();
417        }
418      }
419    }
420   
421    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(200) NOT NULL", CanBeNull=false)]
422    public string Name
423    {
424      get
425      {
426        return this._Name;
427      }
428      set
429      {
430        if ((this._Name != value))
431        {
432          this.OnNameChanging(value);
433          this.SendPropertyChanging();
434          this._Name = value;
435          this.SendPropertyChanged("Name");
436          this.OnNameChanged();
437        }
438      }
439    }
440   
441    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Description", DbType="NVarChar(MAX)")]
442    public string Description
443    {
444      get
445      {
446        return this._Description;
447      }
448      set
449      {
450        if ((this._Description != value))
451        {
452          this.OnDescriptionChanging(value);
453          this.SendPropertyChanging();
454          this._Description = value;
455          this.SendPropertyChanged("Description");
456          this.OnDescriptionChanged();
457        }
458      }
459    }
460   
461    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="ProblemClass_Problem", Storage="_Problems", ThisKey="Id", OtherKey="ProblemClassId")]
462    public EntitySet<Problem> Problems
463    {
464      get
465      {
466        return this._Problems;
467      }
468      set
469      {
470        this._Problems.Assign(value);
471      }
472    }
473   
474    public event PropertyChangingEventHandler PropertyChanging;
475   
476    public event PropertyChangedEventHandler PropertyChanged;
477   
478    protected virtual void SendPropertyChanging()
479    {
480      if ((this.PropertyChanging != null))
481      {
482        this.PropertyChanging(this, emptyChangingEventArgs);
483      }
484    }
485   
486    protected virtual void SendPropertyChanged(String propertyName)
487    {
488      if ((this.PropertyChanged != null))
489      {
490        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
491      }
492    }
493   
494    private void attach_Problems(Problem entity)
495    {
496      this.SendPropertyChanging();
497      entity.ProblemClass = this;
498    }
499   
500    private void detach_Problems(Problem entity)
501    {
502      this.SendPropertyChanging();
503      entity.ProblemClass = null;
504    }
505  }
506 
507  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.AlgorithmUser")]
508  public partial class AlgorithmUser : INotifyPropertyChanging, INotifyPropertyChanged
509  {
510   
511    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
512   
513    private long _AlgorithmId;
514   
515    private System.Guid _UserId;
516   
517    private EntityRef<Algorithm> _Algorithm;
518   
519    #region Extensibility Method Definitions
520    partial void OnLoaded();
521    partial void OnValidate(System.Data.Linq.ChangeAction action);
522    partial void OnCreated();
523    partial void OnAlgorithmIdChanging(long value);
524    partial void OnAlgorithmIdChanged();
525    partial void OnUserGroupIdChanging(System.Guid value);
526    partial void OnUserGroupIdChanged();
527    #endregion
528   
529    public AlgorithmUser()
530    {
531      this._Algorithm = default(EntityRef<Algorithm>);
532      OnCreated();
533    }
534   
535    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_AlgorithmId", DbType="BigInt NOT NULL", IsPrimaryKey=true)]
536    public long AlgorithmId
537    {
538      get
539      {
540        return this._AlgorithmId;
541      }
542      set
543      {
544        if ((this._AlgorithmId != value))
545        {
546          if (this._Algorithm.HasLoadedOrAssignedValue)
547          {
548            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
549          }
550          this.OnAlgorithmIdChanging(value);
551          this.SendPropertyChanging();
552          this._AlgorithmId = value;
553          this.SendPropertyChanged("AlgorithmId");
554          this.OnAlgorithmIdChanged();
555        }
556      }
557    }
558   
559    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
560    public System.Guid UserGroupId
561    {
562      get
563      {
564        return this._UserId;
565      }
566      set
567      {
568        if ((this._UserId != value))
569        {
570          this.OnUserGroupIdChanging(value);
571          this.SendPropertyChanging();
572          this._UserId = value;
573          this.SendPropertyChanged("UserGroupId");
574          this.OnUserGroupIdChanged();
575        }
576      }
577    }
578   
579    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Algorithm_AlgorithmUser", Storage="_Algorithm", ThisKey="AlgorithmId", OtherKey="Id", IsForeignKey=true, DeleteOnNull=true, DeleteRule="CASCADE")]
580    public Algorithm Algorithm
581    {
582      get
583      {
584        return this._Algorithm.Entity;
585      }
586      set
587      {
588        Algorithm previousValue = this._Algorithm.Entity;
589        if (((previousValue != value)
590              || (this._Algorithm.HasLoadedOrAssignedValue == false)))
591        {
592          this.SendPropertyChanging();
593          if ((previousValue != null))
594          {
595            this._Algorithm.Entity = null;
596            previousValue.AlgorithmUsers.Remove(this);
597          }
598          this._Algorithm.Entity = value;
599          if ((value != null))
600          {
601            value.AlgorithmUsers.Add(this);
602            this._AlgorithmId = value.Id;
603          }
604          else
605          {
606            this._AlgorithmId = default(long);
607          }
608          this.SendPropertyChanged("Algorithm");
609        }
610      }
611    }
612   
613    public event PropertyChangingEventHandler PropertyChanging;
614   
615    public event PropertyChangedEventHandler PropertyChanged;
616   
617    protected virtual void SendPropertyChanging()
618    {
619      if ((this.PropertyChanging != null))
620      {
621        this.PropertyChanging(this, emptyChangingEventArgs);
622      }
623    }
624   
625    protected virtual void SendPropertyChanged(String propertyName)
626    {
627      if ((this.PropertyChanged != null))
628      {
629        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
630      }
631    }
632  }
633 
634  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ProblemUser")]
635  public partial class ProblemUser : INotifyPropertyChanging, INotifyPropertyChanged
636  {
637   
638    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
639   
640    private long _ProblemId;
641   
642    private System.Guid _UserId;
643   
644    private EntityRef<Problem> _Problem;
645   
646    #region Extensibility Method Definitions
647    partial void OnLoaded();
648    partial void OnValidate(System.Data.Linq.ChangeAction action);
649    partial void OnCreated();
650    partial void OnProblemIdChanging(long value);
651    partial void OnProblemIdChanged();
652    partial void OnUserGroupIdChanging(System.Guid value);
653    partial void OnUserGroupIdChanged();
654    #endregion
655   
656    public ProblemUser()
657    {
658      this._Problem = default(EntityRef<Problem>);
659      OnCreated();
660    }
661   
662    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ProblemId", DbType="BigInt NOT NULL", IsPrimaryKey=true)]
663    public long ProblemId
664    {
665      get
666      {
667        return this._ProblemId;
668      }
669      set
670      {
671        if ((this._ProblemId != value))
672        {
673          if (this._Problem.HasLoadedOrAssignedValue)
674          {
675            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
676          }
677          this.OnProblemIdChanging(value);
678          this.SendPropertyChanging();
679          this._ProblemId = value;
680          this.SendPropertyChanged("ProblemId");
681          this.OnProblemIdChanged();
682        }
683      }
684    }
685   
686    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
687    public System.Guid UserGroupId
688    {
689      get
690      {
691        return this._UserId;
692      }
693      set
694      {
695        if ((this._UserId != value))
696        {
697          this.OnUserGroupIdChanging(value);
698          this.SendPropertyChanging();
699          this._UserId = value;
700          this.SendPropertyChanged("UserGroupId");
701          this.OnUserGroupIdChanged();
702        }
703      }
704    }
705   
706    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Problem_ProblemUser", Storage="_Problem", ThisKey="ProblemId", OtherKey="Id", IsForeignKey=true, DeleteOnNull=true, DeleteRule="CASCADE")]
707    public Problem Problem
708    {
709      get
710      {
711        return this._Problem.Entity;
712      }
713      set
714      {
715        Problem previousValue = this._Problem.Entity;
716        if (((previousValue != value)
717              || (this._Problem.HasLoadedOrAssignedValue == false)))
718        {
719          this.SendPropertyChanging();
720          if ((previousValue != null))
721          {
722            this._Problem.Entity = null;
723            previousValue.ProblemUsers.Remove(this);
724          }
725          this._Problem.Entity = value;
726          if ((value != null))
727          {
728            value.ProblemUsers.Add(this);
729            this._ProblemId = value.Id;
730          }
731          else
732          {
733            this._ProblemId = default(long);
734          }
735          this.SendPropertyChanged("Problem");
736        }
737      }
738    }
739   
740    public event PropertyChangingEventHandler PropertyChanging;
741   
742    public event PropertyChangedEventHandler PropertyChanged;
743   
744    protected virtual void SendPropertyChanging()
745    {
746      if ((this.PropertyChanging != null))
747      {
748        this.PropertyChanging(this, emptyChangingEventArgs);
749      }
750    }
751   
752    protected virtual void SendPropertyChanged(String propertyName)
753    {
754      if ((this.PropertyChanged != null))
755      {
756        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
757      }
758    }
759  }
760 
761  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Platform")]
762  public partial class Platform : INotifyPropertyChanging, INotifyPropertyChanged
763  {
764   
765    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
766   
767    private long _Id;
768   
769    private string _Name;
770   
771    private string _Description;
772   
773    private EntitySet<Algorithm> _Algorithms;
774   
775    private EntitySet<Problem> _Problems;
776   
777    #region Extensibility Method Definitions
778    partial void OnLoaded();
779    partial void OnValidate(System.Data.Linq.ChangeAction action);
780    partial void OnCreated();
781    partial void OnIdChanging(long value);
782    partial void OnIdChanged();
783    partial void OnNameChanging(string value);
784    partial void OnNameChanged();
785    partial void OnDescriptionChanging(string value);
786    partial void OnDescriptionChanged();
787    #endregion
788   
789    public Platform()
790    {
791      this._Algorithms = new EntitySet<Algorithm>(new Action<Algorithm>(this.attach_Algorithms), new Action<Algorithm>(this.detach_Algorithms));
792      this._Problems = new EntitySet<Problem>(new Action<Problem>(this.attach_Problems), new Action<Problem>(this.detach_Problems));
793      OnCreated();
794    }
795   
796    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true)]
797    public long Id
798    {
799      get
800      {
801        return this._Id;
802      }
803      set
804      {
805        if ((this._Id != value))
806        {
807          this.OnIdChanging(value);
808          this.SendPropertyChanging();
809          this._Id = value;
810          this.SendPropertyChanged("Id");
811          this.OnIdChanged();
812        }
813      }
814    }
815   
816    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(200) NOT NULL", CanBeNull=false)]
817    public string Name
818    {
819      get
820      {
821        return this._Name;
822      }
823      set
824      {
825        if ((this._Name != value))
826        {
827          this.OnNameChanging(value);
828          this.SendPropertyChanging();
829          this._Name = value;
830          this.SendPropertyChanged("Name");
831          this.OnNameChanged();
832        }
833      }
834    }
835   
836    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Description", DbType="NVarChar(MAX)")]
837    public string Description
838    {
839      get
840      {
841        return this._Description;
842      }
843      set
844      {
845        if ((this._Description != value))
846        {
847          this.OnDescriptionChanging(value);
848          this.SendPropertyChanging();
849          this._Description = value;
850          this.SendPropertyChanged("Description");
851          this.OnDescriptionChanged();
852        }
853      }
854    }
855   
856    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Platform_Algorithm", Storage="_Algorithms", ThisKey="Id", OtherKey="PlatformId")]
857    public EntitySet<Algorithm> Algorithms
858    {
859      get
860      {
861        return this._Algorithms;
862      }
863      set
864      {
865        this._Algorithms.Assign(value);
866      }
867    }
868   
869    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Platform_Problem", Storage="_Problems", ThisKey="Id", OtherKey="PlatformId")]
870    public EntitySet<Problem> Problems
871    {
872      get
873      {
874        return this._Problems;
875      }
876      set
877      {
878        this._Problems.Assign(value);
879      }
880    }
881   
882    public event PropertyChangingEventHandler PropertyChanging;
883   
884    public event PropertyChangedEventHandler PropertyChanged;
885   
886    protected virtual void SendPropertyChanging()
887    {
888      if ((this.PropertyChanging != null))
889      {
890        this.PropertyChanging(this, emptyChangingEventArgs);
891      }
892    }
893   
894    protected virtual void SendPropertyChanged(String propertyName)
895    {
896      if ((this.PropertyChanged != null))
897      {
898        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
899      }
900    }
901   
902    private void attach_Algorithms(Algorithm entity)
903    {
904      this.SendPropertyChanging();
905      entity.Platform = this;
906    }
907   
908    private void detach_Algorithms(Algorithm entity)
909    {
910      this.SendPropertyChanging();
911      entity.Platform = null;
912    }
913   
914    private void attach_Problems(Problem entity)
915    {
916      this.SendPropertyChanging();
917      entity.Platform = this;
918    }
919   
920    private void detach_Problems(Problem entity)
921    {
922      this.SendPropertyChanging();
923      entity.Platform = null;
924    }
925  }
926 
927  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.DataType")]
928  public partial class DataType : INotifyPropertyChanging, INotifyPropertyChanged
929  {
930   
931    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
932   
933    private long _Id;
934   
935    private string _Name;
936   
937    private string _TypeName;
938   
939    private EntitySet<Algorithm> _Algorithms;
940   
941    private EntitySet<Problem> _Problems;
942   
943    private EntitySet<Value> _Values;
944   
945    private EntitySet<CharacteristicValue> _CharacteristicValues;
946   
947    private EntitySet<SingleObjectiveSolution> _SingleObjectiveSolutions;
948   
949    #region Extensibility Method Definitions
950    partial void OnLoaded();
951    partial void OnValidate(System.Data.Linq.ChangeAction action);
952    partial void OnCreated();
953    partial void OnIdChanging(long value);
954    partial void OnIdChanged();
955    partial void OnNameChanging(string value);
956    partial void OnNameChanged();
957    partial void OnTypeNameChanging(string value);
958    partial void OnTypeNameChanged();
959    #endregion
960   
961    public DataType()
962    {
963      this._Algorithms = new EntitySet<Algorithm>(new Action<Algorithm>(this.attach_Algorithms), new Action<Algorithm>(this.detach_Algorithms));
964      this._Problems = new EntitySet<Problem>(new Action<Problem>(this.attach_Problems), new Action<Problem>(this.detach_Problems));
965      this._Values = new EntitySet<Value>(new Action<Value>(this.attach_Values), new Action<Value>(this.detach_Values));
966      this._CharacteristicValues = new EntitySet<CharacteristicValue>(new Action<CharacteristicValue>(this.attach_CharacteristicValues), new Action<CharacteristicValue>(this.detach_CharacteristicValues));
967      this._SingleObjectiveSolutions = new EntitySet<SingleObjectiveSolution>(new Action<SingleObjectiveSolution>(this.attach_SingleObjectiveSolutions), new Action<SingleObjectiveSolution>(this.detach_SingleObjectiveSolutions));
968      OnCreated();
969    }
970   
971    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true)]
972    public long Id
973    {
974      get
975      {
976        return this._Id;
977      }
978      set
979      {
980        if ((this._Id != value))
981        {
982          this.OnIdChanging(value);
983          this.SendPropertyChanging();
984          this._Id = value;
985          this.SendPropertyChanged("Id");
986          this.OnIdChanged();
987        }
988      }
989    }
990   
991    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(200) NOT NULL", CanBeNull=false)]
992    public string Name
993    {
994      get
995      {
996        return this._Name;
997      }
998      set
999      {
1000        if ((this._Name != value))
1001        {
1002          this.OnNameChanging(value);
1003          this.SendPropertyChanging();
1004          this._Name = value;
1005          this.SendPropertyChanged("Name");
1006          this.OnNameChanged();
1007        }
1008      }
1009    }
1010   
1011    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TypeName", DbType="NVarChar(MAX) NOT NULL", CanBeNull=false)]
1012    public string TypeName
1013    {
1014      get
1015      {
1016        return this._TypeName;
1017      }
1018      set
1019      {
1020        if ((this._TypeName != value))
1021        {
1022          this.OnTypeNameChanging(value);
1023          this.SendPropertyChanging();
1024          this._TypeName = value;
1025          this.SendPropertyChanged("TypeName");
1026          this.OnTypeNameChanged();
1027        }
1028      }
1029    }
1030   
1031    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DataType_Algorithm", Storage="_Algorithms", ThisKey="Id", OtherKey="DataTypeId")]
1032    public EntitySet<Algorithm> Algorithms
1033    {
1034      get
1035      {
1036        return this._Algorithms;
1037      }
1038      set
1039      {
1040        this._Algorithms.Assign(value);
1041      }
1042    }
1043   
1044    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DataType_Problem", Storage="_Problems", ThisKey="Id", OtherKey="DataTypeId")]
1045    public EntitySet<Problem> Problems
1046    {
1047      get
1048      {
1049        return this._Problems;
1050      }
1051      set
1052      {
1053        this._Problems.Assign(value);
1054      }
1055    }
1056   
1057    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DataType_Value", Storage="_Values", ThisKey="Id", OtherKey="DataTypeId")]
1058    public EntitySet<Value> Values
1059    {
1060      get
1061      {
1062        return this._Values;
1063      }
1064      set
1065      {
1066        this._Values.Assign(value);
1067      }
1068    }
1069   
1070    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DataType_CharacteristicValue", Storage="_CharacteristicValues", ThisKey="Id", OtherKey="DataTypeId")]
1071    public EntitySet<CharacteristicValue> CharacteristicValues
1072    {
1073      get
1074      {
1075        return this._CharacteristicValues;
1076      }
1077      set
1078      {
1079        this._CharacteristicValues.Assign(value);
1080      }
1081    }
1082   
1083    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DataType_SingleObjectiveSolution", Storage="_SingleObjectiveSolutions", ThisKey="Id", OtherKey="DataTypeId")]
1084    public EntitySet<SingleObjectiveSolution> SingleObjectiveSolutions
1085    {
1086      get
1087      {
1088        return this._SingleObjectiveSolutions;
1089      }
1090      set
1091      {
1092        this._SingleObjectiveSolutions.Assign(value);
1093      }
1094    }
1095   
1096    public event PropertyChangingEventHandler PropertyChanging;
1097   
1098    public event PropertyChangedEventHandler PropertyChanged;
1099   
1100    protected virtual void SendPropertyChanging()
1101    {
1102      if ((this.PropertyChanging != null))
1103      {
1104        this.PropertyChanging(this, emptyChangingEventArgs);
1105      }
1106    }
1107   
1108    protected virtual void SendPropertyChanged(String propertyName)
1109    {
1110      if ((this.PropertyChanged != null))
1111      {
1112        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1113      }
1114    }
1115   
1116    private void attach_Algorithms(Algorithm entity)
1117    {
1118      this.SendPropertyChanging();
1119      entity.DataType = this;
1120    }
1121   
1122    private void detach_Algorithms(Algorithm entity)
1123    {
1124      this.SendPropertyChanging();
1125      entity.DataType = null;
1126    }
1127   
1128    private void attach_Problems(Problem entity)
1129    {
1130      this.SendPropertyChanging();
1131      entity.DataType = this;
1132    }
1133   
1134    private void detach_Problems(Problem entity)
1135    {
1136      this.SendPropertyChanging();
1137      entity.DataType = null;
1138    }
1139   
1140    private void attach_Values(Value entity)
1141    {
1142      this.SendPropertyChanging();
1143      entity.DataType = this;
1144    }
1145   
1146    private void detach_Values(Value entity)
1147    {
1148      this.SendPropertyChanging();
1149      entity.DataType = null;
1150    }
1151   
1152    private void attach_CharacteristicValues(CharacteristicValue entity)
1153    {
1154      this.SendPropertyChanging();
1155      entity.DataType = this;
1156    }
1157   
1158    private void detach_CharacteristicValues(CharacteristicValue entity)
1159    {
1160      this.SendPropertyChanging();
1161      entity.DataType = null;
1162    }
1163   
1164    private void attach_SingleObjectiveSolutions(SingleObjectiveSolution entity)
1165    {
1166      this.SendPropertyChanging();
1167      entity.DataType = this;
1168    }
1169   
1170    private void detach_SingleObjectiveSolutions(SingleObjectiveSolution entity)
1171    {
1172      this.SendPropertyChanging();
1173      entity.DataType = null;
1174    }
1175  }
1176 
1177  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ValueName")]
1178  public partial class ValueName : INotifyPropertyChanging, INotifyPropertyChanged
1179  {
1180   
1181    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1182   
1183    private long _Id;
1184   
1185    private string _Name;
1186   
1187    private ValueNameCategory _Category;
1188   
1189    private ValueNameType _Type;
1190   
1191    private EntitySet<Value> _Values;
1192   
1193    #region Extensibility Method Definitions
1194    partial void OnLoaded();
1195    partial void OnValidate(System.Data.Linq.ChangeAction action);
1196    partial void OnCreated();
1197    partial void OnIdChanging(long value);
1198    partial void OnIdChanged();
1199    partial void OnNameChanging(string value);
1200    partial void OnNameChanged();
1201    partial void OnCategoryChanging(ValueNameCategory value);
1202    partial void OnCategoryChanged();
1203    partial void OnTypeChanging(ValueNameType value);
1204    partial void OnTypeChanged();
1205    #endregion
1206   
1207    public ValueName()
1208    {
1209      this._Values = new EntitySet<Value>(new Action<Value>(this.attach_Values), new Action<Value>(this.detach_Values));
1210      OnCreated();
1211    }
1212   
1213    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true)]
1214    public long Id
1215    {
1216      get
1217      {
1218        return this._Id;
1219      }
1220      set
1221      {
1222        if ((this._Id != value))
1223        {
1224          this.OnIdChanging(value);
1225          this.SendPropertyChanging();
1226          this._Id = value;
1227          this.SendPropertyChanged("Id");
1228          this.OnIdChanged();
1229        }
1230      }
1231    }
1232   
1233    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(200) NOT NULL", CanBeNull=false)]
1234    public string Name
1235    {
1236      get
1237      {
1238        return this._Name;
1239      }
1240      set
1241      {
1242        if ((this._Name != value))
1243        {
1244          this.OnNameChanging(value);
1245          this.SendPropertyChanging();
1246          this._Name = value;
1247          this.SendPropertyChanged("Name");
1248          this.OnNameChanged();
1249        }
1250      }
1251    }
1252   
1253    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Category", DbType="TinyInt NOT NULL", CanBeNull=false)]
1254    public ValueNameCategory Category
1255    {
1256      get
1257      {
1258        return this._Category;
1259      }
1260      set
1261      {
1262        if ((this._Category != value))
1263        {
1264          this.OnCategoryChanging(value);
1265          this.SendPropertyChanging();
1266          this._Category = value;
1267          this.SendPropertyChanged("Category");
1268          this.OnCategoryChanged();
1269        }
1270      }
1271    }
1272   
1273    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Type", DbType="TinyInt NOT NULL", CanBeNull=false)]
1274    public ValueNameType Type
1275    {
1276      get
1277      {
1278        return this._Type;
1279      }
1280      set
1281      {
1282        if ((this._Type != value))
1283        {
1284          this.OnTypeChanging(value);
1285          this.SendPropertyChanging();
1286          this._Type = value;
1287          this.SendPropertyChanged("Type");
1288          this.OnTypeChanged();
1289        }
1290      }
1291    }
1292   
1293    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="ValueName_Value", Storage="_Values", ThisKey="Id", OtherKey="ValueNameId")]
1294    public EntitySet<Value> Values
1295    {
1296      get
1297      {
1298        return this._Values;
1299      }
1300      set
1301      {
1302        this._Values.Assign(value);
1303      }
1304    }
1305   
1306    public event PropertyChangingEventHandler PropertyChanging;
1307   
1308    public event PropertyChangedEventHandler PropertyChanged;
1309   
1310    protected virtual void SendPropertyChanging()
1311    {
1312      if ((this.PropertyChanging != null))
1313      {
1314        this.PropertyChanging(this, emptyChangingEventArgs);
1315      }
1316    }
1317   
1318    protected virtual void SendPropertyChanged(String propertyName)
1319    {
1320      if ((this.PropertyChanged != null))
1321      {
1322        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1323      }
1324    }
1325   
1326    private void attach_Values(Value entity)
1327    {
1328      this.SendPropertyChanging();
1329      entity.ValueName = this;
1330    }
1331   
1332    private void detach_Values(Value entity)
1333    {
1334      this.SendPropertyChanging();
1335      entity.ValueName = null;
1336    }
1337  }
1338 
1339  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Algorithm")]
1340  public partial class Algorithm : INotifyPropertyChanging, INotifyPropertyChanged
1341  {
1342   
1343    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1344   
1345    private long _Id;
1346   
1347    private long _AlgorithmClassId;
1348   
1349    private long _PlatformId;
1350   
1351    private long _DataTypeId;
1352   
1353    private System.Nullable<long> _BinaryDataId;
1354   
1355    private string _Name;
1356   
1357    private string _Description;
1358   
1359    private EntitySet<AlgorithmUser> _AlgorithmUsers;
1360   
1361    private EntitySet<Run> _Runs;
1362   
1363    private EntityRef<AlgorithmClass> _AlgorithmClass;
1364   
1365    private EntityRef<DataType> _DataType;
1366   
1367    private EntityRef<Platform> _Platform;
1368   
1369    private EntityRef<BinaryData> _BinaryData;
1370   
1371    #region Extensibility Method Definitions
1372    partial void OnLoaded();
1373    partial void OnValidate(System.Data.Linq.ChangeAction action);
1374    partial void OnCreated();
1375    partial void OnIdChanging(long value);
1376    partial void OnIdChanged();
1377    partial void OnAlgorithmClassIdChanging(long value);
1378    partial void OnAlgorithmClassIdChanged();
1379    partial void OnPlatformIdChanging(long value);
1380    partial void OnPlatformIdChanged();
1381    partial void OnDataTypeIdChanging(long value);
1382    partial void OnDataTypeIdChanged();
1383    partial void OnBinaryDataIdChanging(System.Nullable<long> value);
1384    partial void OnBinaryDataIdChanged();
1385    partial void OnNameChanging(string value);
1386    partial void OnNameChanged();
1387    partial void OnDescriptionChanging(string value);
1388    partial void OnDescriptionChanged();
1389    #endregion
1390   
1391    public Algorithm()
1392    {
1393      this._AlgorithmUsers = new EntitySet<AlgorithmUser>(new Action<AlgorithmUser>(this.attach_AlgorithmUsers), new Action<AlgorithmUser>(this.detach_AlgorithmUsers));
1394      this._Runs = new EntitySet<Run>(new Action<Run>(this.attach_Runs), new Action<Run>(this.detach_Runs));
1395      this._AlgorithmClass = default(EntityRef<AlgorithmClass>);
1396      this._DataType = default(EntityRef<DataType>);
1397      this._Platform = default(EntityRef<Platform>);
1398      this._BinaryData = default(EntityRef<BinaryData>);
1399      OnCreated();
1400    }
1401   
1402    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true)]
1403    public long Id
1404    {
1405      get
1406      {
1407        return this._Id;
1408      }
1409      set
1410      {
1411        if ((this._Id != value))
1412        {
1413          this.OnIdChanging(value);
1414          this.SendPropertyChanging();
1415          this._Id = value;
1416          this.SendPropertyChanged("Id");
1417          this.OnIdChanged();
1418        }
1419      }
1420    }
1421   
1422    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_AlgorithmClassId", DbType="BigInt NOT NULL")]
1423    public long AlgorithmClassId
1424    {
1425      get
1426      {
1427        return this._AlgorithmClassId;
1428      }
1429      set
1430      {
1431        if ((this._AlgorithmClassId != value))
1432        {
1433          if (this._AlgorithmClass.HasLoadedOrAssignedValue)
1434          {
1435            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
1436          }
1437          this.OnAlgorithmClassIdChanging(value);
1438          this.SendPropertyChanging();
1439          this._AlgorithmClassId = value;
1440          this.SendPropertyChanged("AlgorithmClassId");
1441          this.OnAlgorithmClassIdChanged();
1442        }
1443      }
1444    }
1445   
1446    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PlatformId", DbType="BigInt NOT NULL")]
1447    public long PlatformId
1448    {
1449      get
1450      {
1451        return this._PlatformId;
1452      }
1453      set
1454      {
1455        if ((this._PlatformId != value))
1456        {
1457          if (this._Platform.HasLoadedOrAssignedValue)
1458          {
1459            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
1460          }
1461          this.OnPlatformIdChanging(value);
1462          this.SendPropertyChanging();
1463          this._PlatformId = value;
1464          this.SendPropertyChanged("PlatformId");
1465          this.OnPlatformIdChanged();
1466        }
1467      }
1468    }
1469   
1470    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DataTypeId", DbType="BigInt NOT NULL")]
1471    public long DataTypeId
1472    {
1473      get
1474      {
1475        return this._DataTypeId;
1476      }
1477      set
1478      {
1479        if ((this._DataTypeId != value))
1480        {
1481          if (this._DataType.HasLoadedOrAssignedValue)
1482          {
1483            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
1484          }
1485          this.OnDataTypeIdChanging(value);
1486          this.SendPropertyChanging();
1487          this._DataTypeId = value;
1488          this.SendPropertyChanged("DataTypeId");
1489          this.OnDataTypeIdChanged();
1490        }
1491      }
1492    }
1493   
1494    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_BinaryDataId", DbType="BigInt")]
1495    public System.Nullable<long> BinaryDataId
1496    {
1497      get
1498      {
1499        return this._BinaryDataId;
1500      }
1501      set
1502      {
1503        if ((this._BinaryDataId != value))
1504        {
1505          if (this._BinaryData.HasLoadedOrAssignedValue)
1506          {
1507            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
1508          }
1509          this.OnBinaryDataIdChanging(value);
1510          this.SendPropertyChanging();
1511          this._BinaryDataId = value;
1512          this.SendPropertyChanged("BinaryDataId");
1513          this.OnBinaryDataIdChanged();
1514        }
1515      }
1516    }
1517   
1518    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(200) NOT NULL", CanBeNull=false)]
1519    public string Name
1520    {
1521      get
1522      {
1523        return this._Name;
1524      }
1525      set
1526      {
1527        if ((this._Name != value))
1528        {
1529          this.OnNameChanging(value);
1530          this.SendPropertyChanging();
1531          this._Name = value;
1532          this.SendPropertyChanged("Name");
1533          this.OnNameChanged();
1534        }
1535      }
1536    }
1537   
1538    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Description", DbType="NVarChar(MAX)")]
1539    public string Description
1540    {
1541      get
1542      {
1543        return this._Description;
1544      }
1545      set
1546      {
1547        if ((this._Description != value))
1548        {
1549          this.OnDescriptionChanging(value);
1550          this.SendPropertyChanging();
1551          this._Description = value;
1552          this.SendPropertyChanged("Description");
1553          this.OnDescriptionChanged();
1554        }
1555      }
1556    }
1557   
1558    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Algorithm_AlgorithmUser", Storage="_AlgorithmUsers", ThisKey="Id", OtherKey="AlgorithmId")]
1559    public EntitySet<AlgorithmUser> AlgorithmUsers
1560    {
1561      get
1562      {
1563        return this._AlgorithmUsers;
1564      }
1565      set
1566      {
1567        this._AlgorithmUsers.Assign(value);
1568      }
1569    }
1570   
1571    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Algorithm_Run", Storage="_Runs", ThisKey="Id", OtherKey="AlgorithmId")]
1572    public EntitySet<Run> Runs
1573    {
1574      get
1575      {
1576        return this._Runs;
1577      }
1578      set
1579      {
1580        this._Runs.Assign(value);
1581      }
1582    }
1583   
1584    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="AlgorithmClass_Algorithm", Storage="_AlgorithmClass", ThisKey="AlgorithmClassId", OtherKey="Id", IsForeignKey=true)]
1585    public AlgorithmClass AlgorithmClass
1586    {
1587      get
1588      {
1589        return this._AlgorithmClass.Entity;
1590      }
1591      set
1592      {
1593        AlgorithmClass previousValue = this._AlgorithmClass.Entity;
1594        if (((previousValue != value)
1595              || (this._AlgorithmClass.HasLoadedOrAssignedValue == false)))
1596        {
1597          this.SendPropertyChanging();
1598          if ((previousValue != null))
1599          {
1600            this._AlgorithmClass.Entity = null;
1601            previousValue.Algorithms.Remove(this);
1602          }
1603          this._AlgorithmClass.Entity = value;
1604          if ((value != null))
1605          {
1606            value.Algorithms.Add(this);
1607            this._AlgorithmClassId = value.Id;
1608          }
1609          else
1610          {
1611            this._AlgorithmClassId = default(long);
1612          }
1613          this.SendPropertyChanged("AlgorithmClass");
1614        }
1615      }
1616    }
1617   
1618    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DataType_Algorithm", Storage="_DataType", ThisKey="DataTypeId", OtherKey="Id", IsForeignKey=true)]
1619    public DataType DataType
1620    {
1621      get
1622      {
1623        return this._DataType.Entity;
1624      }
1625      set
1626      {
1627        DataType previousValue = this._DataType.Entity;
1628        if (((previousValue != value)
1629              || (this._DataType.HasLoadedOrAssignedValue == false)))
1630        {
1631          this.SendPropertyChanging();
1632          if ((previousValue != null))
1633          {
1634            this._DataType.Entity = null;
1635            previousValue.Algorithms.Remove(this);
1636          }
1637          this._DataType.Entity = value;
1638          if ((value != null))
1639          {
1640            value.Algorithms.Add(this);
1641            this._DataTypeId = value.Id;
1642          }
1643          else
1644          {
1645            this._DataTypeId = default(long);
1646          }
1647          this.SendPropertyChanged("DataType");
1648        }
1649      }
1650    }
1651   
1652    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Platform_Algorithm", Storage="_Platform", ThisKey="PlatformId", OtherKey="Id", IsForeignKey=true)]
1653    public Platform Platform
1654    {
1655      get
1656      {
1657        return this._Platform.Entity;
1658      }
1659      set
1660      {
1661        Platform previousValue = this._Platform.Entity;
1662        if (((previousValue != value)
1663              || (this._Platform.HasLoadedOrAssignedValue == false)))
1664        {
1665          this.SendPropertyChanging();
1666          if ((previousValue != null))
1667          {
1668            this._Platform.Entity = null;
1669            previousValue.Algorithms.Remove(this);
1670          }
1671          this._Platform.Entity = value;
1672          if ((value != null))
1673          {
1674            value.Algorithms.Add(this);
1675            this._PlatformId = value.Id;
1676          }
1677          else
1678          {
1679            this._PlatformId = default(long);
1680          }
1681          this.SendPropertyChanged("Platform");
1682        }
1683      }
1684    }
1685   
1686    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="BinaryData_Algorithm", Storage="_BinaryData", ThisKey="BinaryDataId", OtherKey="Id", IsForeignKey=true)]
1687    public BinaryData BinaryData
1688    {
1689      get
1690      {
1691        return this._BinaryData.Entity;
1692      }
1693      set
1694      {
1695        BinaryData previousValue = this._BinaryData.Entity;
1696        if (((previousValue != value)
1697              || (this._BinaryData.HasLoadedOrAssignedValue == false)))
1698        {
1699          this.SendPropertyChanging();
1700          if ((previousValue != null))
1701          {
1702            this._BinaryData.Entity = null;
1703            previousValue.Algorithms.Remove(this);
1704          }
1705          this._BinaryData.Entity = value;
1706          if ((value != null))
1707          {
1708            value.Algorithms.Add(this);
1709            this._BinaryDataId = value.Id;
1710          }
1711          else
1712          {
1713            this._BinaryDataId = default(Nullable<long>);
1714          }
1715          this.SendPropertyChanged("BinaryData");
1716        }
1717      }
1718    }
1719   
1720    public event PropertyChangingEventHandler PropertyChanging;
1721   
1722    public event PropertyChangedEventHandler PropertyChanged;
1723   
1724    protected virtual void SendPropertyChanging()
1725    {
1726      if ((this.PropertyChanging != null))
1727      {
1728        this.PropertyChanging(this, emptyChangingEventArgs);
1729      }
1730    }
1731   
1732    protected virtual void SendPropertyChanged(String propertyName)
1733    {
1734      if ((this.PropertyChanged != null))
1735      {
1736        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1737      }
1738    }
1739   
1740    private void attach_AlgorithmUsers(AlgorithmUser entity)
1741    {
1742      this.SendPropertyChanging();
1743      entity.Algorithm = this;
1744    }
1745   
1746    private void detach_AlgorithmUsers(AlgorithmUser entity)
1747    {
1748      this.SendPropertyChanging();
1749      entity.Algorithm = null;
1750    }
1751   
1752    private void attach_Runs(Run entity)
1753    {
1754      this.SendPropertyChanging();
1755      entity.Algorithm = this;
1756    }
1757   
1758    private void detach_Runs(Run entity)
1759    {
1760      this.SendPropertyChanging();
1761      entity.Algorithm = null;
1762    }
1763  }
1764 
1765  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Problem")]
1766  public partial class Problem : INotifyPropertyChanging, INotifyPropertyChanged
1767  {
1768   
1769    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1770   
1771    private long _Id;
1772   
1773    private long _ProblemClassId;
1774   
1775    private long _PlatformId;
1776   
1777    private long _DataTypeId;
1778   
1779    private System.Nullable<long> _BinaryDataId;
1780   
1781    private string _Name;
1782   
1783    private string _Description;
1784   
1785    private EntitySet<ProblemUser> _ProblemUsers;
1786   
1787    private EntitySet<Run> _Runs;
1788   
1789    private EntitySet<CharacteristicValue> _CharacteristicValues;
1790   
1791    private EntitySet<SingleObjectiveSolution> _SingleObjectiveSolutions;
1792   
1793    private EntityRef<DataType> _DataType;
1794   
1795    private EntityRef<Platform> _Platform;
1796   
1797    private EntityRef<ProblemClass> _ProblemClass;
1798   
1799    private EntityRef<BinaryData> _BinaryData;
1800   
1801    #region Extensibility Method Definitions
1802    partial void OnLoaded();
1803    partial void OnValidate(System.Data.Linq.ChangeAction action);
1804    partial void OnCreated();
1805    partial void OnIdChanging(long value);
1806    partial void OnIdChanged();
1807    partial void OnProblemClassIdChanging(long value);
1808    partial void OnProblemClassIdChanged();
1809    partial void OnPlatformIdChanging(long value);
1810    partial void OnPlatformIdChanged();
1811    partial void OnDataTypeIdChanging(long value);
1812    partial void OnDataTypeIdChanged();
1813    partial void OnBinaryDataIdChanging(System.Nullable<long> value);
1814    partial void OnBinaryDataIdChanged();
1815    partial void OnNameChanging(string value);
1816    partial void OnNameChanged();
1817    partial void OnDescriptionChanging(string value);
1818    partial void OnDescriptionChanged();
1819    #endregion
1820   
1821    public Problem()
1822    {
1823      this._ProblemUsers = new EntitySet<ProblemUser>(new Action<ProblemUser>(this.attach_ProblemUsers), new Action<ProblemUser>(this.detach_ProblemUsers));
1824      this._Runs = new EntitySet<Run>(new Action<Run>(this.attach_Runs), new Action<Run>(this.detach_Runs));
1825      this._CharacteristicValues = new EntitySet<CharacteristicValue>(new Action<CharacteristicValue>(this.attach_CharacteristicValues), new Action<CharacteristicValue>(this.detach_CharacteristicValues));
1826      this._SingleObjectiveSolutions = new EntitySet<SingleObjectiveSolution>(new Action<SingleObjectiveSolution>(this.attach_SingleObjectiveSolutions), new Action<SingleObjectiveSolution>(this.detach_SingleObjectiveSolutions));
1827      this._DataType = default(EntityRef<DataType>);
1828      this._Platform = default(EntityRef<Platform>);
1829      this._ProblemClass = default(EntityRef<ProblemClass>);
1830      this._BinaryData = default(EntityRef<BinaryData>);
1831      OnCreated();
1832    }
1833   
1834    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true)]
1835    public long Id
1836    {
1837      get
1838      {
1839        return this._Id;
1840      }
1841      set
1842      {
1843        if ((this._Id != value))
1844        {
1845          this.OnIdChanging(value);
1846          this.SendPropertyChanging();
1847          this._Id = value;
1848          this.SendPropertyChanged("Id");
1849          this.OnIdChanged();
1850        }
1851      }
1852    }
1853   
1854    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ProblemClassId", DbType="BigInt NOT NULL")]
1855    public long ProblemClassId
1856    {
1857      get
1858      {
1859        return this._ProblemClassId;
1860      }
1861      set
1862      {
1863        if ((this._ProblemClassId != value))
1864        {
1865          if (this._ProblemClass.HasLoadedOrAssignedValue)
1866          {
1867            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
1868          }
1869          this.OnProblemClassIdChanging(value);
1870          this.SendPropertyChanging();
1871          this._ProblemClassId = value;
1872          this.SendPropertyChanged("ProblemClassId");
1873          this.OnProblemClassIdChanged();
1874        }
1875      }
1876    }
1877   
1878    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PlatformId", DbType="BigInt NOT NULL")]
1879    public long PlatformId
1880    {
1881      get
1882      {
1883        return this._PlatformId;
1884      }
1885      set
1886      {
1887        if ((this._PlatformId != value))
1888        {
1889          if (this._Platform.HasLoadedOrAssignedValue)
1890          {
1891            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
1892          }
1893          this.OnPlatformIdChanging(value);
1894          this.SendPropertyChanging();
1895          this._PlatformId = value;
1896          this.SendPropertyChanged("PlatformId");
1897          this.OnPlatformIdChanged();
1898        }
1899      }
1900    }
1901   
1902    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DataTypeId", DbType="BigInt NOT NULL")]
1903    public long DataTypeId
1904    {
1905      get
1906      {
1907        return this._DataTypeId;
1908      }
1909      set
1910      {
1911        if ((this._DataTypeId != value))
1912        {
1913          if (this._DataType.HasLoadedOrAssignedValue)
1914          {
1915            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
1916          }
1917          this.OnDataTypeIdChanging(value);
1918          this.SendPropertyChanging();
1919          this._DataTypeId = value;
1920          this.SendPropertyChanged("DataTypeId");
1921          this.OnDataTypeIdChanged();
1922        }
1923      }
1924    }
1925   
1926    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_BinaryDataId", DbType="BigInt")]
1927    public System.Nullable<long> BinaryDataId
1928    {
1929      get
1930      {
1931        return this._BinaryDataId;
1932      }
1933      set
1934      {
1935        if ((this._BinaryDataId != value))
1936        {
1937          if (this._BinaryData.HasLoadedOrAssignedValue)
1938          {
1939            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
1940          }
1941          this.OnBinaryDataIdChanging(value);
1942          this.SendPropertyChanging();
1943          this._BinaryDataId = value;
1944          this.SendPropertyChanged("BinaryDataId");
1945          this.OnBinaryDataIdChanged();
1946        }
1947      }
1948    }
1949   
1950    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(200) NOT NULL", CanBeNull=false)]
1951    public string Name
1952    {
1953      get
1954      {
1955        return this._Name;
1956      }
1957      set
1958      {
1959        if ((this._Name != value))
1960        {
1961          this.OnNameChanging(value);
1962          this.SendPropertyChanging();
1963          this._Name = value;
1964          this.SendPropertyChanged("Name");
1965          this.OnNameChanged();
1966        }
1967      }
1968    }
1969   
1970    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Description", DbType="NVarChar(MAX)")]
1971    public string Description
1972    {
1973      get
1974      {
1975        return this._Description;
1976      }
1977      set
1978      {
1979        if ((this._Description != value))
1980        {
1981          this.OnDescriptionChanging(value);
1982          this.SendPropertyChanging();
1983          this._Description = value;
1984          this.SendPropertyChanged("Description");
1985          this.OnDescriptionChanged();
1986        }
1987      }
1988    }
1989   
1990    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Problem_ProblemUser", Storage="_ProblemUsers", ThisKey="Id", OtherKey="ProblemId")]
1991    public EntitySet<ProblemUser> ProblemUsers
1992    {
1993      get
1994      {
1995        return this._ProblemUsers;
1996      }
1997      set
1998      {
1999        this._ProblemUsers.Assign(value);
2000      }
2001    }
2002   
2003    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Problem_Run", Storage="_Runs", ThisKey="Id", OtherKey="ProblemId")]
2004    public EntitySet<Run> Runs
2005    {
2006      get
2007      {
2008        return this._Runs;
2009      }
2010      set
2011      {
2012        this._Runs.Assign(value);
2013      }
2014    }
2015   
2016    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Problem_CharacteristicValue", Storage="_CharacteristicValues", ThisKey="Id", OtherKey="ProblemId")]
2017    public EntitySet<CharacteristicValue> CharacteristicValues
2018    {
2019      get
2020      {
2021        return this._CharacteristicValues;
2022      }
2023      set
2024      {
2025        this._CharacteristicValues.Assign(value);
2026      }
2027    }
2028   
2029    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Problem_SingleObjectiveSolution", Storage="_SingleObjectiveSolutions", ThisKey="Id", OtherKey="ProblemId")]
2030    public EntitySet<SingleObjectiveSolution> SingleObjectiveSolutions
2031    {
2032      get
2033      {
2034        return this._SingleObjectiveSolutions;
2035      }
2036      set
2037      {
2038        this._SingleObjectiveSolutions.Assign(value);
2039      }
2040    }
2041   
2042    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DataType_Problem", Storage="_DataType", ThisKey="DataTypeId", OtherKey="Id", IsForeignKey=true)]
2043    public DataType DataType
2044    {
2045      get
2046      {
2047        return this._DataType.Entity;
2048      }
2049      set
2050      {
2051        DataType previousValue = this._DataType.Entity;
2052        if (((previousValue != value)
2053              || (this._DataType.HasLoadedOrAssignedValue == false)))
2054        {
2055          this.SendPropertyChanging();
2056          if ((previousValue != null))
2057          {
2058            this._DataType.Entity = null;
2059            previousValue.Problems.Remove(this);
2060          }
2061          this._DataType.Entity = value;
2062          if ((value != null))
2063          {
2064            value.Problems.Add(this);
2065            this._DataTypeId = value.Id;
2066          }
2067          else
2068          {
2069            this._DataTypeId = default(long);
2070          }
2071          this.SendPropertyChanged("DataType");
2072        }
2073      }
2074    }
2075   
2076    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Platform_Problem", Storage="_Platform", ThisKey="PlatformId", OtherKey="Id", IsForeignKey=true)]
2077    public Platform Platform
2078    {
2079      get
2080      {
2081        return this._Platform.Entity;
2082      }
2083      set
2084      {
2085        Platform previousValue = this._Platform.Entity;
2086        if (((previousValue != value)
2087              || (this._Platform.HasLoadedOrAssignedValue == false)))
2088        {
2089          this.SendPropertyChanging();
2090          if ((previousValue != null))
2091          {
2092            this._Platform.Entity = null;
2093            previousValue.Problems.Remove(this);
2094          }
2095          this._Platform.Entity = value;
2096          if ((value != null))
2097          {
2098            value.Problems.Add(this);
2099            this._PlatformId = value.Id;
2100          }
2101          else
2102          {
2103            this._PlatformId = default(long);
2104          }
2105          this.SendPropertyChanged("Platform");
2106        }
2107      }
2108    }
2109   
2110    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="ProblemClass_Problem", Storage="_ProblemClass", ThisKey="ProblemClassId", OtherKey="Id", IsForeignKey=true)]
2111    public ProblemClass ProblemClass
2112    {
2113      get
2114      {
2115        return this._ProblemClass.Entity;
2116      }
2117      set
2118      {
2119        ProblemClass previousValue = this._ProblemClass.Entity;
2120        if (((previousValue != value)
2121              || (this._ProblemClass.HasLoadedOrAssignedValue == false)))
2122        {
2123          this.SendPropertyChanging();
2124          if ((previousValue != null))
2125          {
2126            this._ProblemClass.Entity = null;
2127            previousValue.Problems.Remove(this);
2128          }
2129          this._ProblemClass.Entity = value;
2130          if ((value != null))
2131          {
2132            value.Problems.Add(this);
2133            this._ProblemClassId = value.Id;
2134          }
2135          else
2136          {
2137            this._ProblemClassId = default(long);
2138          }
2139          this.SendPropertyChanged("ProblemClass");
2140        }
2141      }
2142    }
2143   
2144    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="BinaryData_Problem", Storage="_BinaryData", ThisKey="BinaryDataId", OtherKey="Id", IsForeignKey=true)]
2145    public BinaryData BinaryData
2146    {
2147      get
2148      {
2149        return this._BinaryData.Entity;
2150      }
2151      set
2152      {
2153        BinaryData previousValue = this._BinaryData.Entity;
2154        if (((previousValue != value)
2155              || (this._BinaryData.HasLoadedOrAssignedValue == false)))
2156        {
2157          this.SendPropertyChanging();
2158          if ((previousValue != null))
2159          {
2160            this._BinaryData.Entity = null;
2161            previousValue.Problems.Remove(this);
2162          }
2163          this._BinaryData.Entity = value;
2164          if ((value != null))
2165          {
2166            value.Problems.Add(this);
2167            this._BinaryDataId = value.Id;
2168          }
2169          else
2170          {
2171            this._BinaryDataId = default(Nullable<long>);
2172          }
2173          this.SendPropertyChanged("BinaryData");
2174        }
2175      }
2176    }
2177   
2178    public event PropertyChangingEventHandler PropertyChanging;
2179   
2180    public event PropertyChangedEventHandler PropertyChanged;
2181   
2182    protected virtual void SendPropertyChanging()
2183    {
2184      if ((this.PropertyChanging != null))
2185      {
2186        this.PropertyChanging(this, emptyChangingEventArgs);
2187      }
2188    }
2189   
2190    protected virtual void SendPropertyChanged(String propertyName)
2191    {
2192      if ((this.PropertyChanged != null))
2193      {
2194        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2195      }
2196    }
2197   
2198    private void attach_ProblemUsers(ProblemUser entity)
2199    {
2200      this.SendPropertyChanging();
2201      entity.Problem = this;
2202    }
2203   
2204    private void detach_ProblemUsers(ProblemUser entity)
2205    {
2206      this.SendPropertyChanging();
2207      entity.Problem = null;
2208    }
2209   
2210    private void attach_Runs(Run entity)
2211    {
2212      this.SendPropertyChanging();
2213      entity.Problem = this;
2214    }
2215   
2216    private void detach_Runs(Run entity)
2217    {
2218      this.SendPropertyChanging();
2219      entity.Problem = null;
2220    }
2221   
2222    private void attach_CharacteristicValues(CharacteristicValue entity)
2223    {
2224      this.SendPropertyChanging();
2225      entity.Problem = this;
2226    }
2227   
2228    private void detach_CharacteristicValues(CharacteristicValue entity)
2229    {
2230      this.SendPropertyChanging();
2231      entity.Problem = null;
2232    }
2233   
2234    private void attach_SingleObjectiveSolutions(SingleObjectiveSolution entity)
2235    {
2236      this.SendPropertyChanging();
2237      entity.Problem = this;
2238    }
2239   
2240    private void detach_SingleObjectiveSolutions(SingleObjectiveSolution entity)
2241    {
2242      this.SendPropertyChanging();
2243      entity.Problem = null;
2244    }
2245  }
2246 
2247  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.BinaryData")]
2248  public partial class BinaryData : INotifyPropertyChanging, INotifyPropertyChanged
2249  {
2250   
2251    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2252   
2253    private long _Id;
2254   
2255    private System.Data.Linq.Binary _Data;
2256   
2257    private byte[] _Hash;
2258   
2259    private EntitySet<Algorithm> _Algorithms;
2260   
2261    private EntitySet<Problem> _Problems;
2262   
2263    private EntitySet<Value> _Values;
2264   
2265    private EntitySet<SingleObjectiveSolution> _SingleObjectiveSolutions;
2266   
2267    #region Extensibility Method Definitions
2268    partial void OnLoaded();
2269    partial void OnValidate(System.Data.Linq.ChangeAction action);
2270    partial void OnCreated();
2271    partial void OnIdChanging(long value);
2272    partial void OnIdChanged();
2273    partial void OnDataChanging(System.Data.Linq.Binary value);
2274    partial void OnDataChanged();
2275    partial void OnHashChanging(byte[] value);
2276    partial void OnHashChanged();
2277    #endregion
2278   
2279    public BinaryData()
2280    {
2281      this._Algorithms = new EntitySet<Algorithm>(new Action<Algorithm>(this.attach_Algorithms), new Action<Algorithm>(this.detach_Algorithms));
2282      this._Problems = new EntitySet<Problem>(new Action<Problem>(this.attach_Problems), new Action<Problem>(this.detach_Problems));
2283      this._Values = new EntitySet<Value>(new Action<Value>(this.attach_Values), new Action<Value>(this.detach_Values));
2284      this._SingleObjectiveSolutions = new EntitySet<SingleObjectiveSolution>(new Action<SingleObjectiveSolution>(this.attach_SingleObjectiveSolutions), new Action<SingleObjectiveSolution>(this.detach_SingleObjectiveSolutions));
2285      OnCreated();
2286    }
2287   
2288    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true)]
2289    public long Id
2290    {
2291      get
2292      {
2293        return this._Id;
2294      }
2295      set
2296      {
2297        if ((this._Id != value))
2298        {
2299          this.OnIdChanging(value);
2300          this.SendPropertyChanging();
2301          this._Id = value;
2302          this.SendPropertyChanged("Id");
2303          this.OnIdChanged();
2304        }
2305      }
2306    }
2307   
2308    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Data", DbType="VarBinary(MAX) NOT NULL", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
2309    public System.Data.Linq.Binary Data
2310    {
2311      get
2312      {
2313        return this._Data;
2314      }
2315      set
2316      {
2317        if ((this._Data != value))
2318        {
2319          this.OnDataChanging(value);
2320          this.SendPropertyChanging();
2321          this._Data = value;
2322          this.SendPropertyChanged("Data");
2323          this.OnDataChanged();
2324        }
2325      }
2326    }
2327   
2328    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Hash", DbType="VarBinary(20) NOT NULL", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
2329    public byte[] Hash
2330    {
2331      get
2332      {
2333        return this._Hash;
2334      }
2335      set
2336      {
2337        if ((this._Hash != value))
2338        {
2339          this.OnHashChanging(value);
2340          this.SendPropertyChanging();
2341          this._Hash = value;
2342          this.SendPropertyChanged("Hash");
2343          this.OnHashChanged();
2344        }
2345      }
2346    }
2347   
2348    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="BinaryData_Algorithm", Storage="_Algorithms", ThisKey="Id", OtherKey="BinaryDataId")]
2349    public EntitySet<Algorithm> Algorithms
2350    {
2351      get
2352      {
2353        return this._Algorithms;
2354      }
2355      set
2356      {
2357        this._Algorithms.Assign(value);
2358      }
2359    }
2360   
2361    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="BinaryData_Problem", Storage="_Problems", ThisKey="Id", OtherKey="BinaryDataId")]
2362    public EntitySet<Problem> Problems
2363    {
2364      get
2365      {
2366        return this._Problems;
2367      }
2368      set
2369      {
2370        this._Problems.Assign(value);
2371      }
2372    }
2373   
2374    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="BinaryData_Value", Storage="_Values", ThisKey="Id", OtherKey="BinaryDataId")]
2375    public EntitySet<Value> Values
2376    {
2377      get
2378      {
2379        return this._Values;
2380      }
2381      set
2382      {
2383        this._Values.Assign(value);
2384      }
2385    }
2386   
2387    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="BinaryData_SingleObjectiveSolution", Storage="_SingleObjectiveSolutions", ThisKey="Id", OtherKey="BinaryDataId")]
2388    public EntitySet<SingleObjectiveSolution> SingleObjectiveSolutions
2389    {
2390      get
2391      {
2392        return this._SingleObjectiveSolutions;
2393      }
2394      set
2395      {
2396        this._SingleObjectiveSolutions.Assign(value);
2397      }
2398    }
2399   
2400    public event PropertyChangingEventHandler PropertyChanging;
2401   
2402    public event PropertyChangedEventHandler PropertyChanged;
2403   
2404    protected virtual void SendPropertyChanging()
2405    {
2406      if ((this.PropertyChanging != null))
2407      {
2408        this.PropertyChanging(this, emptyChangingEventArgs);
2409      }
2410    }
2411   
2412    protected virtual void SendPropertyChanged(String propertyName)
2413    {
2414      if ((this.PropertyChanged != null))
2415      {
2416        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2417      }
2418    }
2419   
2420    private void attach_Algorithms(Algorithm entity)
2421    {
2422      this.SendPropertyChanging();
2423      entity.BinaryData = this;
2424    }
2425   
2426    private void detach_Algorithms(Algorithm entity)
2427    {
2428      this.SendPropertyChanging();
2429      entity.BinaryData = null;
2430    }
2431   
2432    private void attach_Problems(Problem entity)
2433    {
2434      this.SendPropertyChanging();
2435      entity.BinaryData = this;
2436    }
2437   
2438    private void detach_Problems(Problem entity)
2439    {
2440      this.SendPropertyChanging();
2441      entity.BinaryData = null;
2442    }
2443   
2444    private void attach_Values(Value entity)
2445    {
2446      this.SendPropertyChanging();
2447      entity.BinaryData = this;
2448    }
2449   
2450    private void detach_Values(Value entity)
2451    {
2452      this.SendPropertyChanging();
2453      entity.BinaryData = null;
2454    }
2455   
2456    private void attach_SingleObjectiveSolutions(SingleObjectiveSolution entity)
2457    {
2458      this.SendPropertyChanging();
2459      entity.BinaryData = this;
2460    }
2461   
2462    private void detach_SingleObjectiveSolutions(SingleObjectiveSolution entity)
2463    {
2464      this.SendPropertyChanging();
2465      entity.BinaryData = null;
2466    }
2467  }
2468 
2469  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Run")]
2470  public partial class Run : INotifyPropertyChanging, INotifyPropertyChanged
2471  {
2472   
2473    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2474   
2475    private long _Id;
2476   
2477    private long _AlgorithmId;
2478   
2479    private long _ProblemId;
2480   
2481    private System.DateTime _CreatedDate;
2482   
2483    private System.Guid _UserId;
2484   
2485    private System.Guid _ClientId;
2486   
2487    private EntitySet<Value> _Values;
2488   
2489    private EntitySet<SingleObjectiveSolution> _SingleObjectiveSolutions;
2490   
2491    private EntityRef<Algorithm> _Algorithm;
2492   
2493    private EntityRef<Problem> _Problem;
2494   
2495    #region Extensibility Method Definitions
2496    partial void OnLoaded();
2497    partial void OnValidate(System.Data.Linq.ChangeAction action);
2498    partial void OnCreated();
2499    partial void OnIdChanging(long value);
2500    partial void OnIdChanged();
2501    partial void OnAlgorithmIdChanging(long value);
2502    partial void OnAlgorithmIdChanged();
2503    partial void OnProblemIdChanging(long value);
2504    partial void OnProblemIdChanged();
2505    partial void OnCreatedDateChanging(System.DateTime value);
2506    partial void OnCreatedDateChanged();
2507    partial void OnUserIdChanging(System.Guid value);
2508    partial void OnUserIdChanged();
2509    partial void OnClientIdChanging(System.Guid value);
2510    partial void OnClientIdChanged();
2511    #endregion
2512   
2513    public Run()
2514    {
2515      this._Values = new EntitySet<Value>(new Action<Value>(this.attach_Values), new Action<Value>(this.detach_Values));
2516      this._SingleObjectiveSolutions = new EntitySet<SingleObjectiveSolution>(new Action<SingleObjectiveSolution>(this.attach_SingleObjectiveSolutions), new Action<SingleObjectiveSolution>(this.detach_SingleObjectiveSolutions));
2517      this._Algorithm = default(EntityRef<Algorithm>);
2518      this._Problem = default(EntityRef<Problem>);
2519      OnCreated();
2520    }
2521   
2522    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true)]
2523    public long Id
2524    {
2525      get
2526      {
2527        return this._Id;
2528      }
2529      set
2530      {
2531        if ((this._Id != value))
2532        {
2533          this.OnIdChanging(value);
2534          this.SendPropertyChanging();
2535          this._Id = value;
2536          this.SendPropertyChanged("Id");
2537          this.OnIdChanged();
2538        }
2539      }
2540    }
2541   
2542    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_AlgorithmId", DbType="BigInt NOT NULL")]
2543    public long AlgorithmId
2544    {
2545      get
2546      {
2547        return this._AlgorithmId;
2548      }
2549      set
2550      {
2551        if ((this._AlgorithmId != value))
2552        {
2553          if (this._Algorithm.HasLoadedOrAssignedValue)
2554          {
2555            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2556          }
2557          this.OnAlgorithmIdChanging(value);
2558          this.SendPropertyChanging();
2559          this._AlgorithmId = value;
2560          this.SendPropertyChanged("AlgorithmId");
2561          this.OnAlgorithmIdChanged();
2562        }
2563      }
2564    }
2565   
2566    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ProblemId", DbType="BigInt NOT NULL")]
2567    public long ProblemId
2568    {
2569      get
2570      {
2571        return this._ProblemId;
2572      }
2573      set
2574      {
2575        if ((this._ProblemId != value))
2576        {
2577          if (this._Problem.HasLoadedOrAssignedValue)
2578          {
2579            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2580          }
2581          this.OnProblemIdChanging(value);
2582          this.SendPropertyChanging();
2583          this._ProblemId = value;
2584          this.SendPropertyChanged("ProblemId");
2585          this.OnProblemIdChanged();
2586        }
2587      }
2588    }
2589   
2590    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CreatedDate", DbType="DateTime2 NOT NULL")]
2591    public System.DateTime CreatedDate
2592    {
2593      get
2594      {
2595        return this._CreatedDate;
2596      }
2597      set
2598      {
2599        if ((this._CreatedDate != value))
2600        {
2601          this.OnCreatedDateChanging(value);
2602          this.SendPropertyChanging();
2603          this._CreatedDate = value;
2604          this.SendPropertyChanged("CreatedDate");
2605          this.OnCreatedDateChanged();
2606        }
2607      }
2608    }
2609   
2610    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL")]
2611    public System.Guid UserId
2612    {
2613      get
2614      {
2615        return this._UserId;
2616      }
2617      set
2618      {
2619        if ((this._UserId != value))
2620        {
2621          this.OnUserIdChanging(value);
2622          this.SendPropertyChanging();
2623          this._UserId = value;
2624          this.SendPropertyChanged("UserId");
2625          this.OnUserIdChanged();
2626        }
2627      }
2628    }
2629   
2630    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ClientId", DbType="UniqueIdentifier NOT NULL")]
2631    public System.Guid ClientId
2632    {
2633      get
2634      {
2635        return this._ClientId;
2636      }
2637      set
2638      {
2639        if ((this._ClientId != value))
2640        {
2641          this.OnClientIdChanging(value);
2642          this.SendPropertyChanging();
2643          this._ClientId = value;
2644          this.SendPropertyChanged("ClientId");
2645          this.OnClientIdChanged();
2646        }
2647      }
2648    }
2649   
2650    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Run_Value", Storage="_Values", ThisKey="Id", OtherKey="RunId")]
2651    public EntitySet<Value> Values
2652    {
2653      get
2654      {
2655        return this._Values;
2656      }
2657      set
2658      {
2659        this._Values.Assign(value);
2660      }
2661    }
2662   
2663    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Run_SingleObjectiveSolution", Storage="_SingleObjectiveSolutions", ThisKey="Id", OtherKey="RunId")]
2664    public EntitySet<SingleObjectiveSolution> SingleObjectiveSolutions
2665    {
2666      get
2667      {
2668        return this._SingleObjectiveSolutions;
2669      }
2670      set
2671      {
2672        this._SingleObjectiveSolutions.Assign(value);
2673      }
2674    }
2675   
2676    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Algorithm_Run", Storage="_Algorithm", ThisKey="AlgorithmId", OtherKey="Id", IsForeignKey=true)]
2677    public Algorithm Algorithm
2678    {
2679      get
2680      {
2681        return this._Algorithm.Entity;
2682      }
2683      set
2684      {
2685        Algorithm previousValue = this._Algorithm.Entity;
2686        if (((previousValue != value)
2687              || (this._Algorithm.HasLoadedOrAssignedValue == false)))
2688        {
2689          this.SendPropertyChanging();
2690          if ((previousValue != null))
2691          {
2692            this._Algorithm.Entity = null;
2693            previousValue.Runs.Remove(this);
2694          }
2695          this._Algorithm.Entity = value;
2696          if ((value != null))
2697          {
2698            value.Runs.Add(this);
2699            this._AlgorithmId = value.Id;
2700          }
2701          else
2702          {
2703            this._AlgorithmId = default(long);
2704          }
2705          this.SendPropertyChanged("Algorithm");
2706        }
2707      }
2708    }
2709   
2710    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Problem_Run", Storage="_Problem", ThisKey="ProblemId", OtherKey="Id", IsForeignKey=true)]
2711    public Problem Problem
2712    {
2713      get
2714      {
2715        return this._Problem.Entity;
2716      }
2717      set
2718      {
2719        Problem previousValue = this._Problem.Entity;
2720        if (((previousValue != value)
2721              || (this._Problem.HasLoadedOrAssignedValue == false)))
2722        {
2723          this.SendPropertyChanging();
2724          if ((previousValue != null))
2725          {
2726            this._Problem.Entity = null;
2727            previousValue.Runs.Remove(this);
2728          }
2729          this._Problem.Entity = value;
2730          if ((value != null))
2731          {
2732            value.Runs.Add(this);
2733            this._ProblemId = value.Id;
2734          }
2735          else
2736          {
2737            this._ProblemId = default(long);
2738          }
2739          this.SendPropertyChanged("Problem");
2740        }
2741      }
2742    }
2743   
2744    public event PropertyChangingEventHandler PropertyChanging;
2745   
2746    public event PropertyChangedEventHandler PropertyChanged;
2747   
2748    protected virtual void SendPropertyChanging()
2749    {
2750      if ((this.PropertyChanging != null))
2751      {
2752        this.PropertyChanging(this, emptyChangingEventArgs);
2753      }
2754    }
2755   
2756    protected virtual void SendPropertyChanged(String propertyName)
2757    {
2758      if ((this.PropertyChanged != null))
2759      {
2760        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2761      }
2762    }
2763   
2764    private void attach_Values(Value entity)
2765    {
2766      this.SendPropertyChanging();
2767      entity.Run = this;
2768    }
2769   
2770    private void detach_Values(Value entity)
2771    {
2772      this.SendPropertyChanging();
2773      entity.Run = null;
2774    }
2775   
2776    private void attach_SingleObjectiveSolutions(SingleObjectiveSolution entity)
2777    {
2778      this.SendPropertyChanging();
2779      entity.Run = this;
2780    }
2781   
2782    private void detach_SingleObjectiveSolutions(SingleObjectiveSolution entity)
2783    {
2784      this.SendPropertyChanging();
2785      entity.Run = null;
2786    }
2787  }
2788 
2789  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Value")]
2790  public partial class Value : INotifyPropertyChanging, INotifyPropertyChanged
2791  {
2792   
2793    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2794   
2795    private long _Id;
2796   
2797    private long _RunId;
2798   
2799    private long _ValueNameId;
2800   
2801    private long _DataTypeId;
2802   
2803    private System.Nullable<bool> _BoolValue;
2804   
2805    private System.Nullable<int> _IntValue;
2806   
2807    private System.Nullable<long> _LongValue;
2808   
2809    private System.Nullable<float> _FloatValue;
2810   
2811    private System.Nullable<double> _DoubleValue;
2812   
2813    private string _StringValue;
2814   
2815    private System.Nullable<long> _BinaryDataId;
2816   
2817    private EntityRef<BinaryData> _BinaryData;
2818   
2819    private EntityRef<DataType> _DataType;
2820   
2821    private EntityRef<Run> _Run;
2822   
2823    private EntityRef<ValueName> _ValueName;
2824   
2825    #region Extensibility Method Definitions
2826    partial void OnLoaded();
2827    partial void OnValidate(System.Data.Linq.ChangeAction action);
2828    partial void OnCreated();
2829    partial void OnIdChanging(long value);
2830    partial void OnIdChanged();
2831    partial void OnRunIdChanging(long value);
2832    partial void OnRunIdChanged();
2833    partial void OnValueNameIdChanging(long value);
2834    partial void OnValueNameIdChanged();
2835    partial void OnDataTypeIdChanging(long value);
2836    partial void OnDataTypeIdChanged();
2837    partial void OnBoolValueChanging(System.Nullable<bool> value);
2838    partial void OnBoolValueChanged();
2839    partial void OnIntValueChanging(System.Nullable<int> value);
2840    partial void OnIntValueChanged();
2841    partial void OnLongValueChanging(System.Nullable<long> value);
2842    partial void OnLongValueChanged();
2843    partial void OnFloatValueChanging(System.Nullable<float> value);
2844    partial void OnFloatValueChanged();
2845    partial void OnDoubleValueChanging(System.Nullable<double> value);
2846    partial void OnDoubleValueChanged();
2847    partial void OnStringValueChanging(string value);
2848    partial void OnStringValueChanged();
2849    partial void OnBinaryDataIdChanging(System.Nullable<long> value);
2850    partial void OnBinaryDataIdChanged();
2851    #endregion
2852   
2853    public Value()
2854    {
2855      this._BinaryData = default(EntityRef<BinaryData>);
2856      this._DataType = default(EntityRef<DataType>);
2857      this._Run = default(EntityRef<Run>);
2858      this._ValueName = default(EntityRef<ValueName>);
2859      OnCreated();
2860    }
2861   
2862    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true)]
2863    public long Id
2864    {
2865      get
2866      {
2867        return this._Id;
2868      }
2869      set
2870      {
2871        if ((this._Id != value))
2872        {
2873          this.OnIdChanging(value);
2874          this.SendPropertyChanging();
2875          this._Id = value;
2876          this.SendPropertyChanged("Id");
2877          this.OnIdChanged();
2878        }
2879      }
2880    }
2881   
2882    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_RunId", DbType="BigInt NOT NULL")]
2883    public long RunId
2884    {
2885      get
2886      {
2887        return this._RunId;
2888      }
2889      set
2890      {
2891        if ((this._RunId != value))
2892        {
2893          if (this._Run.HasLoadedOrAssignedValue)
2894          {
2895            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2896          }
2897          this.OnRunIdChanging(value);
2898          this.SendPropertyChanging();
2899          this._RunId = value;
2900          this.SendPropertyChanged("RunId");
2901          this.OnRunIdChanged();
2902        }
2903      }
2904    }
2905   
2906    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ValueNameId", DbType="BigInt NOT NULL")]
2907    public long ValueNameId
2908    {
2909      get
2910      {
2911        return this._ValueNameId;
2912      }
2913      set
2914      {
2915        if ((this._ValueNameId != value))
2916        {
2917          if (this._ValueName.HasLoadedOrAssignedValue)
2918          {
2919            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2920          }
2921          this.OnValueNameIdChanging(value);
2922          this.SendPropertyChanging();
2923          this._ValueNameId = value;
2924          this.SendPropertyChanged("ValueNameId");
2925          this.OnValueNameIdChanged();
2926        }
2927      }
2928    }
2929   
2930    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DataTypeId", DbType="BigInt NOT NULL")]
2931    public long DataTypeId
2932    {
2933      get
2934      {
2935        return this._DataTypeId;
2936      }
2937      set
2938      {
2939        if ((this._DataTypeId != value))
2940        {
2941          if (this._DataType.HasLoadedOrAssignedValue)
2942          {
2943            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2944          }
2945          this.OnDataTypeIdChanging(value);
2946          this.SendPropertyChanging();
2947          this._DataTypeId = value;
2948          this.SendPropertyChanged("DataTypeId");
2949          this.OnDataTypeIdChanged();
2950        }
2951      }
2952    }
2953   
2954    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_BoolValue", DbType="Bit")]
2955    public System.Nullable<bool> BoolValue
2956    {
2957      get
2958      {
2959        return this._BoolValue;
2960      }
2961      set
2962      {
2963        if ((this._BoolValue != value))
2964        {
2965          this.OnBoolValueChanging(value);
2966          this.SendPropertyChanging();
2967          this._BoolValue = value;
2968          this.SendPropertyChanged("BoolValue");
2969          this.OnBoolValueChanged();
2970        }
2971      }
2972    }
2973   
2974    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IntValue", DbType="Int")]
2975    public System.Nullable<int> IntValue
2976    {
2977      get
2978      {
2979        return this._IntValue;
2980      }
2981      set
2982      {
2983        if ((this._IntValue != value))
2984        {
2985          this.OnIntValueChanging(value);
2986          this.SendPropertyChanging();
2987          this._IntValue = value;
2988          this.SendPropertyChanged("IntValue");
2989          this.OnIntValueChanged();
2990        }
2991      }
2992    }
2993   
2994    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LongValue", DbType="BigInt")]
2995    public System.Nullable<long> LongValue
2996    {
2997      get
2998      {
2999        return this._LongValue;
3000      }
3001      set
3002      {
3003        if ((this._LongValue != value))
3004        {
3005          this.OnLongValueChanging(value);
3006          this.SendPropertyChanging();
3007          this._LongValue = value;
3008          this.SendPropertyChanged("LongValue");
3009          this.OnLongValueChanged();
3010        }
3011      }
3012    }
3013   
3014    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_FloatValue", DbType="Real")]
3015    public System.Nullable<float> FloatValue
3016    {
3017      get
3018      {
3019        return this._FloatValue;
3020      }
3021      set
3022      {
3023        if ((this._FloatValue != value))
3024        {
3025          this.OnFloatValueChanging(value);
3026          this.SendPropertyChanging();
3027          this._FloatValue = value;
3028          this.SendPropertyChanged("FloatValue");
3029          this.OnFloatValueChanged();
3030        }
3031      }
3032    }
3033   
3034    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DoubleValue", DbType="Float")]
3035    public System.Nullable<double> DoubleValue
3036    {
3037      get
3038      {
3039        return this._DoubleValue;
3040      }
3041      set
3042      {
3043        if ((this._DoubleValue != value))
3044        {
3045          this.OnDoubleValueChanging(value);
3046          this.SendPropertyChanging();
3047          this._DoubleValue = value;
3048          this.SendPropertyChanged("DoubleValue");
3049          this.OnDoubleValueChanged();
3050        }
3051      }
3052    }
3053   
3054    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StringValue", DbType="NVarChar(MAX)")]
3055    public string StringValue
3056    {
3057      get
3058      {
3059        return this._StringValue;
3060      }
3061      set
3062      {
3063        if ((this._StringValue != value))
3064        {
3065          this.OnStringValueChanging(value);
3066          this.SendPropertyChanging();
3067          this._StringValue = value;
3068          this.SendPropertyChanged("StringValue");
3069          this.OnStringValueChanged();
3070        }
3071      }
3072    }
3073   
3074    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_BinaryDataId", DbType="BigInt")]
3075    public System.Nullable<long> BinaryDataId
3076    {
3077      get
3078      {
3079        return this._BinaryDataId;
3080      }
3081      set
3082      {
3083        if ((this._BinaryDataId != value))
3084        {
3085          if (this._BinaryData.HasLoadedOrAssignedValue)
3086          {
3087            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3088          }
3089          this.OnBinaryDataIdChanging(value);
3090          this.SendPropertyChanging();
3091          this._BinaryDataId = value;
3092          this.SendPropertyChanged("BinaryDataId");
3093          this.OnBinaryDataIdChanged();
3094        }
3095      }
3096    }
3097   
3098    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="BinaryData_Value", Storage="_BinaryData", ThisKey="BinaryDataId", OtherKey="Id", IsForeignKey=true)]
3099    public BinaryData BinaryData
3100    {
3101      get
3102      {
3103        return this._BinaryData.Entity;
3104      }
3105      set
3106      {
3107        BinaryData previousValue = this._BinaryData.Entity;
3108        if (((previousValue != value)
3109              || (this._BinaryData.HasLoadedOrAssignedValue == false)))
3110        {
3111          this.SendPropertyChanging();
3112          if ((previousValue != null))
3113          {
3114            this._BinaryData.Entity = null;
3115            previousValue.Values.Remove(this);
3116          }
3117          this._BinaryData.Entity = value;
3118          if ((value != null))
3119          {
3120            value.Values.Add(this);
3121            this._BinaryDataId = value.Id;
3122          }
3123          else
3124          {
3125            this._BinaryDataId = default(Nullable<long>);
3126          }
3127          this.SendPropertyChanged("BinaryData");
3128        }
3129      }
3130    }
3131   
3132    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DataType_Value", Storage="_DataType", ThisKey="DataTypeId", OtherKey="Id", IsForeignKey=true)]
3133    public DataType DataType
3134    {
3135      get
3136      {
3137        return this._DataType.Entity;
3138      }
3139      set
3140      {
3141        DataType previousValue = this._DataType.Entity;
3142        if (((previousValue != value)
3143              || (this._DataType.HasLoadedOrAssignedValue == false)))
3144        {
3145          this.SendPropertyChanging();
3146          if ((previousValue != null))
3147          {
3148            this._DataType.Entity = null;
3149            previousValue.Values.Remove(this);
3150          }
3151          this._DataType.Entity = value;
3152          if ((value != null))
3153          {
3154            value.Values.Add(this);
3155            this._DataTypeId = value.Id;
3156          }
3157          else
3158          {
3159            this._DataTypeId = default(long);
3160          }
3161          this.SendPropertyChanged("DataType");
3162        }
3163      }
3164    }
3165   
3166    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Run_Value", Storage="_Run", ThisKey="RunId", OtherKey="Id", IsForeignKey=true)]
3167    public Run Run
3168    {
3169      get
3170      {
3171        return this._Run.Entity;
3172      }
3173      set
3174      {
3175        Run previousValue = this._Run.Entity;
3176        if (((previousValue != value)
3177              || (this._Run.HasLoadedOrAssignedValue == false)))
3178        {
3179          this.SendPropertyChanging();
3180          if ((previousValue != null))
3181          {
3182            this._Run.Entity = null;
3183            previousValue.Values.Remove(this);
3184          }
3185          this._Run.Entity = value;
3186          if ((value != null))
3187          {
3188            value.Values.Add(this);
3189            this._RunId = value.Id;
3190          }
3191          else
3192          {
3193            this._RunId = default(long);
3194          }
3195          this.SendPropertyChanged("Run");
3196        }
3197      }
3198    }
3199   
3200    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="ValueName_Value", Storage="_ValueName", ThisKey="ValueNameId", OtherKey="Id", IsForeignKey=true)]
3201    public ValueName ValueName
3202    {
3203      get
3204      {
3205        return this._ValueName.Entity;
3206      }
3207      set
3208      {
3209        ValueName previousValue = this._ValueName.Entity;
3210        if (((previousValue != value)
3211              || (this._ValueName.HasLoadedOrAssignedValue == false)))
3212        {
3213          this.SendPropertyChanging();
3214          if ((previousValue != null))
3215          {
3216            this._ValueName.Entity = null;
3217            previousValue.Values.Remove(this);
3218          }
3219          this._ValueName.Entity = value;
3220          if ((value != null))
3221          {
3222            value.Values.Add(this);
3223            this._ValueNameId = value.Id;
3224          }
3225          else
3226          {
3227            this._ValueNameId = default(long);
3228          }
3229          this.SendPropertyChanged("ValueName");
3230        }
3231      }
3232    }
3233   
3234    public event PropertyChangingEventHandler PropertyChanging;
3235   
3236    public event PropertyChangedEventHandler PropertyChanged;
3237   
3238    protected virtual void SendPropertyChanging()
3239    {
3240      if ((this.PropertyChanging != null))
3241      {
3242        this.PropertyChanging(this, emptyChangingEventArgs);
3243      }
3244    }
3245   
3246    protected virtual void SendPropertyChanged(String propertyName)
3247    {
3248      if ((this.PropertyChanged != null))
3249      {
3250        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3251      }
3252    }
3253  }
3254 
3255  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Characteristic")]
3256  public partial class Characteristic : INotifyPropertyChanging, INotifyPropertyChanged
3257  {
3258   
3259    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3260   
3261    private long _Id;
3262   
3263    private string _Name;
3264   
3265    private CharacteristicType _Type;
3266   
3267    private EntitySet<CharacteristicValue> _CharacteristicValues;
3268   
3269    #region Extensibility Method Definitions
3270    partial void OnLoaded();
3271    partial void OnValidate(System.Data.Linq.ChangeAction action);
3272    partial void OnCreated();
3273    partial void OnIdChanging(long value);
3274    partial void OnIdChanged();
3275    partial void OnNameChanging(string value);
3276    partial void OnNameChanged();
3277    partial void OnTypeChanging(CharacteristicType value);
3278    partial void OnTypeChanged();
3279    #endregion
3280   
3281    public Characteristic()
3282    {
3283      this._CharacteristicValues = new EntitySet<CharacteristicValue>(new Action<CharacteristicValue>(this.attach_CharacteristicValues), new Action<CharacteristicValue>(this.detach_CharacteristicValues));
3284      OnCreated();
3285    }
3286   
3287    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true)]
3288    public long Id
3289    {
3290      get
3291      {
3292        return this._Id;
3293      }
3294      set
3295      {
3296        if ((this._Id != value))
3297        {
3298          this.OnIdChanging(value);
3299          this.SendPropertyChanging();
3300          this._Id = value;
3301          this.SendPropertyChanged("Id");
3302          this.OnIdChanged();
3303        }
3304      }
3305    }
3306   
3307    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(200) NOT NULL", CanBeNull=false)]
3308    public string Name
3309    {
3310      get
3311      {
3312        return this._Name;
3313      }
3314      set
3315      {
3316        if ((this._Name != value))
3317        {
3318          this.OnNameChanging(value);
3319          this.SendPropertyChanging();
3320          this._Name = value;
3321          this.SendPropertyChanged("Name");
3322          this.OnNameChanged();
3323        }
3324      }
3325    }
3326   
3327    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Type", DbType="TinyInt NOT NULL", CanBeNull=false)]
3328    public CharacteristicType Type
3329    {
3330      get
3331      {
3332        return this._Type;
3333      }
3334      set
3335      {
3336        if ((this._Type != value))
3337        {
3338          this.OnTypeChanging(value);
3339          this.SendPropertyChanging();
3340          this._Type = value;
3341          this.SendPropertyChanged("Type");
3342          this.OnTypeChanged();
3343        }
3344      }
3345    }
3346   
3347    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Characteristic_CharacteristicValue", Storage="_CharacteristicValues", ThisKey="Id", OtherKey="CharacteristicId")]
3348    public EntitySet<CharacteristicValue> CharacteristicValues
3349    {
3350      get
3351      {
3352        return this._CharacteristicValues;
3353      }
3354      set
3355      {
3356        this._CharacteristicValues.Assign(value);
3357      }
3358    }
3359   
3360    public event PropertyChangingEventHandler PropertyChanging;
3361   
3362    public event PropertyChangedEventHandler PropertyChanged;
3363   
3364    protected virtual void SendPropertyChanging()
3365    {
3366      if ((this.PropertyChanging != null))
3367      {
3368        this.PropertyChanging(this, emptyChangingEventArgs);
3369      }
3370    }
3371   
3372    protected virtual void SendPropertyChanged(String propertyName)
3373    {
3374      if ((this.PropertyChanged != null))
3375      {
3376        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3377      }
3378    }
3379   
3380    private void attach_CharacteristicValues(CharacteristicValue entity)
3381    {
3382      this.SendPropertyChanging();
3383      entity.Characteristic = this;
3384    }
3385   
3386    private void detach_CharacteristicValues(CharacteristicValue entity)
3387    {
3388      this.SendPropertyChanging();
3389      entity.Characteristic = null;
3390    }
3391  }
3392 
3393  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.CharacteristicValue")]
3394  public partial class CharacteristicValue : INotifyPropertyChanging, INotifyPropertyChanged
3395  {
3396   
3397    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3398   
3399    private long _Id;
3400   
3401    private long _ProblemId;
3402   
3403    private long _CharacteristicId;
3404   
3405    private long _DataTypeId;
3406   
3407    private System.Nullable<bool> _BoolValue;
3408   
3409    private System.Nullable<int> _IntValue;
3410   
3411    private System.Nullable<long> _LongValue;
3412   
3413    private System.Nullable<float> _FloatValue;
3414   
3415    private System.Nullable<double> _DoubleValue;
3416   
3417    private string _StringValue;
3418   
3419    private EntityRef<Characteristic> _Characteristic;
3420   
3421    private EntityRef<DataType> _DataType;
3422   
3423    private EntityRef<Problem> _Problem;
3424   
3425    #region Extensibility Method Definitions
3426    partial void OnLoaded();
3427    partial void OnValidate(System.Data.Linq.ChangeAction action);
3428    partial void OnCreated();
3429    partial void OnIdChanging(long value);
3430    partial void OnIdChanged();
3431    partial void OnProblemIdChanging(long value);
3432    partial void OnProblemIdChanged();
3433    partial void OnCharacteristicIdChanging(long value);
3434    partial void OnCharacteristicIdChanged();
3435    partial void OnDataTypeIdChanging(long value);
3436    partial void OnDataTypeIdChanged();
3437    partial void OnBoolValueChanging(System.Nullable<bool> value);
3438    partial void OnBoolValueChanged();
3439    partial void OnIntValueChanging(System.Nullable<int> value);
3440    partial void OnIntValueChanged();
3441    partial void OnLongValueChanging(System.Nullable<long> value);
3442    partial void OnLongValueChanged();
3443    partial void OnFloatValueChanging(System.Nullable<float> value);
3444    partial void OnFloatValueChanged();
3445    partial void OnDoubleValueChanging(System.Nullable<double> value);
3446    partial void OnDoubleValueChanged();
3447    partial void OnStringValueChanging(string value);
3448    partial void OnStringValueChanged();
3449    #endregion
3450   
3451    public CharacteristicValue()
3452    {
3453      this._Characteristic = default(EntityRef<Characteristic>);
3454      this._DataType = default(EntityRef<DataType>);
3455      this._Problem = default(EntityRef<Problem>);
3456      OnCreated();
3457    }
3458   
3459    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true)]
3460    public long Id
3461    {
3462      get
3463      {
3464        return this._Id;
3465      }
3466      set
3467      {
3468        if ((this._Id != value))
3469        {
3470          this.OnIdChanging(value);
3471          this.SendPropertyChanging();
3472          this._Id = value;
3473          this.SendPropertyChanged("Id");
3474          this.OnIdChanged();
3475        }
3476      }
3477    }
3478   
3479    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ProblemId", DbType="BigInt NOT NULL")]
3480    public long ProblemId
3481    {
3482      get
3483      {
3484        return this._ProblemId;
3485      }
3486      set
3487      {
3488        if ((this._ProblemId != value))
3489        {
3490          if (this._Problem.HasLoadedOrAssignedValue)
3491          {
3492            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3493          }
3494          this.OnProblemIdChanging(value);
3495          this.SendPropertyChanging();
3496          this._ProblemId = value;
3497          this.SendPropertyChanged("ProblemId");
3498          this.OnProblemIdChanged();
3499        }
3500      }
3501    }
3502   
3503    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CharacteristicId", DbType="BigInt NOT NULL")]
3504    public long CharacteristicId
3505    {
3506      get
3507      {
3508        return this._CharacteristicId;
3509      }
3510      set
3511      {
3512        if ((this._CharacteristicId != value))
3513        {
3514          if (this._Characteristic.HasLoadedOrAssignedValue)
3515          {
3516            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3517          }
3518          this.OnCharacteristicIdChanging(value);
3519          this.SendPropertyChanging();
3520          this._CharacteristicId = value;
3521          this.SendPropertyChanged("CharacteristicId");
3522          this.OnCharacteristicIdChanged();
3523        }
3524      }
3525    }
3526   
3527    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DataTypeId", DbType="BigInt NOT NULL")]
3528    public long DataTypeId
3529    {
3530      get
3531      {
3532        return this._DataTypeId;
3533      }
3534      set
3535      {
3536        if ((this._DataTypeId != value))
3537        {
3538          if (this._DataType.HasLoadedOrAssignedValue)
3539          {
3540            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3541          }
3542          this.OnDataTypeIdChanging(value);
3543          this.SendPropertyChanging();
3544          this._DataTypeId = value;
3545          this.SendPropertyChanged("DataTypeId");
3546          this.OnDataTypeIdChanged();
3547        }
3548      }
3549    }
3550   
3551    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_BoolValue", DbType="Bit")]
3552    public System.Nullable<bool> BoolValue
3553    {
3554      get
3555      {
3556        return this._BoolValue;
3557      }
3558      set
3559      {
3560        if ((this._BoolValue != value))
3561        {
3562          this.OnBoolValueChanging(value);
3563          this.SendPropertyChanging();
3564          this._BoolValue = value;
3565          this.SendPropertyChanged("BoolValue");
3566          this.OnBoolValueChanged();
3567        }
3568      }
3569    }
3570   
3571    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IntValue", DbType="Int")]
3572    public System.Nullable<int> IntValue
3573    {
3574      get
3575      {
3576        return this._IntValue;
3577      }
3578      set
3579      {
3580        if ((this._IntValue != value))
3581        {
3582          this.OnIntValueChanging(value);
3583          this.SendPropertyChanging();
3584          this._IntValue = value;
3585          this.SendPropertyChanged("IntValue");
3586          this.OnIntValueChanged();
3587        }
3588      }
3589    }
3590   
3591    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LongValue", DbType="BigInt")]
3592    public System.Nullable<long> LongValue
3593    {
3594      get
3595      {
3596        return this._LongValue;
3597      }
3598      set
3599      {
3600        if ((this._LongValue != value))
3601        {
3602          this.OnLongValueChanging(value);
3603          this.SendPropertyChanging();
3604          this._LongValue = value;
3605          this.SendPropertyChanged("LongValue");
3606          this.OnLongValueChanged();
3607        }
3608      }
3609    }
3610   
3611    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_FloatValue", DbType="Real")]
3612    public System.Nullable<float> FloatValue
3613    {
3614      get
3615      {
3616        return this._FloatValue;
3617      }
3618      set
3619      {
3620        if ((this._FloatValue != value))
3621        {
3622          this.OnFloatValueChanging(value);
3623          this.SendPropertyChanging();
3624          this._FloatValue = value;
3625          this.SendPropertyChanged("FloatValue");
3626          this.OnFloatValueChanged();
3627        }
3628      }
3629    }
3630   
3631    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DoubleValue", DbType="Float")]
3632    public System.Nullable<double> DoubleValue
3633    {
3634      get
3635      {
3636        return this._DoubleValue;
3637      }
3638      set
3639      {
3640        if ((this._DoubleValue != value))
3641        {
3642          this.OnDoubleValueChanging(value);
3643          this.SendPropertyChanging();
3644          this._DoubleValue = value;
3645          this.SendPropertyChanged("DoubleValue");
3646          this.OnDoubleValueChanged();
3647        }
3648      }
3649    }
3650   
3651    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StringValue", DbType="NVarChar(MAX)")]
3652    public string StringValue
3653    {
3654      get
3655      {
3656        return this._StringValue;
3657      }
3658      set
3659      {
3660        if ((this._StringValue != value))
3661        {
3662          this.OnStringValueChanging(value);
3663          this.SendPropertyChanging();
3664          this._StringValue = value;
3665          this.SendPropertyChanged("StringValue");
3666          this.OnStringValueChanged();
3667        }
3668      }
3669    }
3670   
3671    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Characteristic_CharacteristicValue", Storage="_Characteristic", ThisKey="CharacteristicId", OtherKey="Id", IsForeignKey=true)]
3672    public Characteristic Characteristic
3673    {
3674      get
3675      {
3676        return this._Characteristic.Entity;
3677      }
3678      set
3679      {
3680        Characteristic previousValue = this._Characteristic.Entity;
3681        if (((previousValue != value)
3682              || (this._Characteristic.HasLoadedOrAssignedValue == false)))
3683        {
3684          this.SendPropertyChanging();
3685          if ((previousValue != null))
3686          {
3687            this._Characteristic.Entity = null;
3688            previousValue.CharacteristicValues.Remove(this);
3689          }
3690          this._Characteristic.Entity = value;
3691          if ((value != null))
3692          {
3693            value.CharacteristicValues.Add(this);
3694            this._CharacteristicId = value.Id;
3695          }
3696          else
3697          {
3698            this._CharacteristicId = default(long);
3699          }
3700          this.SendPropertyChanged("Characteristic");
3701        }
3702      }
3703    }
3704   
3705    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DataType_CharacteristicValue", Storage="_DataType", ThisKey="DataTypeId", OtherKey="Id", IsForeignKey=true)]
3706    public DataType DataType
3707    {
3708      get
3709      {
3710        return this._DataType.Entity;
3711      }
3712      set
3713      {
3714        DataType previousValue = this._DataType.Entity;
3715        if (((previousValue != value)
3716              || (this._DataType.HasLoadedOrAssignedValue == false)))
3717        {
3718          this.SendPropertyChanging();
3719          if ((previousValue != null))
3720          {
3721            this._DataType.Entity = null;
3722            previousValue.CharacteristicValues.Remove(this);
3723          }
3724          this._DataType.Entity = value;
3725          if ((value != null))
3726          {
3727            value.CharacteristicValues.Add(this);
3728            this._DataTypeId = value.Id;
3729          }
3730          else
3731          {
3732            this._DataTypeId = default(long);
3733          }
3734          this.SendPropertyChanged("DataType");
3735        }
3736      }
3737    }
3738   
3739    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Problem_CharacteristicValue", Storage="_Problem", ThisKey="ProblemId", OtherKey="Id", IsForeignKey=true)]
3740    public Problem Problem
3741    {
3742      get
3743      {
3744        return this._Problem.Entity;
3745      }
3746      set
3747      {
3748        Problem previousValue = this._Problem.Entity;
3749        if (((previousValue != value)
3750              || (this._Problem.HasLoadedOrAssignedValue == false)))
3751        {
3752          this.SendPropertyChanging();
3753          if ((previousValue != null))
3754          {
3755            this._Problem.Entity = null;
3756            previousValue.CharacteristicValues.Remove(this);
3757          }
3758          this._Problem.Entity = value;
3759          if ((value != null))
3760          {
3761            value.CharacteristicValues.Add(this);
3762            this._ProblemId = value.Id;
3763          }
3764          else
3765          {
3766            this._ProblemId = default(long);
3767          }
3768          this.SendPropertyChanged("Problem");
3769        }
3770      }
3771    }
3772   
3773    public event PropertyChangingEventHandler PropertyChanging;
3774   
3775    public event PropertyChangedEventHandler PropertyChanged;
3776   
3777    protected virtual void SendPropertyChanging()
3778    {
3779      if ((this.PropertyChanging != null))
3780      {
3781        this.PropertyChanging(this, emptyChangingEventArgs);
3782      }
3783    }
3784   
3785    protected virtual void SendPropertyChanged(String propertyName)
3786    {
3787      if ((this.PropertyChanged != null))
3788      {
3789        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3790      }
3791    }
3792  }
3793 
3794  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.SingleObjectiveSolution")]
3795  public partial class SingleObjectiveSolution : INotifyPropertyChanging, INotifyPropertyChanged
3796  {
3797   
3798    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3799   
3800    private long _Id;
3801   
3802    private System.Nullable<long> _ProblemId;
3803   
3804    private System.Nullable<long> _BinaryDataId;
3805   
3806    private System.Nullable<long> _RunId;
3807   
3808    private double _Quality;
3809   
3810    private System.Nullable<long> _DataTypeId;
3811   
3812    private EntityRef<Problem> _Problem;
3813   
3814    private EntityRef<BinaryData> _BinaryData;
3815   
3816    private EntityRef<Run> _Run;
3817   
3818    private EntityRef<DataType> _DataType;
3819   
3820    #region Extensibility Method Definitions
3821    partial void OnLoaded();
3822    partial void OnValidate(System.Data.Linq.ChangeAction action);
3823    partial void OnCreated();
3824    partial void OnIdChanging(long value);
3825    partial void OnIdChanged();
3826    partial void OnProblemIdChanging(System.Nullable<long> value);
3827    partial void OnProblemIdChanged();
3828    partial void OnBinaryDataIdChanging(System.Nullable<long> value);
3829    partial void OnBinaryDataIdChanged();
3830    partial void OnRunIdChanging(System.Nullable<long> value);
3831    partial void OnRunIdChanged();
3832    partial void OnQualityChanging(double value);
3833    partial void OnQualityChanged();
3834    partial void OnDataTypeIdChanging(System.Nullable<long> value);
3835    partial void OnDataTypeIdChanged();
3836    #endregion
3837   
3838    public SingleObjectiveSolution()
3839    {
3840      this._Problem = default(EntityRef<Problem>);
3841      this._BinaryData = default(EntityRef<BinaryData>);
3842      this._Run = default(EntityRef<Run>);
3843      this._DataType = default(EntityRef<DataType>);
3844      OnCreated();
3845    }
3846   
3847    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true)]
3848    public long Id
3849    {
3850      get
3851      {
3852        return this._Id;
3853      }
3854      set
3855      {
3856        if ((this._Id != value))
3857        {
3858          this.OnIdChanging(value);
3859          this.SendPropertyChanging();
3860          this._Id = value;
3861          this.SendPropertyChanged("Id");
3862          this.OnIdChanged();
3863        }
3864      }
3865    }
3866   
3867    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ProblemId", DbType="BigInt")]
3868    public System.Nullable<long> ProblemId
3869    {
3870      get
3871      {
3872        return this._ProblemId;
3873      }
3874      set
3875      {
3876        if ((this._ProblemId != value))
3877        {
3878          if (this._Problem.HasLoadedOrAssignedValue)
3879          {
3880            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3881          }
3882          this.OnProblemIdChanging(value);
3883          this.SendPropertyChanging();
3884          this._ProblemId = value;
3885          this.SendPropertyChanged("ProblemId");
3886          this.OnProblemIdChanged();
3887        }
3888      }
3889    }
3890   
3891    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_BinaryDataId", DbType="BigInt")]
3892    public System.Nullable<long> BinaryDataId
3893    {
3894      get
3895      {
3896        return this._BinaryDataId;
3897      }
3898      set
3899      {
3900        if ((this._BinaryDataId != value))
3901        {
3902          if (this._BinaryData.HasLoadedOrAssignedValue)
3903          {
3904            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3905          }
3906          this.OnBinaryDataIdChanging(value);
3907          this.SendPropertyChanging();
3908          this._BinaryDataId = value;
3909          this.SendPropertyChanged("BinaryDataId");
3910          this.OnBinaryDataIdChanged();
3911        }
3912      }
3913    }
3914   
3915    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_RunId", DbType="BigInt")]
3916    public System.Nullable<long> RunId
3917    {
3918      get
3919      {
3920        return this._RunId;
3921      }
3922      set
3923      {
3924        if ((this._RunId != value))
3925        {
3926          if (this._Run.HasLoadedOrAssignedValue)
3927          {
3928            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3929          }
3930          this.OnRunIdChanging(value);
3931          this.SendPropertyChanging();
3932          this._RunId = value;
3933          this.SendPropertyChanged("RunId");
3934          this.OnRunIdChanged();
3935        }
3936      }
3937    }
3938   
3939    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Quality", DbType="Float")]
3940    public double Quality
3941    {
3942      get
3943      {
3944        return this._Quality;
3945      }
3946      set
3947      {
3948        if ((this._Quality != value))
3949        {
3950          this.OnQualityChanging(value);
3951          this.SendPropertyChanging();
3952          this._Quality = value;
3953          this.SendPropertyChanged("Quality");
3954          this.OnQualityChanged();
3955        }
3956      }
3957    }
3958   
3959    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DataTypeId", DbType="BigInt")]
3960    public System.Nullable<long> DataTypeId
3961    {
3962      get
3963      {
3964        return this._DataTypeId;
3965      }
3966      set
3967      {
3968        if ((this._DataTypeId != value))
3969        {
3970          if (this._DataType.HasLoadedOrAssignedValue)
3971          {
3972            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3973          }
3974          this.OnDataTypeIdChanging(value);
3975          this.SendPropertyChanging();
3976          this._DataTypeId = value;
3977          this.SendPropertyChanged("DataTypeId");
3978          this.OnDataTypeIdChanged();
3979        }
3980      }
3981    }
3982   
3983    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Problem_SingleObjectiveSolution", Storage="_Problem", ThisKey="ProblemId", OtherKey="Id", IsForeignKey=true)]
3984    public Problem Problem
3985    {
3986      get
3987      {
3988        return this._Problem.Entity;
3989      }
3990      set
3991      {
3992        Problem previousValue = this._Problem.Entity;
3993        if (((previousValue != value)
3994              || (this._Problem.HasLoadedOrAssignedValue == false)))
3995        {
3996          this.SendPropertyChanging();
3997          if ((previousValue != null))
3998          {
3999            this._Problem.Entity = null;
4000            previousValue.SingleObjectiveSolutions.Remove(this);
4001          }
4002          this._Problem.Entity = value;
4003          if ((value != null))
4004          {
4005            value.SingleObjectiveSolutions.Add(this);
4006            this._ProblemId = value.Id;
4007          }
4008          else
4009          {
4010            this._ProblemId = default(Nullable<long>);
4011          }
4012          this.SendPropertyChanged("Problem");
4013        }
4014      }
4015    }
4016   
4017    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="BinaryData_SingleObjectiveSolution", Storage="_BinaryData", ThisKey="BinaryDataId", OtherKey="Id", IsForeignKey=true)]
4018    public BinaryData BinaryData
4019    {
4020      get
4021      {
4022        return this._BinaryData.Entity;
4023      }
4024      set
4025      {
4026        BinaryData previousValue = this._BinaryData.Entity;
4027        if (((previousValue != value)
4028              || (this._BinaryData.HasLoadedOrAssignedValue == false)))
4029        {
4030          this.SendPropertyChanging();
4031          if ((previousValue != null))
4032          {
4033            this._BinaryData.Entity = null;
4034            previousValue.SingleObjectiveSolutions.Remove(this);
4035          }
4036          this._BinaryData.Entity = value;
4037          if ((value != null))
4038          {
4039            value.SingleObjectiveSolutions.Add(this);
4040            this._BinaryDataId = value.Id;
4041          }
4042          else
4043          {
4044            this._BinaryDataId = default(Nullable<long>);
4045          }
4046          this.SendPropertyChanged("BinaryData");
4047        }
4048      }
4049    }
4050   
4051    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Run_SingleObjectiveSolution", Storage="_Run", ThisKey="RunId", OtherKey="Id", IsForeignKey=true)]
4052    public Run Run
4053    {
4054      get
4055      {
4056        return this._Run.Entity;
4057      }
4058      set
4059      {
4060        Run previousValue = this._Run.Entity;
4061        if (((previousValue != value)
4062              || (this._Run.HasLoadedOrAssignedValue == false)))
4063        {
4064          this.SendPropertyChanging();
4065          if ((previousValue != null))
4066          {
4067            this._Run.Entity = null;
4068            previousValue.SingleObjectiveSolutions.Remove(this);
4069          }
4070          this._Run.Entity = value;
4071          if ((value != null))
4072          {
4073            value.SingleObjectiveSolutions.Add(this);
4074            this._RunId = value.Id;
4075          }
4076          else
4077          {
4078            this._RunId = default(Nullable<long>);
4079          }
4080          this.SendPropertyChanged("Run");
4081        }
4082      }
4083    }
4084   
4085    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DataType_SingleObjectiveSolution", Storage="_DataType", ThisKey="DataTypeId", OtherKey="Id", IsForeignKey=true)]
4086    public DataType DataType
4087    {
4088      get
4089      {
4090        return this._DataType.Entity;
4091      }
4092      set
4093      {
4094        DataType previousValue = this._DataType.Entity;
4095        if (((previousValue != value)
4096              || (this._DataType.HasLoadedOrAssignedValue == false)))
4097        {
4098          this.SendPropertyChanging();
4099          if ((previousValue != null))
4100          {
4101            this._DataType.Entity = null;
4102            previousValue.SingleObjectiveSolutions.Remove(this);
4103          }
4104          this._DataType.Entity = value;
4105          if ((value != null))
4106          {
4107            value.SingleObjectiveSolutions.Add(this);
4108            this._DataTypeId = value.Id;
4109          }
4110          else
4111          {
4112            this._DataTypeId = default(Nullable<long>);
4113          }
4114          this.SendPropertyChanged("DataType");
4115        }
4116      }
4117    }
4118   
4119    public event PropertyChangingEventHandler PropertyChanging;
4120   
4121    public event PropertyChangedEventHandler PropertyChanged;
4122   
4123    protected virtual void SendPropertyChanging()
4124    {
4125      if ((this.PropertyChanging != null))
4126      {
4127        this.PropertyChanging(this, emptyChangingEventArgs);
4128      }
4129    }
4130   
4131    protected virtual void SendPropertyChanged(String propertyName)
4132    {
4133      if ((this.PropertyChanged != null))
4134      {
4135        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
4136      }
4137    }
4138  }
4139}
4140#pragma warning restore 1591
Note: See TracBrowser for help on using the repository browser.