Context Navigation

source: branches/2922-DataCompletenessChartPerf/HeuristicLab.Services.OKB.DataAccess/3.3/OKB.designer.cs @ 17563

Visit:

Last change on this file since 17563 was 13682, checked in by abeham, 9 years ago

Added table, FK constraints, and FK indexes to database
Updated Linq2Sql mapping
Added service methods and dtos for downloading

File size: 107.5 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Update cookies preferences