Context Navigation

source: branches/DataPreprocessing/HeuristicLab.Services.OKB.DataAccess/3.3/OKB.designer.cs @ 10187

Visit:

Last change on this file since 10187 was 8049, checked in by ascheibe, 12 years ago
#1174 integrated OKB services parts into trunk
File size: 94.1 KB

Line
1	#pragma warning disable 1591
2	//------------------------------------------------------------------------------
3	// <auto-generated>
4	// This code was generated by a tool.
5	// Runtime Version:4.0.30319.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
12	namespace 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.

Download in other formats:

Update cookies preferences