Free cookie consent management tool by TermsFeed Policy Generator

source: branches/OKB (trunk integration)/HeuristicLab.Services.OKB.DataAccess/3.3/OKB.designer.cs @ 5360

Last change on this file since 5360 was 5360, checked in by swagner, 13 years ago

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