Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.Services.OKB.DataAccess/3.3/OKB.designer.cs @ 10327

Last change on this file since 10327 was 8049, checked in by ascheibe, 12 years ago

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