Context Navigation

source: stable/HeuristicLab.Services.Hive.DataAccess/3.3/HiveDataContext.designer.cs @ 13694

Visit:

Last change on this file since 13694 was 12963, checked in by ascheibe, 9 years ago
#2355 merged r12926, r12927 and r12959 into stable
File size: 145.9 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.Hive.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.Hive")]
26	public partial class HiveDataContext : 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 InsertAssignedResource(AssignedResource instance);
34	partial void UpdateAssignedResource(AssignedResource instance);
35	partial void DeleteAssignedResource(AssignedResource instance);
36	partial void InsertPlugin(Plugin instance);
37	partial void UpdatePlugin(Plugin instance);
38	partial void DeletePlugin(Plugin instance);
39	partial void InsertRequiredPlugin(RequiredPlugin instance);
40	partial void UpdateRequiredPlugin(RequiredPlugin instance);
41	partial void DeleteRequiredPlugin(RequiredPlugin instance);
42	partial void InsertResource(Resource instance);
43	partial void UpdateResource(Resource instance);
44	partial void DeleteResource(Resource instance);
45	partial void InsertTask(Task instance);
46	partial void UpdateTask(Task instance);
47	partial void DeleteTask(Task instance);
48	partial void InsertDowntime(Downtime instance);
49	partial void UpdateDowntime(Downtime instance);
50	partial void DeleteDowntime(Downtime instance);
51	partial void InsertJob(Job instance);
52	partial void UpdateJob(Job instance);
53	partial void DeleteJob(Job instance);
54	partial void InsertTaskData(TaskData instance);
55	partial void UpdateTaskData(TaskData instance);
56	partial void DeleteTaskData(TaskData instance);
57	partial void InsertPluginData(PluginData instance);
58	partial void UpdatePluginData(PluginData instance);
59	partial void DeletePluginData(PluginData instance);
60	partial void InsertStateLog(StateLog instance);
61	partial void UpdateStateLog(StateLog instance);
62	partial void DeleteStateLog(StateLog instance);
63	partial void InsertJobPermission(JobPermission instance);
64	partial void UpdateJobPermission(JobPermission instance);
65	partial void DeleteJobPermission(JobPermission instance);
66	partial void InsertLifecycle(Lifecycle instance);
67	partial void UpdateLifecycle(Lifecycle instance);
68	partial void DeleteLifecycle(Lifecycle instance);
69	partial void InsertResourcePermission(ResourcePermission instance);
70	partial void UpdateResourcePermission(ResourcePermission instance);
71	partial void DeleteResourcePermission(ResourcePermission instance);
72	partial void InsertUserPriority(UserPriority instance);
73	partial void UpdateUserPriority(UserPriority instance);
74	partial void DeleteUserPriority(UserPriority instance);
75	partial void InsertDimClient(DimClient instance);
76	partial void UpdateDimClient(DimClient instance);
77	partial void DeleteDimClient(DimClient instance);
78	partial void InsertFactTask(FactTask instance);
79	partial void UpdateFactTask(FactTask instance);
80	partial void DeleteFactTask(FactTask instance);
81	partial void InsertDimJob(DimJob instance);
82	partial void UpdateDimJob(DimJob instance);
83	partial void DeleteDimJob(DimJob instance);
84	partial void InsertDimTime(DimTime instance);
85	partial void UpdateDimTime(DimTime instance);
86	partial void DeleteDimTime(DimTime instance);
87	partial void InsertDimUser(DimUser instance);
88	partial void UpdateDimUser(DimUser instance);
89	partial void DeleteDimUser(DimUser instance);
90	partial void InsertFactClientInfo(FactClientInfo instance);
91	partial void UpdateFactClientInfo(FactClientInfo instance);
92	partial void DeleteFactClientInfo(FactClientInfo instance);
93	#endregion
94
95	public HiveDataContext() :
96	base(global::HeuristicLab.Services.Hive.DataAccess.Settings.Default.HeuristicLab_Hive_LinqConnectionString, mappingSource)
97	{
98	OnCreated();
99	}
100
101	public HiveDataContext(string connection) :
102	base(connection, mappingSource)
103	{
104	OnCreated();
105	}
106
107	public HiveDataContext(System.Data.IDbConnection connection) :
108	base(connection, mappingSource)
109	{
110	OnCreated();
111	}
112
113	public HiveDataContext(string connection, System.Data.Linq.Mapping.MappingSource mappingSource) :
114	base(connection, mappingSource)
115	{
116	OnCreated();
117	}
118
119	public HiveDataContext(System.Data.IDbConnection connection, System.Data.Linq.Mapping.MappingSource mappingSource) :
120	base(connection, mappingSource)
121	{
122	OnCreated();
123	}
124
125	public System.Data.Linq.Table<AssignedResource> AssignedResources
126	{
127	get
128	{
129	return this.GetTable<AssignedResource>();
130	}
131	}
132
133	public System.Data.Linq.Table<Plugin> Plugins
134	{
135	get
136	{
137	return this.GetTable<Plugin>();
138	}
139	}
140
141	public System.Data.Linq.Table<RequiredPlugin> RequiredPlugins
142	{
143	get
144	{
145	return this.GetTable<RequiredPlugin>();
146	}
147	}
148
149	public System.Data.Linq.Table<Resource> Resources
150	{
151	get
152	{
153	return this.GetTable<Resource>();
154	}
155	}
156
157	public System.Data.Linq.Table<Task> Tasks
158	{
159	get
160	{
161	return this.GetTable<Task>();
162	}
163	}
164
165	public System.Data.Linq.Table<Downtime> Downtimes
166	{
167	get
168	{
169	return this.GetTable<Downtime>();
170	}
171	}
172
173	public System.Data.Linq.Table<Job> Jobs
174	{
175	get
176	{
177	return this.GetTable<Job>();
178	}
179	}
180
181	public System.Data.Linq.Table<TaskData> TaskDatas
182	{
183	get
184	{
185	return this.GetTable<TaskData>();
186	}
187	}
188
189	public System.Data.Linq.Table<PluginData> PluginDatas
190	{
191	get
192	{
193	return this.GetTable<PluginData>();
194	}
195	}
196
197	public System.Data.Linq.Table<StateLog> StateLogs
198	{
199	get
200	{
201	return this.GetTable<StateLog>();
202	}
203	}
204
205	public System.Data.Linq.Table<JobPermission> JobPermissions
206	{
207	get
208	{
209	return this.GetTable<JobPermission>();
210	}
211	}
212
213	public System.Data.Linq.Table<Lifecycle> Lifecycles
214	{
215	get
216	{
217	return this.GetTable<Lifecycle>();
218	}
219	}
220
221	public System.Data.Linq.Table<ResourcePermission> ResourcePermissions
222	{
223	get
224	{
225	return this.GetTable<ResourcePermission>();
226	}
227	}
228
229	public System.Data.Linq.Table<UserPriority> UserPriorities
230	{
231	get
232	{
233	return this.GetTable<UserPriority>();
234	}
235	}
236
237	public System.Data.Linq.Table<DimClient> DimClients
238	{
239	get
240	{
241	return this.GetTable<DimClient>();
242	}
243	}
244
245	public System.Data.Linq.Table<FactTask> FactTasks
246	{
247	get
248	{
249	return this.GetTable<FactTask>();
250	}
251	}
252
253	public System.Data.Linq.Table<DimJob> DimJobs
254	{
255	get
256	{
257	return this.GetTable<DimJob>();
258	}
259	}
260
261	public System.Data.Linq.Table<DimTime> DimTimes
262	{
263	get
264	{
265	return this.GetTable<DimTime>();
266	}
267	}
268
269	public System.Data.Linq.Table<DimUser> DimUsers
270	{
271	get
272	{
273	return this.GetTable<DimUser>();
274	}
275	}
276
277	public System.Data.Linq.Table<FactClientInfo> FactClientInfos
278	{
279	get
280	{
281	return this.GetTable<FactClientInfo>();
282	}
283	}
284	}
285
286	[global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.AssignedResources")]
287	public partial class AssignedResource : INotifyPropertyChanging, INotifyPropertyChanged
288	{
289
290	private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
291
292	private System.Guid _ResourceId;
293
294	private System.Guid _JobId;
295
296	private EntityRef<Resource> _Resource;
297
298	private EntityRef<Task> _Job;
299
300	#region Extensibility Method Definitions
301	partial void OnLoaded();
302	partial void OnValidate(System.Data.Linq.ChangeAction action);
303	partial void OnCreated();
304	partial void OnResourceIdChanging(System.Guid value);
305	partial void OnResourceIdChanged();
306	partial void OnTaskIdChanging(System.Guid value);
307	partial void OnTaskIdChanged();
308	#endregion
309
310	public AssignedResource()
311	{
312	this._Resource = default(EntityRef<Resource>);
313	this._Job = default(EntityRef<Task>);
314	OnCreated();
315	}
316
317	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
318	public System.Guid ResourceId
319	{
320	get
321	{
322	return this._ResourceId;
323	}
324	set
325	{
326	if ((this._ResourceId != value))
327	{
328	if (this._Resource.HasLoadedOrAssignedValue)
329	{
330	throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
331	}
332	this.OnResourceIdChanging(value);
333	this.SendPropertyChanging();
334	this._ResourceId = value;
335	this.SendPropertyChanged("ResourceId");
336	this.OnResourceIdChanged();
337	}
338	}
339	}
340
341	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
342	public System.Guid TaskId
343	{
344	get
345	{
346	return this._JobId;
347	}
348	set
349	{
350	if ((this._JobId != value))
351	{
352	if (this._Job.HasLoadedOrAssignedValue)
353	{
354	throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
355	}
356	this.OnTaskIdChanging(value);
357	this.SendPropertyChanging();
358	this._JobId = value;
359	this.SendPropertyChanged("TaskId");
360	this.OnTaskIdChanged();
361	}
362	}
363	}
364
365	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_AssignedResource", Storage="_Resource", ThisKey="ResourceId", OtherKey="ResourceId", IsForeignKey=true, DeleteRule="CASCADE")]
366	public Resource Resource
367	{
368	get
369	{
370	return this._Resource.Entity;
371	}
372	set
373	{
374	Resource previousValue = this._Resource.Entity;
375	if (((previousValue != value)
376	\|\| (this._Resource.HasLoadedOrAssignedValue == false)))
377	{
378	this.SendPropertyChanging();
379	if ((previousValue != null))
380	{
381	this._Resource.Entity = null;
382	previousValue.AssignedResources.Remove(this);
383	}
384	this._Resource.Entity = value;
385	if ((value != null))
386	{
387	value.AssignedResources.Add(this);
388	this._ResourceId = value.ResourceId;
389	}
390	else
391	{
392	this._ResourceId = default(System.Guid);
393	}
394	this.SendPropertyChanged("Resource");
395	}
396	}
397	}
398
399	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_AssignedResource", Storage="_Job", ThisKey="TaskId", OtherKey="TaskId", IsForeignKey=true, DeleteRule="CASCADE")]
400	public Task Task
401	{
402	get
403	{
404	return this._Job.Entity;
405	}
406	set
407	{
408	Task previousValue = this._Job.Entity;
409	if (((previousValue != value)
410	\|\| (this._Job.HasLoadedOrAssignedValue == false)))
411	{
412	this.SendPropertyChanging();
413	if ((previousValue != null))
414	{
415	this._Job.Entity = null;
416	previousValue.AssignedResources.Remove(this);
417	}
418	this._Job.Entity = value;
419	if ((value != null))
420	{
421	value.AssignedResources.Add(this);
422	this._JobId = value.TaskId;
423	}
424	else
425	{
426	this._JobId = default(System.Guid);
427	}
428	this.SendPropertyChanged("Task");
429	}
430	}
431	}
432
433	public event PropertyChangingEventHandler PropertyChanging;
434
435	public event PropertyChangedEventHandler PropertyChanged;
436
437	protected virtual void SendPropertyChanging()
438	{
439	if ((this.PropertyChanging != null))
440	{
441	this.PropertyChanging(this, emptyChangingEventArgs);
442	}
443	}
444
445	protected virtual void SendPropertyChanged(String propertyName)
446	{
447	if ((this.PropertyChanged != null))
448	{
449	this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
450	}
451	}
452	}
453
454	[global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Plugin")]
455	public partial class Plugin : INotifyPropertyChanging, INotifyPropertyChanged
456	{
457
458	private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
459
460	private System.Guid _PluginId;
461
462	private string _Name;
463
464	private string _Version;
465
466	private System.Guid _UserId;
467
468	private System.DateTime _DateCreated;
469
470	private byte[] _Hash;
471
472	private EntitySet<RequiredPlugin> _RequiredPlugins;
473
474	private EntitySet<PluginData> _PluginData;
475
476	#region Extensibility Method Definitions
477	partial void OnLoaded();
478	partial void OnValidate(System.Data.Linq.ChangeAction action);
479	partial void OnCreated();
480	partial void OnPluginIdChanging(System.Guid value);
481	partial void OnPluginIdChanged();
482	partial void OnNameChanging(string value);
483	partial void OnNameChanged();
484	partial void OnVersionChanging(string value);
485	partial void OnVersionChanged();
486	partial void OnUserIdChanging(System.Guid value);
487	partial void OnUserIdChanged();
488	partial void OnDateCreatedChanging(System.DateTime value);
489	partial void OnDateCreatedChanged();
490	partial void OnHashChanging(byte[] value);
491	partial void OnHashChanged();
492	#endregion
493
494	public Plugin()
495	{
496	this._RequiredPlugins = new EntitySet<RequiredPlugin>(new Action<RequiredPlugin>(this.attach_RequiredPlugins), new Action<RequiredPlugin>(this.detach_RequiredPlugins));
497	this._PluginData = new EntitySet<PluginData>(new Action<PluginData>(this.attach_PluginData), new Action<PluginData>(this.detach_PluginData));
498	OnCreated();
499	}
500
501	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
502	public System.Guid PluginId
503	{
504	get
505	{
506	return this._PluginId;
507	}
508	set
509	{
510	if ((this._PluginId != value))
511	{
512	this.OnPluginIdChanging(value);
513	this.SendPropertyChanging();
514	this._PluginId = value;
515	this.SendPropertyChanged("PluginId");
516	this.OnPluginIdChanged();
517	}
518	}
519	}
520
521	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX)", CanBeNull=false)]
522	public string Name
523	{
524	get
525	{
526	return this._Name;
527	}
528	set
529	{
530	if ((this._Name != value))
531	{
532	this.OnNameChanging(value);
533	this.SendPropertyChanging();
534	this._Name = value;
535	this.SendPropertyChanged("Name");
536	this.OnNameChanged();
537	}
538	}
539	}
540
541	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Version", DbType="VarChar(MAX)", CanBeNull=false)]
542	public string Version
543	{
544	get
545	{
546	return this._Version;
547	}
548	set
549	{
550	if ((this._Version != value))
551	{
552	this.OnVersionChanging(value);
553	this.SendPropertyChanging();
554	this._Version = value;
555	this.SendPropertyChanged("Version");
556	this.OnVersionChanged();
557	}
558	}
559	}
560
561	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier")]
562	public System.Guid UserId
563	{
564	get
565	{
566	return this._UserId;
567	}
568	set
569	{
570	if ((this._UserId != value))
571	{
572	this.OnUserIdChanging(value);
573	this.SendPropertyChanging();
574	this._UserId = value;
575	this.SendPropertyChanged("UserId");
576	this.OnUserIdChanged();
577	}
578	}
579	}
580
581	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateCreated", DbType="DateTime")]
582	public System.DateTime DateCreated
583	{
584	get
585	{
586	return this._DateCreated;
587	}
588	set
589	{
590	if ((this._DateCreated != value))
591	{
592	this.OnDateCreatedChanging(value);
593	this.SendPropertyChanging();
594	this._DateCreated = value;
595	this.SendPropertyChanged("DateCreated");
596	this.OnDateCreatedChanged();
597	}
598	}
599	}
600
601	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Hash", DbType="VarBinary(20) NOT NULL", CanBeNull=false)]
602	public byte[] Hash
603	{
604	get
605	{
606	return this._Hash;
607	}
608	set
609	{
610	if ((this._Hash != value))
611	{
612	this.OnHashChanging(value);
613	this.SendPropertyChanging();
614	this._Hash = value;
615	this.SendPropertyChanged("Hash");
616	this.OnHashChanged();
617	}
618	}
619	}
620
621	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_RequiredPlugin", Storage="_RequiredPlugins", ThisKey="PluginId", OtherKey="PluginId")]
622	public EntitySet<RequiredPlugin> RequiredPlugins
623	{
624	get
625	{
626	return this._RequiredPlugins;
627	}
628	set
629	{
630	this._RequiredPlugins.Assign(value);
631	}
632	}
633
634	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_PluginData", Storage="_PluginData", ThisKey="PluginId", OtherKey="PluginId")]
635	public EntitySet<PluginData> PluginData
636	{
637	get
638	{
639	return this._PluginData;
640	}
641	set
642	{
643	this._PluginData.Assign(value);
644	}
645	}
646
647	public event PropertyChangingEventHandler PropertyChanging;
648
649	public event PropertyChangedEventHandler PropertyChanged;
650
651	protected virtual void SendPropertyChanging()
652	{
653	if ((this.PropertyChanging != null))
654	{
655	this.PropertyChanging(this, emptyChangingEventArgs);
656	}
657	}
658
659	protected virtual void SendPropertyChanged(String propertyName)
660	{
661	if ((this.PropertyChanged != null))
662	{
663	this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
664	}
665	}
666
667	private void attach_RequiredPlugins(RequiredPlugin entity)
668	{
669	this.SendPropertyChanging();
670	entity.Plugin = this;
671	}
672
673	private void detach_RequiredPlugins(RequiredPlugin entity)
674	{
675	this.SendPropertyChanging();
676	entity.Plugin = null;
677	}
678
679	private void attach_PluginData(PluginData entity)
680	{
681	this.SendPropertyChanging();
682	entity.Plugin = this;
683	}
684
685	private void detach_PluginData(PluginData entity)
686	{
687	this.SendPropertyChanging();
688	entity.Plugin = null;
689	}
690	}
691
692	[global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.RequiredPlugins")]
693	public partial class RequiredPlugin : INotifyPropertyChanging, INotifyPropertyChanged
694	{
695
696	private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
697
698	private System.Guid _RequiredPluginId;
699
700	private System.Guid _JobId;
701
702	private System.Guid _PluginId;
703
704	private EntityRef<Plugin> _PluginInfo;
705
706	private EntityRef<Task> _Job;
707
708	#region Extensibility Method Definitions
709	partial void OnLoaded();
710	partial void OnValidate(System.Data.Linq.ChangeAction action);
711	partial void OnCreated();
712	partial void OnRequiredPluginIdChanging(System.Guid value);
713	partial void OnRequiredPluginIdChanged();
714	partial void OnTaskIdChanging(System.Guid value);
715	partial void OnTaskIdChanged();
716	partial void OnPluginIdChanging(System.Guid value);
717	partial void OnPluginIdChanged();
718	#endregion
719
720	public RequiredPlugin()
721	{
722	this._PluginInfo = default(EntityRef<Plugin>);
723	this._Job = default(EntityRef<Task>);
724	OnCreated();
725	}
726
727	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_RequiredPluginId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
728	public System.Guid RequiredPluginId
729	{
730	get
731	{
732	return this._RequiredPluginId;
733	}
734	set
735	{
736	if ((this._RequiredPluginId != value))
737	{
738	this.OnRequiredPluginIdChanging(value);
739	this.SendPropertyChanging();
740	this._RequiredPluginId = value;
741	this.SendPropertyChanged("RequiredPluginId");
742	this.OnRequiredPluginIdChanged();
743	}
744	}
745	}
746
747	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL")]
748	public System.Guid TaskId
749	{
750	get
751	{
752	return this._JobId;
753	}
754	set
755	{
756	if ((this._JobId != value))
757	{
758	if (this._Job.HasLoadedOrAssignedValue)
759	{
760	throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
761	}
762	this.OnTaskIdChanging(value);
763	this.SendPropertyChanging();
764	this._JobId = value;
765	this.SendPropertyChanged("TaskId");
766	this.OnTaskIdChanged();
767	}
768	}
769	}
770
771	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginId", DbType="UniqueIdentifier NOT NULL")]
772	public System.Guid PluginId
773	{
774	get
775	{
776	return this._PluginId;
777	}
778	set
779	{
780	if ((this._PluginId != value))
781	{
782	if (this._PluginInfo.HasLoadedOrAssignedValue)
783	{
784	throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
785	}
786	this.OnPluginIdChanging(value);
787	this.SendPropertyChanging();
788	this._PluginId = value;
789	this.SendPropertyChanged("PluginId");
790	this.OnPluginIdChanged();
791	}
792	}
793	}
794
795	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_RequiredPlugin", Storage="_PluginInfo", ThisKey="PluginId", OtherKey="PluginId", IsForeignKey=true, DeleteRule="CASCADE")]
796	public Plugin Plugin
797	{
798	get
799	{
800	return this._PluginInfo.Entity;
801	}
802	set
803	{
804	Plugin previousValue = this._PluginInfo.Entity;
805	if (((previousValue != value)
806	\|\| (this._PluginInfo.HasLoadedOrAssignedValue == false)))
807	{
808	this.SendPropertyChanging();
809	if ((previousValue != null))
810	{
811	this._PluginInfo.Entity = null;
812	previousValue.RequiredPlugins.Remove(this);
813	}
814	this._PluginInfo.Entity = value;
815	if ((value != null))
816	{
817	value.RequiredPlugins.Add(this);
818	this._PluginId = value.PluginId;
819	}
820	else
821	{
822	this._PluginId = default(System.Guid);
823	}
824	this.SendPropertyChanged("Plugin");
825	}
826	}
827	}
828
829	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_RequiredPlugin", Storage="_Job", ThisKey="TaskId", OtherKey="TaskId", IsForeignKey=true)]
830	public Task Task
831	{
832	get
833	{
834	return this._Job.Entity;
835	}
836	set
837	{
838	Task previousValue = this._Job.Entity;
839	if (((previousValue != value)
840	\|\| (this._Job.HasLoadedOrAssignedValue == false)))
841	{
842	this.SendPropertyChanging();
843	if ((previousValue != null))
844	{
845	this._Job.Entity = null;
846	previousValue.RequiredPlugins.Remove(this);
847	}
848	this._Job.Entity = value;
849	if ((value != null))
850	{
851	value.RequiredPlugins.Add(this);
852	this._JobId = value.TaskId;
853	}
854	else
855	{
856	this._JobId = default(System.Guid);
857	}
858	this.SendPropertyChanged("Task");
859	}
860	}
861	}
862
863	public event PropertyChangingEventHandler PropertyChanging;
864
865	public event PropertyChangedEventHandler PropertyChanged;
866
867	protected virtual void SendPropertyChanging()
868	{
869	if ((this.PropertyChanging != null))
870	{
871	this.PropertyChanging(this, emptyChangingEventArgs);
872	}
873	}
874
875	protected virtual void SendPropertyChanged(String propertyName)
876	{
877	if ((this.PropertyChanged != null))
878	{
879	this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
880	}
881	}
882	}
883
884	[global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Resource")]
885	[global::System.Data.Linq.Mapping.InheritanceMappingAttribute(Code="RESOURCE", Type=typeof(Resource))]
886	[global::System.Data.Linq.Mapping.InheritanceMappingAttribute(Code="Slave", Type=typeof(Slave), IsDefault=true)]
887	[global::System.Data.Linq.Mapping.InheritanceMappingAttribute(Code="GROUP", Type=typeof(SlaveGroup))]
888	public partial class Resource : INotifyPropertyChanging, INotifyPropertyChanged
889	{
890
891	private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
892
893	private System.Guid _ResourceId;
894
895	private string _Name;
896
897	private string _ResourceType;
898
899	private System.Nullable<System.Guid> _ParentResourceId;
900
901	private int _HbInterval;
902
903	private System.Nullable<System.Guid> _OwnerUserId;
904
905	private EntitySet<AssignedResource> _AssignedResources;
906
907	private EntitySet<Resource> _ChildResources;
908
909	private EntitySet<Downtime> _UptimeCalendars;
910
911	private EntitySet<StateLog> _StateLogs;
912
913	private EntitySet<ResourcePermission> _ResourcePermissions;
914
915	private EntityRef<Resource> _ParentResource;
916
917	#region Extensibility Method Definitions
918	partial void OnLoaded();
919	partial void OnValidate(System.Data.Linq.ChangeAction action);
920	partial void OnCreated();
921	partial void OnResourceIdChanging(System.Guid value);
922	partial void OnResourceIdChanged();
923	partial void OnNameChanging(string value);
924	partial void OnNameChanged();
925	partial void OnResourceTypeChanging(string value);
926	partial void OnResourceTypeChanged();
927	partial void OnParentResourceIdChanging(System.Nullable<System.Guid> value);
928	partial void OnParentResourceIdChanged();
929	partial void OnHbIntervalChanging(int value);
930	partial void OnHbIntervalChanged();
931	partial void OnOwnerUserIdChanging(System.Nullable<System.Guid> value);
932	partial void OnOwnerUserIdChanged();
933	#endregion
934
935	public Resource()
936	{
937	this._AssignedResources = new EntitySet<AssignedResource>(new Action<AssignedResource>(this.attach_AssignedResources), new Action<AssignedResource>(this.detach_AssignedResources));
938	this._ChildResources = new EntitySet<Resource>(new Action<Resource>(this.attach_ChildResources), new Action<Resource>(this.detach_ChildResources));
939	this._UptimeCalendars = new EntitySet<Downtime>(new Action<Downtime>(this.attach_UptimeCalendars), new Action<Downtime>(this.detach_UptimeCalendars));
940	this._StateLogs = new EntitySet<StateLog>(new Action<StateLog>(this.attach_StateLogs), new Action<StateLog>(this.detach_StateLogs));
941	this._ResourcePermissions = new EntitySet<ResourcePermission>(new Action<ResourcePermission>(this.attach_ResourcePermissions), new Action<ResourcePermission>(this.detach_ResourcePermissions));
942	this._ParentResource = default(EntityRef<Resource>);
943	OnCreated();
944	}
945
946	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
947	public System.Guid ResourceId
948	{
949	get
950	{
951	return this._ResourceId;
952	}
953	set
954	{
955	if ((this._ResourceId != value))
956	{
957	this.OnResourceIdChanging(value);
958	this.SendPropertyChanging();
959	this._ResourceId = value;
960	this.SendPropertyChanged("ResourceId");
961	this.OnResourceIdChanged();
962	}
963	}
964	}
965
966	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX)", CanBeNull=false)]
967	public string Name
968	{
969	get
970	{
971	return this._Name;
972	}
973	set
974	{
975	if ((this._Name != value))
976	{
977	this.OnNameChanging(value);
978	this.SendPropertyChanging();
979	this._Name = value;
980	this.SendPropertyChanged("Name");
981	this.OnNameChanged();
982	}
983	}
984	}
985
986	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceType", CanBeNull=false, IsDiscriminator=true)]
987	public string ResourceType
988	{
989	get
990	{
991	return this._ResourceType;
992	}
993	set
994	{
995	if ((this._ResourceType != value))
996	{
997	this.OnResourceTypeChanging(value);
998	this.SendPropertyChanging();
999	this._ResourceType = value;
1000	this.SendPropertyChanged("ResourceType");
1001	this.OnResourceTypeChanged();
1002	}
1003	}
1004	}
1005
1006	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ParentResourceId", DbType="UniqueIdentifier")]
1007	public System.Nullable<System.Guid> ParentResourceId
1008	{
1009	get
1010	{
1011	return this._ParentResourceId;
1012	}
1013	set
1014	{
1015	if ((this._ParentResourceId != value))
1016	{
1017	if (this._ParentResource.HasLoadedOrAssignedValue)
1018	{
1019	throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
1020	}
1021	this.OnParentResourceIdChanging(value);
1022	this.SendPropertyChanging();
1023	this._ParentResourceId = value;
1024	this.SendPropertyChanged("ParentResourceId");
1025	this.OnParentResourceIdChanged();
1026	}
1027	}
1028	}
1029
1030	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_HbInterval", DbType="Int")]
1031	public int HbInterval
1032	{
1033	get
1034	{
1035	return this._HbInterval;
1036	}
1037	set
1038	{
1039	if ((this._HbInterval != value))
1040	{
1041	this.OnHbIntervalChanging(value);
1042	this.SendPropertyChanging();
1043	this._HbInterval = value;
1044	this.SendPropertyChanged("HbInterval");
1045	this.OnHbIntervalChanged();
1046	}
1047	}
1048	}
1049
1050	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_OwnerUserId", DbType="UniqueIdentifier")]
1051	public System.Nullable<System.Guid> OwnerUserId
1052	{
1053	get
1054	{
1055	return this._OwnerUserId;
1056	}
1057	set
1058	{
1059	if ((this._OwnerUserId != value))
1060	{
1061	this.OnOwnerUserIdChanging(value);
1062	this.SendPropertyChanging();
1063	this._OwnerUserId = value;
1064	this.SendPropertyChanged("OwnerUserId");
1065	this.OnOwnerUserIdChanged();
1066	}
1067	}
1068	}
1069
1070	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_AssignedResource", Storage="_AssignedResources", ThisKey="ResourceId", OtherKey="ResourceId")]
1071	public EntitySet<AssignedResource> AssignedResources
1072	{
1073	get
1074	{
1075	return this._AssignedResources;
1076	}
1077	set
1078	{
1079	this._AssignedResources.Assign(value);
1080	}
1081	}
1082
1083	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_Resource", Storage="_ChildResources", ThisKey="ResourceId", OtherKey="ParentResourceId")]
1084	public EntitySet<Resource> ChildResources
1085	{
1086	get
1087	{
1088	return this._ChildResources;
1089	}
1090	set
1091	{
1092	this._ChildResources.Assign(value);
1093	}
1094	}
1095
1096	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_Downtime", Storage="_UptimeCalendars", ThisKey="ResourceId", OtherKey="ResourceId")]
1097	public EntitySet<Downtime> Downtimes
1098	{
1099	get
1100	{
1101	return this._UptimeCalendars;
1102	}
1103	set
1104	{
1105	this._UptimeCalendars.Assign(value);
1106	}
1107	}
1108
1109	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_StateLog", Storage="_StateLogs", ThisKey="ResourceId", OtherKey="SlaveId")]
1110	public EntitySet<StateLog> StateLogs
1111	{
1112	get
1113	{
1114	return this._StateLogs;
1115	}
1116	set
1117	{
1118	this._StateLogs.Assign(value);
1119	}
1120	}
1121
1122	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_ResourcePermission", Storage="_ResourcePermissions", ThisKey="ResourceId", OtherKey="ResourceId")]
1123	public EntitySet<ResourcePermission> ResourcePermissions
1124	{
1125	get
1126	{
1127	return this._ResourcePermissions;
1128	}
1129	set
1130	{
1131	this._ResourcePermissions.Assign(value);
1132	}
1133	}
1134
1135	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_Resource", Storage="_ParentResource", ThisKey="ParentResourceId", OtherKey="ResourceId", IsForeignKey=true)]
1136	public Resource ParentResource
1137	{
1138	get
1139	{
1140	return this._ParentResource.Entity;
1141	}
1142	set
1143	{
1144	Resource previousValue = this._ParentResource.Entity;
1145	if (((previousValue != value)
1146	\|\| (this._ParentResource.HasLoadedOrAssignedValue == false)))
1147	{
1148	this.SendPropertyChanging();
1149	if ((previousValue != null))
1150	{
1151	this._ParentResource.Entity = null;
1152	previousValue.ChildResources.Remove(this);
1153	}
1154	this._ParentResource.Entity = value;
1155	if ((value != null))
1156	{
1157	value.ChildResources.Add(this);
1158	this._ParentResourceId = value.ResourceId;
1159	}
1160	else
1161	{
1162	this._ParentResourceId = default(Nullable<System.Guid>);
1163	}
1164	this.SendPropertyChanged("ParentResource");
1165	}
1166	}
1167	}
1168
1169	public event PropertyChangingEventHandler PropertyChanging;
1170
1171	public event PropertyChangedEventHandler PropertyChanged;
1172
1173	protected virtual void SendPropertyChanging()
1174	{
1175	if ((this.PropertyChanging != null))
1176	{
1177	this.PropertyChanging(this, emptyChangingEventArgs);
1178	}
1179	}
1180
1181	protected virtual void SendPropertyChanged(String propertyName)
1182	{
1183	if ((this.PropertyChanged != null))
1184	{
1185	this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1186	}
1187	}
1188
1189	private void attach_AssignedResources(AssignedResource entity)
1190	{
1191	this.SendPropertyChanging();
1192	entity.Resource = this;
1193	}
1194
1195	private void detach_AssignedResources(AssignedResource entity)
1196	{
1197	this.SendPropertyChanging();
1198	entity.Resource = null;
1199	}
1200
1201	private void attach_ChildResources(Resource entity)
1202	{
1203	this.SendPropertyChanging();
1204	entity.ParentResource = this;
1205	}
1206
1207	private void detach_ChildResources(Resource entity)
1208	{
1209	this.SendPropertyChanging();
1210	entity.ParentResource = null;
1211	}
1212
1213	private void attach_UptimeCalendars(Downtime entity)
1214	{
1215	this.SendPropertyChanging();
1216	entity.Resource = this;
1217	}
1218
1219	private void detach_UptimeCalendars(Downtime entity)
1220	{
1221	this.SendPropertyChanging();
1222	entity.Resource = null;
1223	}
1224
1225	private void attach_StateLogs(StateLog entity)
1226	{
1227	this.SendPropertyChanging();
1228	entity.Resource = this;
1229	}
1230
1231	private void detach_StateLogs(StateLog entity)
1232	{
1233	this.SendPropertyChanging();
1234	entity.Resource = null;
1235	}
1236
1237	private void attach_ResourcePermissions(ResourcePermission entity)
1238	{
1239	this.SendPropertyChanging();
1240	entity.Resource = this;
1241	}
1242
1243	private void detach_ResourcePermissions(ResourcePermission entity)
1244	{
1245	this.SendPropertyChanging();
1246	entity.Resource = null;
1247	}
1248	}
1249
1250	public partial class Slave : Resource
1251	{
1252
1253	private System.Nullable<int> _CPUSpeed;
1254
1255	private System.Nullable<int> _Memory;
1256
1257	private System.Nullable<System.DateTime> _Login;
1258
1259	private global::HeuristicLab.Services.Hive.DataAccess.SlaveState _Status;
1260
1261	private System.Nullable<int> _NumberOfCores;
1262
1263	private System.Nullable<int> _NumberOfFreeCores;
1264
1265	private System.Nullable<int> _FreeMemory;
1266
1267	private bool _IsAllowedToCalculate;
1268
1269	private global::HeuristicLab.Services.Hive.DataAccess.CpuArchitecture _CpuArchitecture;
1270
1271	private string _OperatingSystem;
1272
1273	private System.Nullable<System.DateTime> _LastHeartbeat;
1274
1275	private double _CpuUtilization;
1276
1277	private System.Nullable<bool> _IsDisposable;
1278
1279	#region Extensibility Method Definitions
1280	partial void OnLoaded();
1281	partial void OnValidate(System.Data.Linq.ChangeAction action);
1282	partial void OnCreated();
1283	partial void OnCpuSpeedChanging(System.Nullable<int> value);
1284	partial void OnCpuSpeedChanged();
1285	partial void OnMemoryChanging(System.Nullable<int> value);
1286	partial void OnMemoryChanged();
1287	partial void OnLoginChanging(System.Nullable<System.DateTime> value);
1288	partial void OnLoginChanged();
1289	partial void OnSlaveStateChanging(global::HeuristicLab.Services.Hive.DataAccess.SlaveState value);
1290	partial void OnSlaveStateChanged();
1291	partial void OnCoresChanging(System.Nullable<int> value);
1292	partial void OnCoresChanged();
1293	partial void OnFreeCoresChanging(System.Nullable<int> value);
1294	partial void OnFreeCoresChanged();
1295	partial void OnFreeMemoryChanging(System.Nullable<int> value);
1296	partial void OnFreeMemoryChanged();
1297	partial void OnIsAllowedToCalculateChanging(bool value);
1298	partial void OnIsAllowedToCalculateChanged();
1299	partial void OnCpuArchitectureChanging(global::HeuristicLab.Services.Hive.DataAccess.CpuArchitecture value);
1300	partial void OnCpuArchitectureChanged();
1301	partial void OnOperatingSystemChanging(string value);
1302	partial void OnOperatingSystemChanged();
1303	partial void OnLastHeartbeatChanging(System.Nullable<System.DateTime> value);
1304	partial void OnLastHeartbeatChanged();
1305	partial void OnCpuUtilizationChanging(double value);
1306	partial void OnCpuUtilizationChanged();
1307	partial void OnIsDisposableChanging(System.Nullable<bool> value);
1308	partial void OnIsDisposableChanged();
1309	#endregion
1310
1311	public Slave()
1312	{
1313	OnCreated();
1314	}
1315
1316	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CPUSpeed", DbType="Int")]
1317	public System.Nullable<int> CpuSpeed
1318	{
1319	get
1320	{
1321	return this._CPUSpeed;
1322	}
1323	set
1324	{
1325	if ((this._CPUSpeed != value))
1326	{
1327	this.OnCpuSpeedChanging(value);
1328	this.SendPropertyChanging();
1329	this._CPUSpeed = value;
1330	this.SendPropertyChanged("CpuSpeed");
1331	this.OnCpuSpeedChanged();
1332	}
1333	}
1334	}
1335
1336	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Memory", DbType="Int")]
1337	public System.Nullable<int> Memory
1338	{
1339	get
1340	{
1341	return this._Memory;
1342	}
1343	set
1344	{
1345	if ((this._Memory != value))
1346	{
1347	this.OnMemoryChanging(value);
1348	this.SendPropertyChanging();
1349	this._Memory = value;
1350	this.SendPropertyChanged("Memory");
1351	this.OnMemoryChanged();
1352	}
1353	}
1354	}
1355
1356	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Login", DbType="DateTime")]
1357	public System.Nullable<System.DateTime> Login
1358	{
1359	get
1360	{
1361	return this._Login;
1362	}
1363	set
1364	{
1365	if ((this._Login != value))
1366	{
1367	this.OnLoginChanging(value);
1368	this.SendPropertyChanging();
1369	this._Login = value;
1370	this.SendPropertyChanged("Login");
1371	this.OnLoginChanged();
1372	}
1373	}
1374	}
1375
1376	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Status", DbType="VarChar(15)", CanBeNull=true)]
1377	public global::HeuristicLab.Services.Hive.DataAccess.SlaveState SlaveState
1378	{
1379	get
1380	{
1381	return this._Status;
1382	}
1383	set
1384	{
1385	if ((this._Status != value))
1386	{
1387	this.OnSlaveStateChanging(value);
1388	this.SendPropertyChanging();
1389	this._Status = value;
1390	this.SendPropertyChanged("SlaveState");
1391	this.OnSlaveStateChanged();
1392	}
1393	}
1394	}
1395
1396	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumberOfCores", DbType="Int")]
1397	public System.Nullable<int> Cores
1398	{
1399	get
1400	{
1401	return this._NumberOfCores;
1402	}
1403	set
1404	{
1405	if ((this._NumberOfCores != value))
1406	{
1407	this.OnCoresChanging(value);
1408	this.SendPropertyChanging();
1409	this._NumberOfCores = value;
1410	this.SendPropertyChanged("Cores");
1411	this.OnCoresChanged();
1412	}
1413	}
1414	}
1415
1416	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumberOfFreeCores", DbType="Int")]
1417	public System.Nullable<int> FreeCores
1418	{
1419	get
1420	{
1421	return this._NumberOfFreeCores;
1422	}
1423	set
1424	{
1425	if ((this._NumberOfFreeCores != value))
1426	{
1427	this.OnFreeCoresChanging(value);
1428	this.SendPropertyChanging();
1429	this._NumberOfFreeCores = value;
1430	this.SendPropertyChanged("FreeCores");
1431	this.OnFreeCoresChanged();
1432	}
1433	}
1434	}
1435
1436	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_FreeMemory", DbType="Int")]
1437	public System.Nullable<int> FreeMemory
1438	{
1439	get
1440	{
1441	return this._FreeMemory;
1442	}
1443	set
1444	{
1445	if ((this._FreeMemory != value))
1446	{
1447	this.OnFreeMemoryChanging(value);
1448	this.SendPropertyChanging();
1449	this._FreeMemory = value;
1450	this.SendPropertyChanged("FreeMemory");
1451	this.OnFreeMemoryChanged();
1452	}
1453	}
1454	}
1455
1456	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsAllowedToCalculate", DbType="Bit")]
1457	public bool IsAllowedToCalculate
1458	{
1459	get
1460	{
1461	return this._IsAllowedToCalculate;
1462	}
1463	set
1464	{
1465	if ((this._IsAllowedToCalculate != value))
1466	{
1467	this.OnIsAllowedToCalculateChanging(value);
1468	this.SendPropertyChanging();
1469	this._IsAllowedToCalculate = value;
1470	this.SendPropertyChanged("IsAllowedToCalculate");
1471	this.OnIsAllowedToCalculateChanged();
1472	}
1473	}
1474	}
1475
1476	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CpuArchitecture", DbType="VarChar(3)", CanBeNull=false)]
1477	public global::HeuristicLab.Services.Hive.DataAccess.CpuArchitecture CpuArchitecture
1478	{
1479	get
1480	{
1481	return this._CpuArchitecture;
1482	}
1483	set
1484	{
1485	if ((this._CpuArchitecture != value))
1486	{
1487	this.OnCpuArchitectureChanging(value);
1488	this.SendPropertyChanging();
1489	this._CpuArchitecture = value;
1490	this.SendPropertyChanged("CpuArchitecture");
1491	this.OnCpuArchitectureChanged();
1492	}
1493	}
1494	}
1495
1496	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_OperatingSystem", DbType="VarChar(MAX)", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
1497	public string OperatingSystem
1498	{
1499	get
1500	{
1501	return this._OperatingSystem;
1502	}
1503	set
1504	{
1505	if ((this._OperatingSystem != value))
1506	{
1507	this.OnOperatingSystemChanging(value);
1508	this.SendPropertyChanging();
1509	this._OperatingSystem = value;
1510	this.SendPropertyChanged("OperatingSystem");
1511	this.OnOperatingSystemChanged();
1512	}
1513	}
1514	}
1515
1516	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastHeartbeat", DbType="DateTime")]
1517	public System.Nullable<System.DateTime> LastHeartbeat
1518	{
1519	get
1520	{
1521	return this._LastHeartbeat;
1522	}
1523	set
1524	{
1525	if ((this._LastHeartbeat != value))
1526	{
1527	this.OnLastHeartbeatChanging(value);
1528	this.SendPropertyChanging();
1529	this._LastHeartbeat = value;
1530	this.SendPropertyChanged("LastHeartbeat");
1531	this.OnLastHeartbeatChanged();
1532	}
1533	}
1534	}
1535
1536	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CpuUtilization", DbType="float")]
1537	public double CpuUtilization
1538	{
1539	get
1540	{
1541	return this._CpuUtilization;
1542	}
1543	set
1544	{
1545	if ((this._CpuUtilization != value))
1546	{
1547	this.OnCpuUtilizationChanging(value);
1548	this.SendPropertyChanging();
1549	this._CpuUtilization = value;
1550	this.SendPropertyChanged("CpuUtilization");
1551	this.OnCpuUtilizationChanged();
1552	}
1553	}
1554	}
1555
1556	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsDisposable", DbType="Bit")]
1557	public System.Nullable<bool> IsDisposable
1558	{
1559	get
1560	{
1561	return this._IsDisposable;
1562	}
1563	set
1564	{
1565	if ((this._IsDisposable != value))
1566	{
1567	this.OnIsDisposableChanging(value);
1568	this.SendPropertyChanging();
1569	this._IsDisposable = value;
1570	this.SendPropertyChanged("IsDisposable");
1571	this.OnIsDisposableChanged();
1572	}
1573	}
1574	}
1575	}
1576
1577	public partial class SlaveGroup : Resource
1578	{
1579
1580	#region Extensibility Method Definitions
1581	partial void OnLoaded();
1582	partial void OnValidate(System.Data.Linq.ChangeAction action);
1583	partial void OnCreated();
1584	#endregion
1585
1586	public SlaveGroup()
1587	{
1588	OnCreated();
1589	}
1590	}
1591
1592	[global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Task")]
1593	public partial class Task : INotifyPropertyChanging, INotifyPropertyChanged
1594	{
1595
1596	private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1597
1598	private System.Guid _JobId;
1599
1600	private global::HeuristicLab.Services.Hive.DataAccess.TaskState _State;
1601
1602	private double _ExecutionTime;
1603
1604	private System.Nullable<System.DateTime> _LastHeartbeat;
1605
1606	private System.Nullable<System.Guid> _ParentJobId;
1607
1608	private int _Priority;
1609
1610	private int _CoresNeeded;
1611
1612	private int _MemoryNeeded;
1613
1614	private bool _IsParentJob;
1615
1616	private bool _FinishWhenChildJobsFinished;
1617
1618	private global::HeuristicLab.Services.Hive.DataAccess.Command? _Command;
1619
1620	private System.Guid _HiveExperimentId;
1621
1622	private EntitySet<AssignedResource> _AssignedResources;
1623
1624	private EntitySet<RequiredPlugin> _RequiredPlugins;
1625
1626	private EntitySet<Task> _Jobs;
1627
1628	private EntityRef<TaskData> _JobData;
1629
1630	private EntitySet<StateLog> _StateLogs;
1631
1632	private EntityRef<Task> _Job1;
1633
1634	private EntityRef<Job> _HiveExperiment;
1635
1636	#region Extensibility Method Definitions
1637	partial void OnLoaded();
1638	partial void OnValidate(System.Data.Linq.ChangeAction action);
1639	partial void OnCreated();
1640	partial void OnTaskIdChanging(System.Guid value);
1641	partial void OnTaskIdChanged();
1642	partial void OnStateChanging(global::HeuristicLab.Services.Hive.DataAccess.TaskState value);
1643	partial void OnStateChanged();
1644	partial void OnExecutionTimeMsChanging(double value);
1645	partial void OnExecutionTimeMsChanged();
1646	partial void OnLastHeartbeatChanging(System.Nullable<System.DateTime> value);
1647	partial void OnLastHeartbeatChanged();
1648	partial void OnParentTaskIdChanging(System.Nullable<System.Guid> value);
1649	partial void OnParentTaskIdChanged();
1650	partial void OnPriorityChanging(int value);
1651	partial void OnPriorityChanged();
1652	partial void OnCoresNeededChanging(int value);
1653	partial void OnCoresNeededChanged();
1654	partial void OnMemoryNeededChanging(int value);
1655	partial void OnMemoryNeededChanged();
1656	partial void OnIsParentTaskChanging(bool value);
1657	partial void OnIsParentTaskChanged();
1658	partial void OnFinishWhenChildJobsFinishedChanging(bool value);
1659	partial void OnFinishWhenChildJobsFinishedChanged();
1660	partial void OnCommandChanging(global::HeuristicLab.Services.Hive.DataAccess.Command? value);
1661	partial void OnCommandChanged();
1662	partial void OnJobIdChanging(System.Guid value);
1663	partial void OnJobIdChanged();
1664	#endregion
1665
1666	public Task()
1667	{
1668	this._AssignedResources = new EntitySet<AssignedResource>(new Action<AssignedResource>(this.attach_AssignedResources), new Action<AssignedResource>(this.detach_AssignedResources));
1669	this._RequiredPlugins = new EntitySet<RequiredPlugin>(new Action<RequiredPlugin>(this.attach_RequiredPlugins), new Action<RequiredPlugin>(this.detach_RequiredPlugins));
1670	this._Jobs = new EntitySet<Task>(new Action<Task>(this.attach_Jobs), new Action<Task>(this.detach_Jobs));
1671	this._JobData = default(EntityRef<TaskData>);
1672	this._StateLogs = new EntitySet<StateLog>(new Action<StateLog>(this.attach_StateLogs), new Action<StateLog>(this.detach_StateLogs));
1673	this._Job1 = default(EntityRef<Task>);
1674	this._HiveExperiment = default(EntityRef<Job>);
1675	OnCreated();
1676	}
1677
1678	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
1679	public System.Guid TaskId
1680	{
1681	get
1682	{
1683	return this._JobId;
1684	}
1685	set
1686	{
1687	if ((this._JobId != value))
1688	{
1689	this.OnTaskIdChanging(value);
1690	this.SendPropertyChanging();
1691	this._JobId = value;
1692	this.SendPropertyChanged("TaskId");
1693	this.OnTaskIdChanged();
1694	}
1695	}
1696	}
1697
1698	[global::System.Data.Linq.Mapping.ColumnAttribute(Name="TaskState", Storage="_State", DbType="VarChar(30)", CanBeNull=false)]
1699	public global::HeuristicLab.Services.Hive.DataAccess.TaskState State
1700	{
1701	get
1702	{
1703	return this._State;
1704	}
1705	set
1706	{
1707	if ((this._State != value))
1708	{
1709	this.OnStateChanging(value);
1710	this.SendPropertyChanging();
1711	this._State = value;
1712	this.SendPropertyChanged("State");
1713	this.OnStateChanged();
1714	}
1715	}
1716	}
1717
1718	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ExecutionTime", DbType="float")]
1719	public double ExecutionTimeMs
1720	{
1721	get
1722	{
1723	return this._ExecutionTime;
1724	}
1725	set
1726	{
1727	if ((this._ExecutionTime != value))
1728	{
1729	this.OnExecutionTimeMsChanging(value);
1730	this.SendPropertyChanging();
1731	this._ExecutionTime = value;
1732	this.SendPropertyChanged("ExecutionTimeMs");
1733	this.OnExecutionTimeMsChanged();
1734	}
1735	}
1736	}
1737
1738	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastHeartbeat", DbType="DateTime")]
1739	public System.Nullable<System.DateTime> LastHeartbeat
1740	{
1741	get
1742	{
1743	return this._LastHeartbeat;
1744	}
1745	set
1746	{
1747	if ((this._LastHeartbeat != value))
1748	{
1749	this.OnLastHeartbeatChanging(value);
1750	this.SendPropertyChanging();
1751	this._LastHeartbeat = value;
1752	this.SendPropertyChanged("LastHeartbeat");
1753	this.OnLastHeartbeatChanged();
1754	}
1755	}
1756	}
1757
1758	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ParentJobId", DbType="UniqueIdentifier")]
1759	public System.Nullable<System.Guid> ParentTaskId
1760	{
1761	get
1762	{
1763	return this._ParentJobId;
1764	}
1765	set
1766	{
1767	if ((this._ParentJobId != value))
1768	{
1769	if (this._Job1.HasLoadedOrAssignedValue)
1770	{
1771	throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
1772	}
1773	this.OnParentTaskIdChanging(value);
1774	this.SendPropertyChanging();
1775	this._ParentJobId = value;
1776	this.SendPropertyChanged("ParentTaskId");
1777	this.OnParentTaskIdChanged();
1778	}
1779	}
1780	}
1781
1782	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Priority", DbType="Int NOT NULL")]
1783	public int Priority
1784	{
1785	get
1786	{
1787	return this._Priority;
1788	}
1789	set
1790	{
1791	if ((this._Priority != value))
1792	{
1793	this.OnPriorityChanging(value);
1794	this.SendPropertyChanging();
1795	this._Priority = value;
1796	this.SendPropertyChanged("Priority");
1797	this.OnPriorityChanged();
1798	}
1799	}
1800	}
1801
1802	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CoresNeeded", DbType="Int NOT NULL")]
1803	public int CoresNeeded
1804	{
1805	get
1806	{
1807	return this._CoresNeeded;
1808	}
1809	set
1810	{
1811	if ((this._CoresNeeded != value))
1812	{
1813	this.OnCoresNeededChanging(value);
1814	this.SendPropertyChanging();
1815	this._CoresNeeded = value;
1816	this.SendPropertyChanged("CoresNeeded");
1817	this.OnCoresNeededChanged();
1818	}
1819	}
1820	}
1821
1822	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_MemoryNeeded", DbType="Int NOT NULL")]
1823	public int MemoryNeeded
1824	{
1825	get
1826	{
1827	return this._MemoryNeeded;
1828	}
1829	set
1830	{
1831	if ((this._MemoryNeeded != value))
1832	{
1833	this.OnMemoryNeededChanging(value);
1834	this.SendPropertyChanging();
1835	this._MemoryNeeded = value;
1836	this.SendPropertyChanged("MemoryNeeded");
1837	this.OnMemoryNeededChanged();
1838	}
1839	}
1840	}
1841
1842	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsParentJob", DbType="Bit")]
1843	public bool IsParentTask
1844	{
1845	get
1846	{
1847	return this._IsParentJob;
1848	}
1849	set
1850	{
1851	if ((this._IsParentJob != value))
1852	{
1853	this.OnIsParentTaskChanging(value);
1854	this.SendPropertyChanging();
1855	this._IsParentJob = value;
1856	this.SendPropertyChanged("IsParentTask");
1857	this.OnIsParentTaskChanged();
1858	}
1859	}
1860	}
1861
1862	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_FinishWhenChildJobsFinished", DbType="Bit")]
1863	public bool FinishWhenChildJobsFinished
1864	{
1865	get
1866	{
1867	return this._FinishWhenChildJobsFinished;
1868	}
1869	set
1870	{
1871	if ((this._FinishWhenChildJobsFinished != value))
1872	{
1873	this.OnFinishWhenChildJobsFinishedChanging(value);
1874	this.SendPropertyChanging();
1875	this._FinishWhenChildJobsFinished = value;
1876	this.SendPropertyChanged("FinishWhenChildJobsFinished");
1877	this.OnFinishWhenChildJobsFinishedChanged();
1878	}
1879	}
1880	}
1881
1882	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Command", DbType="VarChar(30)", CanBeNull=true)]
1883	public global::HeuristicLab.Services.Hive.DataAccess.Command? Command
1884	{
1885	get
1886	{
1887	return this._Command;
1888	}
1889	set
1890	{
1891	if ((this._Command != value))
1892	{
1893	this.OnCommandChanging(value);
1894	this.SendPropertyChanging();
1895	this._Command = value;
1896	this.SendPropertyChanged("Command");
1897	this.OnCommandChanged();
1898	}
1899	}
1900	}
1901
1902	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_HiveExperimentId", DbType="UniqueIdentifier NOT NULL")]
1903	public System.Guid JobId
1904	{
1905	get
1906	{
1907	return this._HiveExperimentId;
1908	}
1909	set
1910	{
1911	if ((this._HiveExperimentId != value))
1912	{
1913	if (this._HiveExperiment.HasLoadedOrAssignedValue)
1914	{
1915	throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
1916	}
1917	this.OnJobIdChanging(value);
1918	this.SendPropertyChanging();
1919	this._HiveExperimentId = value;
1920	this.SendPropertyChanged("JobId");
1921	this.OnJobIdChanged();
1922	}
1923	}
1924	}
1925
1926	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_AssignedResource", Storage="_AssignedResources", ThisKey="TaskId", OtherKey="TaskId")]
1927	public EntitySet<AssignedResource> AssignedResources
1928	{
1929	get
1930	{
1931	return this._AssignedResources;
1932	}
1933	set
1934	{
1935	this._AssignedResources.Assign(value);
1936	}
1937	}
1938
1939	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_RequiredPlugin", Storage="_RequiredPlugins", ThisKey="TaskId", OtherKey="TaskId")]
1940	public EntitySet<RequiredPlugin> RequiredPlugins
1941	{
1942	get
1943	{
1944	return this._RequiredPlugins;
1945	}
1946	set
1947	{
1948	this._RequiredPlugins.Assign(value);
1949	}
1950	}
1951
1952	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_Task", Storage="_Jobs", ThisKey="TaskId", OtherKey="ParentTaskId")]
1953	public EntitySet<Task> ChildJobs
1954	{
1955	get
1956	{
1957	return this._Jobs;
1958	}
1959	set
1960	{
1961	this._Jobs.Assign(value);
1962	}
1963	}
1964
1965	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_TaskData", Storage="_JobData", ThisKey="TaskId", OtherKey="TaskId", IsUnique=true, IsForeignKey=false)]
1966	public TaskData JobData
1967	{
1968	get
1969	{
1970	return this._JobData.Entity;
1971	}
1972	set
1973	{
1974	TaskData previousValue = this._JobData.Entity;
1975	if (((previousValue != value)
1976	\|\| (this._JobData.HasLoadedOrAssignedValue == false)))
1977	{
1978	this.SendPropertyChanging();
1979	if ((previousValue != null))
1980	{
1981	this._JobData.Entity = null;
1982	previousValue.Task = null;
1983	}
1984	this._JobData.Entity = value;
1985	if ((value != null))
1986	{
1987	value.Task = this;
1988	}
1989	this.SendPropertyChanged("JobData");
1990	}
1991	}
1992	}
1993
1994	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_StateLog", Storage="_StateLogs", ThisKey="TaskId", OtherKey="TaskId")]
1995	public EntitySet<StateLog> StateLogs
1996	{
1997	get
1998	{
1999	return this._StateLogs;
2000	}
2001	set
2002	{
2003	this._StateLogs.Assign(value);
2004	}
2005	}
2006
2007	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_Task", Storage="_Job1", ThisKey="ParentTaskId", OtherKey="TaskId", IsForeignKey=true)]
2008	public Task ParentJob
2009	{
2010	get
2011	{
2012	return this._Job1.Entity;
2013	}
2014	set
2015	{
2016	Task previousValue = this._Job1.Entity;
2017	if (((previousValue != value)
2018	\|\| (this._Job1.HasLoadedOrAssignedValue == false)))
2019	{
2020	this.SendPropertyChanging();
2021	if ((previousValue != null))
2022	{
2023	this._Job1.Entity = null;
2024	previousValue.ChildJobs.Remove(this);
2025	}
2026	this._Job1.Entity = value;
2027	if ((value != null))
2028	{
2029	value.ChildJobs.Add(this);
2030	this._ParentJobId = value.TaskId;
2031	}
2032	else
2033	{
2034	this._ParentJobId = default(Nullable<System.Guid>);
2035	}
2036	this.SendPropertyChanged("ParentJob");
2037	}
2038	}
2039	}
2040
2041	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_Task", Storage="_HiveExperiment", ThisKey="JobId", OtherKey="JobId", IsForeignKey=true)]
2042	public Job Job
2043	{
2044	get
2045	{
2046	return this._HiveExperiment.Entity;
2047	}
2048	set
2049	{
2050	Job previousValue = this._HiveExperiment.Entity;
2051	if (((previousValue != value)
2052	\|\| (this._HiveExperiment.HasLoadedOrAssignedValue == false)))
2053	{
2054	this.SendPropertyChanging();
2055	if ((previousValue != null))
2056	{
2057	this._HiveExperiment.Entity = null;
2058	previousValue.Tasks.Remove(this);
2059	}
2060	this._HiveExperiment.Entity = value;
2061	if ((value != null))
2062	{
2063	value.Tasks.Add(this);
2064	this._HiveExperimentId = value.JobId;
2065	}
2066	else
2067	{
2068	this._HiveExperimentId = default(System.Guid);
2069	}
2070	this.SendPropertyChanged("Job");
2071	}
2072	}
2073	}
2074
2075	public event PropertyChangingEventHandler PropertyChanging;
2076
2077	public event PropertyChangedEventHandler PropertyChanged;
2078
2079	protected virtual void SendPropertyChanging()
2080	{
2081	if ((this.PropertyChanging != null))
2082	{
2083	this.PropertyChanging(this, emptyChangingEventArgs);
2084	}
2085	}
2086
2087	protected virtual void SendPropertyChanged(String propertyName)
2088	{
2089	if ((this.PropertyChanged != null))
2090	{
2091	this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2092	}
2093	}
2094
2095	private void attach_AssignedResources(AssignedResource entity)
2096	{
2097	this.SendPropertyChanging();
2098	entity.Task = this;
2099	}
2100
2101	private void detach_AssignedResources(AssignedResource entity)
2102	{
2103	this.SendPropertyChanging();
2104	entity.Task = null;
2105	}
2106
2107	private void attach_RequiredPlugins(RequiredPlugin entity)
2108	{
2109	this.SendPropertyChanging();
2110	entity.Task = this;
2111	}
2112
2113	private void detach_RequiredPlugins(RequiredPlugin entity)
2114	{
2115	this.SendPropertyChanging();
2116	entity.Task = null;
2117	}
2118
2119	private void attach_Jobs(Task entity)
2120	{
2121	this.SendPropertyChanging();
2122	entity.ParentJob = this;
2123	}
2124
2125	private void detach_Jobs(Task entity)
2126	{
2127	this.SendPropertyChanging();
2128	entity.ParentJob = null;
2129	}
2130
2131	private void attach_StateLogs(StateLog entity)
2132	{
2133	this.SendPropertyChanging();
2134	entity.Task = this;
2135	}
2136
2137	private void detach_StateLogs(StateLog entity)
2138	{
2139	this.SendPropertyChanging();
2140	entity.Task = null;
2141	}
2142	}
2143
2144	[global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Downtime")]
2145	public partial class Downtime : INotifyPropertyChanging, INotifyPropertyChanged
2146	{
2147
2148	private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2149
2150	private System.Guid _UptimeCalendarId;
2151
2152	private System.Guid _ResourceId;
2153
2154	private System.DateTime _StartDate;
2155
2156	private System.DateTime _EndDate;
2157
2158	private bool _AllDayEvent;
2159
2160	private bool _Recurring;
2161
2162	private System.Guid _RecurringId;
2163
2164	private global::HeuristicLab.Services.Hive.DataAccess.DowntimeType _Type;
2165
2166	private EntityRef<Resource> _Resource;
2167
2168	#region Extensibility Method Definitions
2169	partial void OnLoaded();
2170	partial void OnValidate(System.Data.Linq.ChangeAction action);
2171	partial void OnCreated();
2172	partial void OnDowntimeIdChanging(System.Guid value);
2173	partial void OnDowntimeIdChanged();
2174	partial void OnResourceIdChanging(System.Guid value);
2175	partial void OnResourceIdChanged();
2176	partial void OnStartDateChanging(System.DateTime value);
2177	partial void OnStartDateChanged();
2178	partial void OnEndDateChanging(System.DateTime value);
2179	partial void OnEndDateChanged();
2180	partial void OnAllDayEventChanging(bool value);
2181	partial void OnAllDayEventChanged();
2182	partial void OnRecurringChanging(bool value);
2183	partial void OnRecurringChanged();
2184	partial void OnRecurringIdChanging(System.Guid value);
2185	partial void OnRecurringIdChanged();
2186	partial void OnDowntimeTypeChanging(global::HeuristicLab.Services.Hive.DataAccess.DowntimeType value);
2187	partial void OnDowntimeTypeChanged();
2188	#endregion
2189
2190	public Downtime()
2191	{
2192	this._Resource = default(EntityRef<Resource>);
2193	OnCreated();
2194	}
2195
2196	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UptimeCalendarId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier", IsPrimaryKey=true, IsDbGenerated=true)]
2197	public System.Guid DowntimeId
2198	{
2199	get
2200	{
2201	return this._UptimeCalendarId;
2202	}
2203	set
2204	{
2205	if ((this._UptimeCalendarId != value))
2206	{
2207	this.OnDowntimeIdChanging(value);
2208	this.SendPropertyChanging();
2209	this._UptimeCalendarId = value;
2210	this.SendPropertyChanged("DowntimeId");
2211	this.OnDowntimeIdChanged();
2212	}
2213	}
2214	}
2215
2216	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier")]
2217	public System.Guid ResourceId
2218	{
2219	get
2220	{
2221	return this._ResourceId;
2222	}
2223	set
2224	{
2225	if ((this._ResourceId != value))
2226	{
2227	if (this._Resource.HasLoadedOrAssignedValue)
2228	{
2229	throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2230	}
2231	this.OnResourceIdChanging(value);
2232	this.SendPropertyChanging();
2233	this._ResourceId = value;
2234	this.SendPropertyChanged("ResourceId");
2235	this.OnResourceIdChanged();
2236	}
2237	}
2238	}
2239
2240	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StartDate", DbType="DateTime")]
2241	public System.DateTime StartDate
2242	{
2243	get
2244	{
2245	return this._StartDate;
2246	}
2247	set
2248	{
2249	if ((this._StartDate != value))
2250	{
2251	this.OnStartDateChanging(value);
2252	this.SendPropertyChanging();
2253	this._StartDate = value;
2254	this.SendPropertyChanged("StartDate");
2255	this.OnStartDateChanged();
2256	}
2257	}
2258	}
2259
2260	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_EndDate", DbType="DateTime")]
2261	public System.DateTime EndDate
2262	{
2263	get
2264	{
2265	return this._EndDate;
2266	}
2267	set
2268	{
2269	if ((this._EndDate != value))
2270	{
2271	this.OnEndDateChanging(value);
2272	this.SendPropertyChanging();
2273	this._EndDate = value;
2274	this.SendPropertyChanged("EndDate");
2275	this.OnEndDateChanged();
2276	}
2277	}
2278	}
2279
2280	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_AllDayEvent", DbType="Bit")]
2281	public bool AllDayEvent
2282	{
2283	get
2284	{
2285	return this._AllDayEvent;
2286	}
2287	set
2288	{
2289	if ((this._AllDayEvent != value))
2290	{
2291	this.OnAllDayEventChanging(value);
2292	this.SendPropertyChanging();
2293	this._AllDayEvent = value;
2294	this.SendPropertyChanged("AllDayEvent");
2295	this.OnAllDayEventChanged();
2296	}
2297	}
2298	}
2299
2300	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Recurring", DbType="Bit")]
2301	public bool Recurring
2302	{
2303	get
2304	{
2305	return this._Recurring;
2306	}
2307	set
2308	{
2309	if ((this._Recurring != value))
2310	{
2311	this.OnRecurringChanging(value);
2312	this.SendPropertyChanging();
2313	this._Recurring = value;
2314	this.SendPropertyChanged("Recurring");
2315	this.OnRecurringChanged();
2316	}
2317	}
2318	}
2319
2320	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_RecurringId", DbType="UniqueIdentifier")]
2321	public System.Guid RecurringId
2322	{
2323	get
2324	{
2325	return this._RecurringId;
2326	}
2327	set
2328	{
2329	if ((this._RecurringId != value))
2330	{
2331	this.OnRecurringIdChanging(value);
2332	this.SendPropertyChanging();
2333	this._RecurringId = value;
2334	this.SendPropertyChanged("RecurringId");
2335	this.OnRecurringIdChanged();
2336	}
2337	}
2338	}
2339
2340	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Type", DbType="VarChar(MAX)", CanBeNull=false)]
2341	public global::HeuristicLab.Services.Hive.DataAccess.DowntimeType DowntimeType
2342	{
2343	get
2344	{
2345	return this._Type;
2346	}
2347	set
2348	{
2349	if ((this._Type != value))
2350	{
2351	this.OnDowntimeTypeChanging(value);
2352	this.SendPropertyChanging();
2353	this._Type = value;
2354	this.SendPropertyChanged("DowntimeType");
2355	this.OnDowntimeTypeChanged();
2356	}
2357	}
2358	}
2359
2360	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_Downtime", Storage="_Resource", ThisKey="ResourceId", OtherKey="ResourceId", IsForeignKey=true, DeleteRule="CASCADE")]
2361	public Resource Resource
2362	{
2363	get
2364	{
2365	return this._Resource.Entity;
2366	}
2367	set
2368	{
2369	Resource previousValue = this._Resource.Entity;
2370	if (((previousValue != value)
2371	\|\| (this._Resource.HasLoadedOrAssignedValue == false)))
2372	{
2373	this.SendPropertyChanging();
2374	if ((previousValue != null))
2375	{
2376	this._Resource.Entity = null;
2377	previousValue.Downtimes.Remove(this);
2378	}
2379	this._Resource.Entity = value;
2380	if ((value != null))
2381	{
2382	value.Downtimes.Add(this);
2383	this._ResourceId = value.ResourceId;
2384	}
2385	else
2386	{
2387	this._ResourceId = default(System.Guid);
2388	}
2389	this.SendPropertyChanged("Resource");
2390	}
2391	}
2392	}
2393
2394	public event PropertyChangingEventHandler PropertyChanging;
2395
2396	public event PropertyChangedEventHandler PropertyChanged;
2397
2398	protected virtual void SendPropertyChanging()
2399	{
2400	if ((this.PropertyChanging != null))
2401	{
2402	this.PropertyChanging(this, emptyChangingEventArgs);
2403	}
2404	}
2405
2406	protected virtual void SendPropertyChanged(String propertyName)
2407	{
2408	if ((this.PropertyChanged != null))
2409	{
2410	this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2411	}
2412	}
2413	}
2414
2415	[global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Job")]
2416	public partial class Job : INotifyPropertyChanging, INotifyPropertyChanged
2417	{
2418
2419	private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2420
2421	private System.Guid _HiveExperimentId;
2422
2423	private string _Name;
2424
2425	private string _Description;
2426
2427	private string _ResourceIds;
2428
2429	private System.Guid _UserId;
2430
2431	private System.DateTime _DateCreated;
2432
2433	private EntitySet<Task> _Jobs;
2434
2435	private EntitySet<JobPermission> _HiveExperimentPermissions;
2436
2437	#region Extensibility Method Definitions
2438	partial void OnLoaded();
2439	partial void OnValidate(System.Data.Linq.ChangeAction action);
2440	partial void OnCreated();
2441	partial void OnJobIdChanging(System.Guid value);
2442	partial void OnJobIdChanged();
2443	partial void OnNameChanging(string value);
2444	partial void OnNameChanged();
2445	partial void OnDescriptionChanging(string value);
2446	partial void OnDescriptionChanged();
2447	partial void OnResourceIdsChanging(string value);
2448	partial void OnResourceIdsChanged();
2449	partial void OnOwnerUserIdChanging(System.Guid value);
2450	partial void OnOwnerUserIdChanged();
2451	partial void OnDateCreatedChanging(System.DateTime value);
2452	partial void OnDateCreatedChanged();
2453	#endregion
2454
2455	public Job()
2456	{
2457	this._Jobs = new EntitySet<Task>(new Action<Task>(this.attach_Jobs), new Action<Task>(this.detach_Jobs));
2458	this._HiveExperimentPermissions = new EntitySet<JobPermission>(new Action<JobPermission>(this.attach_HiveExperimentPermissions), new Action<JobPermission>(this.detach_HiveExperimentPermissions));
2459	OnCreated();
2460	}
2461
2462	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_HiveExperimentId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
2463	public System.Guid JobId
2464	{
2465	get
2466	{
2467	return this._HiveExperimentId;
2468	}
2469	set
2470	{
2471	if ((this._HiveExperimentId != value))
2472	{
2473	this.OnJobIdChanging(value);
2474	this.SendPropertyChanging();
2475	this._HiveExperimentId = value;
2476	this.SendPropertyChanged("JobId");
2477	this.OnJobIdChanged();
2478	}
2479	}
2480	}
2481
2482	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX)", CanBeNull=false)]
2483	public string Name
2484	{
2485	get
2486	{
2487	return this._Name;
2488	}
2489	set
2490	{
2491	if ((this._Name != value))
2492	{
2493	this.OnNameChanging(value);
2494	this.SendPropertyChanging();
2495	this._Name = value;
2496	this.SendPropertyChanged("Name");
2497	this.OnNameChanged();
2498	}
2499	}
2500	}
2501
2502	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Description", DbType="VarChar(MAX)")]
2503	public string Description
2504	{
2505	get
2506	{
2507	return this._Description;
2508	}
2509	set
2510	{
2511	if ((this._Description != value))
2512	{
2513	this.OnDescriptionChanging(value);
2514	this.SendPropertyChanging();
2515	this._Description = value;
2516	this.SendPropertyChanged("Description");
2517	this.OnDescriptionChanged();
2518	}
2519	}
2520	}
2521
2522	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceIds", DbType="VarChar(MAX)")]
2523	public string ResourceIds
2524	{
2525	get
2526	{
2527	return this._ResourceIds;
2528	}
2529	set
2530	{
2531	if ((this._ResourceIds != value))
2532	{
2533	this.OnResourceIdsChanging(value);
2534	this.SendPropertyChanging();
2535	this._ResourceIds = value;
2536	this.SendPropertyChanged("ResourceIds");
2537	this.OnResourceIdsChanged();
2538	}
2539	}
2540	}
2541
2542	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier")]
2543	public System.Guid OwnerUserId
2544	{
2545	get
2546	{
2547	return this._UserId;
2548	}
2549	set
2550	{
2551	if ((this._UserId != value))
2552	{
2553	this.OnOwnerUserIdChanging(value);
2554	this.SendPropertyChanging();
2555	this._UserId = value;
2556	this.SendPropertyChanged("OwnerUserId");
2557	this.OnOwnerUserIdChanged();
2558	}
2559	}
2560	}
2561
2562	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateCreated", DbType="DateTime")]
2563	public System.DateTime DateCreated
2564	{
2565	get
2566	{
2567	return this._DateCreated;
2568	}
2569	set
2570	{
2571	if ((this._DateCreated != value))
2572	{
2573	this.OnDateCreatedChanging(value);
2574	this.SendPropertyChanging();
2575	this._DateCreated = value;
2576	this.SendPropertyChanged("DateCreated");
2577	this.OnDateCreatedChanged();
2578	}
2579	}
2580	}
2581
2582	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_Task", Storage="_Jobs", ThisKey="JobId", OtherKey="JobId")]
2583	public EntitySet<Task> Tasks
2584	{
2585	get
2586	{
2587	return this._Jobs;
2588	}
2589	set
2590	{
2591	this._Jobs.Assign(value);
2592	}
2593	}
2594
2595	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_JobPermission", Storage="_HiveExperimentPermissions", ThisKey="JobId", OtherKey="JobId")]
2596	public EntitySet<JobPermission> JobPermissions
2597	{
2598	get
2599	{
2600	return this._HiveExperimentPermissions;
2601	}
2602	set
2603	{
2604	this._HiveExperimentPermissions.Assign(value);
2605	}
2606	}
2607
2608	public event PropertyChangingEventHandler PropertyChanging;
2609
2610	public event PropertyChangedEventHandler PropertyChanged;
2611
2612	protected virtual void SendPropertyChanging()
2613	{
2614	if ((this.PropertyChanging != null))
2615	{
2616	this.PropertyChanging(this, emptyChangingEventArgs);
2617	}
2618	}
2619
2620	protected virtual void SendPropertyChanged(String propertyName)
2621	{
2622	if ((this.PropertyChanged != null))
2623	{
2624	this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2625	}
2626	}
2627
2628	private void attach_Jobs(Task entity)
2629	{
2630	this.SendPropertyChanging();
2631	entity.Job = this;
2632	}
2633
2634	private void detach_Jobs(Task entity)
2635	{
2636	this.SendPropertyChanging();
2637	entity.Job = null;
2638	}
2639
2640	private void attach_HiveExperimentPermissions(JobPermission entity)
2641	{
2642	this.SendPropertyChanging();
2643	entity.Job = this;
2644	}
2645
2646	private void detach_HiveExperimentPermissions(JobPermission entity)
2647	{
2648	this.SendPropertyChanging();
2649	entity.Job = null;
2650	}
2651	}
2652
2653	[global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.TaskData")]
2654	public partial class TaskData : INotifyPropertyChanging, INotifyPropertyChanged
2655	{
2656
2657	private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2658
2659	private System.Guid _JobId;
2660
2661	private System.Data.Linq.Link<byte[]> _Data;
2662
2663	private System.DateTime _LastUpdate;
2664
2665	private EntityRef<Task> _Job;
2666
2667	#region Extensibility Method Definitions
2668	partial void OnLoaded();
2669	partial void OnValidate(System.Data.Linq.ChangeAction action);
2670	partial void OnCreated();
2671	partial void OnTaskIdChanging(System.Guid value);
2672	partial void OnTaskIdChanged();
2673	partial void OnDataChanging(byte[] value);
2674	partial void OnDataChanged();
2675	partial void OnLastUpdateChanging(System.DateTime value);
2676	partial void OnLastUpdateChanged();
2677	#endregion
2678
2679	public TaskData()
2680	{
2681	this._Job = default(EntityRef<Task>);
2682	OnCreated();
2683	}
2684
2685	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
2686	public System.Guid TaskId
2687	{
2688	get
2689	{
2690	return this._JobId;
2691	}
2692	set
2693	{
2694	if ((this._JobId != value))
2695	{
2696	if (this._Job.HasLoadedOrAssignedValue)
2697	{
2698	throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2699	}
2700	this.OnTaskIdChanging(value);
2701	this.SendPropertyChanging();
2702	this._JobId = value;
2703	this.SendPropertyChanged("TaskId");
2704	this.OnTaskIdChanged();
2705	}
2706	}
2707	}
2708
2709	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Data", DbType="VarBinary(MAX)", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
2710	public byte[] Data
2711	{
2712	get
2713	{
2714	return this._Data.Value;
2715	}
2716	set
2717	{
2718	if ((this._Data.Value != value))
2719	{
2720	this.OnDataChanging(value);
2721	this.SendPropertyChanging();
2722	this._Data.Value = value;
2723	this.SendPropertyChanged("Data");
2724	this.OnDataChanged();
2725	}
2726	}
2727	}
2728
2729	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastUpdate", DbType="DateTime")]
2730	public System.DateTime LastUpdate
2731	{
2732	get
2733	{
2734	return this._LastUpdate;
2735	}
2736	set
2737	{
2738	if ((this._LastUpdate != value))
2739	{
2740	this.OnLastUpdateChanging(value);
2741	this.SendPropertyChanging();
2742	this._LastUpdate = value;
2743	this.SendPropertyChanged("LastUpdate");
2744	this.OnLastUpdateChanged();
2745	}
2746	}
2747	}
2748
2749	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_TaskData", Storage="_Job", ThisKey="TaskId", OtherKey="TaskId", IsForeignKey=true)]
2750	public Task Task
2751	{
2752	get
2753	{
2754	return this._Job.Entity;
2755	}
2756	set
2757	{
2758	Task previousValue = this._Job.Entity;
2759	if (((previousValue != value)
2760	\|\| (this._Job.HasLoadedOrAssignedValue == false)))
2761	{
2762	this.SendPropertyChanging();
2763	if ((previousValue != null))
2764	{
2765	this._Job.Entity = null;
2766	previousValue.JobData = null;
2767	}
2768	this._Job.Entity = value;
2769	if ((value != null))
2770	{
2771	value.JobData = this;
2772	this._JobId = value.TaskId;
2773	}
2774	else
2775	{
2776	this._JobId = default(System.Guid);
2777	}
2778	this.SendPropertyChanged("Task");
2779	}
2780	}
2781	}
2782
2783	public event PropertyChangingEventHandler PropertyChanging;
2784
2785	public event PropertyChangedEventHandler PropertyChanged;
2786
2787	protected virtual void SendPropertyChanging()
2788	{
2789	if ((this.PropertyChanging != null))
2790	{
2791	this.PropertyChanging(this, emptyChangingEventArgs);
2792	}
2793	}
2794
2795	protected virtual void SendPropertyChanged(String propertyName)
2796	{
2797	if ((this.PropertyChanged != null))
2798	{
2799	this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2800	}
2801	}
2802	}
2803
2804	[global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.PluginData")]
2805	public partial class PluginData : INotifyPropertyChanging, INotifyPropertyChanged
2806	{
2807
2808	private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2809
2810	private System.Guid _PluginDataId;
2811
2812	private System.Guid _PluginId;
2813
2814	private System.Data.Linq.Link<byte[]> _Data;
2815
2816	private string _FileName;
2817
2818	private EntityRef<Plugin> _Plugin;
2819
2820	#region Extensibility Method Definitions
2821	partial void OnLoaded();
2822	partial void OnValidate(System.Data.Linq.ChangeAction action);
2823	partial void OnCreated();
2824	partial void OnPluginDataIdChanging(System.Guid value);
2825	partial void OnPluginDataIdChanged();
2826	partial void OnPluginIdChanging(System.Guid value);
2827	partial void OnPluginIdChanged();
2828	partial void OnDataChanging(byte[] value);
2829	partial void OnDataChanged();
2830	partial void OnFileNameChanging(string value);
2831	partial void OnFileNameChanged();
2832	#endregion
2833
2834	public PluginData()
2835	{
2836	this._Plugin = default(EntityRef<Plugin>);
2837	OnCreated();
2838	}
2839
2840	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginDataId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
2841	public System.Guid PluginDataId
2842	{
2843	get
2844	{
2845	return this._PluginDataId;
2846	}
2847	set
2848	{
2849	if ((this._PluginDataId != value))
2850	{
2851	this.OnPluginDataIdChanging(value);
2852	this.SendPropertyChanging();
2853	this._PluginDataId = value;
2854	this.SendPropertyChanged("PluginDataId");
2855	this.OnPluginDataIdChanged();
2856	}
2857	}
2858	}
2859
2860	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginId", DbType="UniqueIdentifier NOT NULL")]
2861	public System.Guid PluginId
2862	{
2863	get
2864	{
2865	return this._PluginId;
2866	}
2867	set
2868	{
2869	if ((this._PluginId != value))
2870	{
2871	if (this._Plugin.HasLoadedOrAssignedValue)
2872	{
2873	throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2874	}
2875	this.OnPluginIdChanging(value);
2876	this.SendPropertyChanging();
2877	this._PluginId = value;
2878	this.SendPropertyChanged("PluginId");
2879	this.OnPluginIdChanged();
2880	}
2881	}
2882	}
2883
2884	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Data", DbType="VarBinary(MAX) NOT NULL", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
2885	public byte[] Data
2886	{
2887	get
2888	{
2889	return this._Data.Value;
2890	}
2891	set
2892	{
2893	if ((this._Data.Value != value))
2894	{
2895	this.OnDataChanging(value);
2896	this.SendPropertyChanging();
2897	this._Data.Value = value;
2898	this.SendPropertyChanged("Data");
2899	this.OnDataChanged();
2900	}
2901	}
2902	}
2903
2904	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_FileName", DbType="VarChar(MAX)", CanBeNull=false)]
2905	public string FileName
2906	{
2907	get
2908	{
2909	return this._FileName;
2910	}
2911	set
2912	{
2913	if ((this._FileName != value))
2914	{
2915	this.OnFileNameChanging(value);
2916	this.SendPropertyChanging();
2917	this._FileName = value;
2918	this.SendPropertyChanged("FileName");
2919	this.OnFileNameChanged();
2920	}
2921	}
2922	}
2923
2924	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_PluginData", Storage="_Plugin", ThisKey="PluginId", OtherKey="PluginId", IsForeignKey=true)]
2925	public Plugin Plugin
2926	{
2927	get
2928	{
2929	return this._Plugin.Entity;
2930	}
2931	set
2932	{
2933	Plugin previousValue = this._Plugin.Entity;
2934	if (((previousValue != value)
2935	\|\| (this._Plugin.HasLoadedOrAssignedValue == false)))
2936	{
2937	this.SendPropertyChanging();
2938	if ((previousValue != null))
2939	{
2940	this._Plugin.Entity = null;
2941	previousValue.PluginData.Remove(this);
2942	}
2943	this._Plugin.Entity = value;
2944	if ((value != null))
2945	{
2946	value.PluginData.Add(this);
2947	this._PluginId = value.PluginId;
2948	}
2949	else
2950	{
2951	this._PluginId = default(System.Guid);
2952	}
2953	this.SendPropertyChanged("Plugin");
2954	}
2955	}
2956	}
2957
2958	public event PropertyChangingEventHandler PropertyChanging;
2959
2960	public event PropertyChangedEventHandler PropertyChanged;
2961
2962	protected virtual void SendPropertyChanging()
2963	{
2964	if ((this.PropertyChanging != null))
2965	{
2966	this.PropertyChanging(this, emptyChangingEventArgs);
2967	}
2968	}
2969
2970	protected virtual void SendPropertyChanged(String propertyName)
2971	{
2972	if ((this.PropertyChanged != null))
2973	{
2974	this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2975	}
2976	}
2977	}
2978
2979	[global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.StateLog")]
2980	public partial class StateLog : INotifyPropertyChanging, INotifyPropertyChanged
2981	{
2982
2983	private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2984
2985	private System.Guid _StateLogId;
2986
2987	private global::HeuristicLab.Services.Hive.DataAccess.TaskState _State;
2988
2989	private System.DateTime _DateTime;
2990
2991	private System.Guid _JobId;
2992
2993	private System.Nullable<System.Guid> _UserId;
2994
2995	private System.Nullable<System.Guid> _SlaveId;
2996
2997	private string _Exception;
2998
2999	private EntityRef<Task> _Job;
3000
3001	private EntityRef<Resource> _Resource;
3002
3003	#region Extensibility Method Definitions
3004	partial void OnLoaded();
3005	partial void OnValidate(System.Data.Linq.ChangeAction action);
3006	partial void OnCreated();
3007	partial void OnStateLogIdChanging(System.Guid value);
3008	partial void OnStateLogIdChanged();
3009	partial void OnStateChanging(global::HeuristicLab.Services.Hive.DataAccess.TaskState value);
3010	partial void OnStateChanged();
3011	partial void OnDateTimeChanging(System.DateTime value);
3012	partial void OnDateTimeChanged();
3013	partial void OnTaskIdChanging(System.Guid value);
3014	partial void OnTaskIdChanged();
3015	partial void OnUserIdChanging(System.Nullable<System.Guid> value);
3016	partial void OnUserIdChanged();
3017	partial void OnSlaveIdChanging(System.Nullable<System.Guid> value);
3018	partial void OnSlaveIdChanged();
3019	partial void OnExceptionChanging(string value);
3020	partial void OnExceptionChanged();
3021	#endregion
3022
3023	public StateLog()
3024	{
3025	this._Job = default(EntityRef<Task>);
3026	this._Resource = default(EntityRef<Resource>);
3027	OnCreated();
3028	}
3029
3030	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StateLogId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
3031	public System.Guid StateLogId
3032	{
3033	get
3034	{
3035	return this._StateLogId;
3036	}
3037	set
3038	{
3039	if ((this._StateLogId != value))
3040	{
3041	this.OnStateLogIdChanging(value);
3042	this.SendPropertyChanging();
3043	this._StateLogId = value;
3044	this.SendPropertyChanged("StateLogId");
3045	this.OnStateLogIdChanged();
3046	}
3047	}
3048	}
3049
3050	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_State", DbType="VarChar(30) NOT NULL", CanBeNull=false)]
3051	public global::HeuristicLab.Services.Hive.DataAccess.TaskState State
3052	{
3053	get
3054	{
3055	return this._State;
3056	}
3057	set
3058	{
3059	if ((this._State != value))
3060	{
3061	this.OnStateChanging(value);
3062	this.SendPropertyChanging();
3063	this._State = value;
3064	this.SendPropertyChanged("State");
3065	this.OnStateChanged();
3066	}
3067	}
3068	}
3069
3070	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateTime", DbType="DateTime NOT NULL")]
3071	public System.DateTime DateTime
3072	{
3073	get
3074	{
3075	return this._DateTime;
3076	}
3077	set
3078	{
3079	if ((this._DateTime != value))
3080	{
3081	this.OnDateTimeChanging(value);
3082	this.SendPropertyChanging();
3083	this._DateTime = value;
3084	this.SendPropertyChanged("DateTime");
3085	this.OnDateTimeChanged();
3086	}
3087	}
3088	}
3089
3090	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL")]
3091	public System.Guid TaskId
3092	{
3093	get
3094	{
3095	return this._JobId;
3096	}
3097	set
3098	{
3099	if ((this._JobId != value))
3100	{
3101	if (this._Job.HasLoadedOrAssignedValue)
3102	{
3103	throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3104	}
3105	this.OnTaskIdChanging(value);
3106	this.SendPropertyChanging();
3107	this._JobId = value;
3108	this.SendPropertyChanged("TaskId");
3109	this.OnTaskIdChanged();
3110	}
3111	}
3112	}
3113
3114	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier")]
3115	public System.Nullable<System.Guid> UserId
3116	{
3117	get
3118	{
3119	return this._UserId;
3120	}
3121	set
3122	{
3123	if ((this._UserId != value))
3124	{
3125	this.OnUserIdChanging(value);
3126	this.SendPropertyChanging();
3127	this._UserId = value;
3128	this.SendPropertyChanged("UserId");
3129	this.OnUserIdChanged();
3130	}
3131	}
3132	}
3133
3134	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_SlaveId", DbType="UniqueIdentifier")]
3135	public System.Nullable<System.Guid> SlaveId
3136	{
3137	get
3138	{
3139	return this._SlaveId;
3140	}
3141	set
3142	{
3143	if ((this._SlaveId != value))
3144	{
3145	if (this._Resource.HasLoadedOrAssignedValue)
3146	{
3147	throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3148	}
3149	this.OnSlaveIdChanging(value);
3150	this.SendPropertyChanging();
3151	this._SlaveId = value;
3152	this.SendPropertyChanged("SlaveId");
3153	this.OnSlaveIdChanged();
3154	}
3155	}
3156	}
3157
3158	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Exception", DbType="VarChar(MAX)", CanBeNull=false)]
3159	public string Exception
3160	{
3161	get
3162	{
3163	return this._Exception;
3164	}
3165	set
3166	{
3167	if ((this._Exception != value))
3168	{
3169	this.OnExceptionChanging(value);
3170	this.SendPropertyChanging();
3171	this._Exception = value;
3172	this.SendPropertyChanged("Exception");
3173	this.OnExceptionChanged();
3174	}
3175	}
3176	}
3177
3178	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_StateLog", Storage="_Job", ThisKey="TaskId", OtherKey="TaskId", IsForeignKey=true)]
3179	public Task Task
3180	{
3181	get
3182	{
3183	return this._Job.Entity;
3184	}
3185	set
3186	{
3187	Task previousValue = this._Job.Entity;
3188	if (((previousValue != value)
3189	\|\| (this._Job.HasLoadedOrAssignedValue == false)))
3190	{
3191	this.SendPropertyChanging();
3192	if ((previousValue != null))
3193	{
3194	this._Job.Entity = null;
3195	previousValue.StateLogs.Remove(this);
3196	}
3197	this._Job.Entity = value;
3198	if ((value != null))
3199	{
3200	value.StateLogs.Add(this);
3201	this._JobId = value.TaskId;
3202	}
3203	else
3204	{
3205	this._JobId = default(System.Guid);
3206	}
3207	this.SendPropertyChanged("Task");
3208	}
3209	}
3210	}
3211
3212	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_StateLog", Storage="_Resource", ThisKey="SlaveId", OtherKey="ResourceId", IsForeignKey=true)]
3213	public Resource Resource
3214	{
3215	get
3216	{
3217	return this._Resource.Entity;
3218	}
3219	set
3220	{
3221	Resource previousValue = this._Resource.Entity;
3222	if (((previousValue != value)
3223	\|\| (this._Resource.HasLoadedOrAssignedValue == false)))
3224	{
3225	this.SendPropertyChanging();
3226	if ((previousValue != null))
3227	{
3228	this._Resource.Entity = null;
3229	previousValue.StateLogs.Remove(this);
3230	}
3231	this._Resource.Entity = value;
3232	if ((value != null))
3233	{
3234	value.StateLogs.Add(this);
3235	this._SlaveId = value.ResourceId;
3236	}
3237	else
3238	{
3239	this._SlaveId = default(Nullable<System.Guid>);
3240	}
3241	this.SendPropertyChanged("Resource");
3242	}
3243	}
3244	}
3245
3246	public event PropertyChangingEventHandler PropertyChanging;
3247
3248	public event PropertyChangedEventHandler PropertyChanged;
3249
3250	protected virtual void SendPropertyChanging()
3251	{
3252	if ((this.PropertyChanging != null))
3253	{
3254	this.PropertyChanging(this, emptyChangingEventArgs);
3255	}
3256	}
3257
3258	protected virtual void SendPropertyChanged(String propertyName)
3259	{
3260	if ((this.PropertyChanged != null))
3261	{
3262	this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3263	}
3264	}
3265	}
3266
3267	[global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.JobPermission")]
3268	public partial class JobPermission : INotifyPropertyChanging, INotifyPropertyChanged
3269	{
3270
3271	private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3272
3273	private System.Guid _HiveExperimentId;
3274
3275	private System.Guid _GrantedUserId;
3276
3277	private System.Guid _GrantedByUserId;
3278
3279	private global::HeuristicLab.Services.Hive.DataAccess.Permission _Permission;
3280
3281	private EntityRef<Job> _HiveExperiment;
3282
3283	#region Extensibility Method Definitions
3284	partial void OnLoaded();
3285	partial void OnValidate(System.Data.Linq.ChangeAction action);
3286	partial void OnCreated();
3287	partial void OnJobIdChanging(System.Guid value);
3288	partial void OnJobIdChanged();
3289	partial void OnGrantedUserIdChanging(System.Guid value);
3290	partial void OnGrantedUserIdChanged();
3291	partial void OnGrantedByUserIdChanging(System.Guid value);
3292	partial void OnGrantedByUserIdChanged();
3293	partial void OnPermissionChanging(global::HeuristicLab.Services.Hive.DataAccess.Permission value);
3294	partial void OnPermissionChanged();
3295	#endregion
3296
3297	public JobPermission()
3298	{
3299	this._HiveExperiment = default(EntityRef<Job>);
3300	OnCreated();
3301	}
3302
3303	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_HiveExperimentId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
3304	public System.Guid JobId
3305	{
3306	get
3307	{
3308	return this._HiveExperimentId;
3309	}
3310	set
3311	{
3312	if ((this._HiveExperimentId != value))
3313	{
3314	if (this._HiveExperiment.HasLoadedOrAssignedValue)
3315	{
3316	throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3317	}
3318	this.OnJobIdChanging(value);
3319	this.SendPropertyChanging();
3320	this._HiveExperimentId = value;
3321	this.SendPropertyChanged("JobId");
3322	this.OnJobIdChanged();
3323	}
3324	}
3325	}
3326
3327	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GrantedUserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
3328	public System.Guid GrantedUserId
3329	{
3330	get
3331	{
3332	return this._GrantedUserId;
3333	}
3334	set
3335	{
3336	if ((this._GrantedUserId != value))
3337	{
3338	this.OnGrantedUserIdChanging(value);
3339	this.SendPropertyChanging();
3340	this._GrantedUserId = value;
3341	this.SendPropertyChanged("GrantedUserId");
3342	this.OnGrantedUserIdChanged();
3343	}
3344	}
3345	}
3346
3347	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GrantedByUserId", DbType="UniqueIdentifier NOT NULL")]
3348	public System.Guid GrantedByUserId
3349	{
3350	get
3351	{
3352	return this._GrantedByUserId;
3353	}
3354	set
3355	{
3356	if ((this._GrantedByUserId != value))
3357	{
3358	this.OnGrantedByUserIdChanging(value);
3359	this.SendPropertyChanging();
3360	this._GrantedByUserId = value;
3361	this.SendPropertyChanged("GrantedByUserId");
3362	this.OnGrantedByUserIdChanged();
3363	}
3364	}
3365	}
3366
3367	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Permission", DbType="VarChar(15) NOT NULL", CanBeNull=false)]
3368	public global::HeuristicLab.Services.Hive.DataAccess.Permission Permission
3369	{
3370	get
3371	{
3372	return this._Permission;
3373	}
3374	set
3375	{
3376	if ((this._Permission != value))
3377	{
3378	this.OnPermissionChanging(value);
3379	this.SendPropertyChanging();
3380	this._Permission = value;
3381	this.SendPropertyChanged("Permission");
3382	this.OnPermissionChanged();
3383	}
3384	}
3385	}
3386
3387	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_JobPermission", Storage="_HiveExperiment", ThisKey="JobId", OtherKey="JobId", IsForeignKey=true)]
3388	public Job Job
3389	{
3390	get
3391	{
3392	return this._HiveExperiment.Entity;
3393	}
3394	set
3395	{
3396	Job previousValue = this._HiveExperiment.Entity;
3397	if (((previousValue != value)
3398	\|\| (this._HiveExperiment.HasLoadedOrAssignedValue == false)))
3399	{
3400	this.SendPropertyChanging();
3401	if ((previousValue != null))
3402	{
3403	this._HiveExperiment.Entity = null;
3404	previousValue.JobPermissions.Remove(this);
3405	}
3406	this._HiveExperiment.Entity = value;
3407	if ((value != null))
3408	{
3409	value.JobPermissions.Add(this);
3410	this._HiveExperimentId = value.JobId;
3411	}
3412	else
3413	{
3414	this._HiveExperimentId = default(System.Guid);
3415	}
3416	this.SendPropertyChanged("Job");
3417	}
3418	}
3419	}
3420
3421	public event PropertyChangingEventHandler PropertyChanging;
3422
3423	public event PropertyChangedEventHandler PropertyChanged;
3424
3425	protected virtual void SendPropertyChanging()
3426	{
3427	if ((this.PropertyChanging != null))
3428	{
3429	this.PropertyChanging(this, emptyChangingEventArgs);
3430	}
3431	}
3432
3433	protected virtual void SendPropertyChanged(String propertyName)
3434	{
3435	if ((this.PropertyChanged != null))
3436	{
3437	this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3438	}
3439	}
3440	}
3441
3442	[global::System.Data.Linq.Mapping.TableAttribute(Name="")]
3443	public partial class Lifecycle : INotifyPropertyChanging, INotifyPropertyChanged
3444	{
3445
3446	private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3447
3448	private int _LifecycleId;
3449
3450	private System.DateTime _LastCleanup;
3451
3452	#region Extensibility Method Definitions
3453	partial void OnLoaded();
3454	partial void OnValidate(System.Data.Linq.ChangeAction action);
3455	partial void OnCreated();
3456	partial void OnLifecycleIdChanging(int value);
3457	partial void OnLifecycleIdChanged();
3458	partial void OnLastCleanupChanging(System.DateTime value);
3459	partial void OnLastCleanupChanged();
3460	#endregion
3461
3462	public Lifecycle()
3463	{
3464	OnCreated();
3465	}
3466
3467	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LifecycleId", DbType="Int", IsPrimaryKey=true)]
3468	public int LifecycleId
3469	{
3470	get
3471	{
3472	return this._LifecycleId;
3473	}
3474	set
3475	{
3476	if ((this._LifecycleId != value))
3477	{
3478	this.OnLifecycleIdChanging(value);
3479	this.SendPropertyChanging();
3480	this._LifecycleId = value;
3481	this.SendPropertyChanged("LifecycleId");
3482	this.OnLifecycleIdChanged();
3483	}
3484	}
3485	}
3486
3487	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastCleanup", DbType="DateTime")]
3488	public System.DateTime LastCleanup
3489	{
3490	get
3491	{
3492	return this._LastCleanup;
3493	}
3494	set
3495	{
3496	if ((this._LastCleanup != value))
3497	{
3498	this.OnLastCleanupChanging(value);
3499	this.SendPropertyChanging();
3500	this._LastCleanup = value;
3501	this.SendPropertyChanged("LastCleanup");
3502	this.OnLastCleanupChanged();
3503	}
3504	}
3505	}
3506
3507	public event PropertyChangingEventHandler PropertyChanging;
3508
3509	public event PropertyChangedEventHandler PropertyChanged;
3510
3511	protected virtual void SendPropertyChanging()
3512	{
3513	if ((this.PropertyChanging != null))
3514	{
3515	this.PropertyChanging(this, emptyChangingEventArgs);
3516	}
3517	}
3518
3519	protected virtual void SendPropertyChanged(String propertyName)
3520	{
3521	if ((this.PropertyChanged != null))
3522	{
3523	this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3524	}
3525	}
3526	}
3527
3528	[global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ResourcePermission")]
3529	public partial class ResourcePermission : INotifyPropertyChanging, INotifyPropertyChanged
3530	{
3531
3532	private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3533
3534	private System.Guid _ResourceId;
3535
3536	private System.Guid _GrantedUserId;
3537
3538	private System.Guid _GrantedByUserId;
3539
3540	private EntityRef<Resource> _Resource;
3541
3542	#region Extensibility Method Definitions
3543	partial void OnLoaded();
3544	partial void OnValidate(System.Data.Linq.ChangeAction action);
3545	partial void OnCreated();
3546	partial void OnResourceIdChanging(System.Guid value);
3547	partial void OnResourceIdChanged();
3548	partial void OnGrantedUserIdChanging(System.Guid value);
3549	partial void OnGrantedUserIdChanged();
3550	partial void OnGrantedByUserIdChanging(System.Guid value);
3551	partial void OnGrantedByUserIdChanged();
3552	#endregion
3553
3554	public ResourcePermission()
3555	{
3556	this._Resource = default(EntityRef<Resource>);
3557	OnCreated();
3558	}
3559
3560	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
3561	public System.Guid ResourceId
3562	{
3563	get
3564	{
3565	return this._ResourceId;
3566	}
3567	set
3568	{
3569	if ((this._ResourceId != value))
3570	{
3571	if (this._Resource.HasLoadedOrAssignedValue)
3572	{
3573	throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3574	}
3575	this.OnResourceIdChanging(value);
3576	this.SendPropertyChanging();
3577	this._ResourceId = value;
3578	this.SendPropertyChanged("ResourceId");
3579	this.OnResourceIdChanged();
3580	}
3581	}
3582	}
3583
3584	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GrantedUserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
3585	public System.Guid GrantedUserId
3586	{
3587	get
3588	{
3589	return this._GrantedUserId;
3590	}
3591	set
3592	{
3593	if ((this._GrantedUserId != value))
3594	{
3595	this.OnGrantedUserIdChanging(value);
3596	this.SendPropertyChanging();
3597	this._GrantedUserId = value;
3598	this.SendPropertyChanged("GrantedUserId");
3599	this.OnGrantedUserIdChanged();
3600	}
3601	}
3602	}
3603
3604	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GrantedByUserId", DbType="UniqueIdentifier NOT NULL")]
3605	public System.Guid GrantedByUserId
3606	{
3607	get
3608	{
3609	return this._GrantedByUserId;
3610	}
3611	set
3612	{
3613	if ((this._GrantedByUserId != value))
3614	{
3615	this.OnGrantedByUserIdChanging(value);
3616	this.SendPropertyChanging();
3617	this._GrantedByUserId = value;
3618	this.SendPropertyChanged("GrantedByUserId");
3619	this.OnGrantedByUserIdChanged();
3620	}
3621	}
3622	}
3623
3624	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_ResourcePermission", Storage="_Resource", ThisKey="ResourceId", OtherKey="ResourceId", IsForeignKey=true)]
3625	public Resource Resource
3626	{
3627	get
3628	{
3629	return this._Resource.Entity;
3630	}
3631	set
3632	{
3633	Resource previousValue = this._Resource.Entity;
3634	if (((previousValue != value)
3635	\|\| (this._Resource.HasLoadedOrAssignedValue == false)))
3636	{
3637	this.SendPropertyChanging();
3638	if ((previousValue != null))
3639	{
3640	this._Resource.Entity = null;
3641	previousValue.ResourcePermissions.Remove(this);
3642	}
3643	this._Resource.Entity = value;
3644	if ((value != null))
3645	{
3646	value.ResourcePermissions.Add(this);
3647	this._ResourceId = value.ResourceId;
3648	}
3649	else
3650	{
3651	this._ResourceId = default(System.Guid);
3652	}
3653	this.SendPropertyChanged("Resource");
3654	}
3655	}
3656	}
3657
3658	public event PropertyChangingEventHandler PropertyChanging;
3659
3660	public event PropertyChangedEventHandler PropertyChanged;
3661
3662	protected virtual void SendPropertyChanging()
3663	{
3664	if ((this.PropertyChanging != null))
3665	{
3666	this.PropertyChanging(this, emptyChangingEventArgs);
3667	}
3668	}
3669
3670	protected virtual void SendPropertyChanged(String propertyName)
3671	{
3672	if ((this.PropertyChanged != null))
3673	{
3674	this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3675	}
3676	}
3677	}
3678
3679	[global::System.Data.Linq.Mapping.TableAttribute(Name="")]
3680	public partial class UserPriority : INotifyPropertyChanging, INotifyPropertyChanged
3681	{
3682
3683	private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3684
3685	private System.Guid _UserId;
3686
3687	private System.DateTime _DateEnqueued;
3688
3689	#region Extensibility Method Definitions
3690	partial void OnLoaded();
3691	partial void OnValidate(System.Data.Linq.ChangeAction action);
3692	partial void OnCreated();
3693	partial void OnUserIdChanging(System.Guid value);
3694	partial void OnUserIdChanged();
3695	partial void OnDateEnqueuedChanging(System.DateTime value);
3696	partial void OnDateEnqueuedChanged();
3697	#endregion
3698
3699	public UserPriority()
3700	{
3701	OnCreated();
3702	}
3703
3704	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
3705	public System.Guid UserId
3706	{
3707	get
3708	{
3709	return this._UserId;
3710	}
3711	set
3712	{
3713	if ((this._UserId != value))
3714	{
3715	this.OnUserIdChanging(value);
3716	this.SendPropertyChanging();
3717	this._UserId = value;
3718	this.SendPropertyChanged("UserId");
3719	this.OnUserIdChanged();
3720	}
3721	}
3722	}
3723
3724	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateEnqueued", DbType="DateTime NOT NULL")]
3725	public System.DateTime DateEnqueued
3726	{
3727	get
3728	{
3729	return this._DateEnqueued;
3730	}
3731	set
3732	{
3733	if ((this._DateEnqueued != value))
3734	{
3735	this.OnDateEnqueuedChanging(value);
3736	this.SendPropertyChanging();
3737	this._DateEnqueued = value;
3738	this.SendPropertyChanged("DateEnqueued");
3739	this.OnDateEnqueuedChanged();
3740	}
3741	}
3742	}
3743
3744	public event PropertyChangingEventHandler PropertyChanging;
3745
3746	public event PropertyChangedEventHandler PropertyChanged;
3747
3748	protected virtual void SendPropertyChanging()
3749	{
3750	if ((this.PropertyChanging != null))
3751	{
3752	this.PropertyChanging(this, emptyChangingEventArgs);
3753	}
3754	}
3755
3756	protected virtual void SendPropertyChanged(String propertyName)
3757	{
3758	if ((this.PropertyChanged != null))
3759	{
3760	this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3761	}
3762	}
3763	}
3764
3765	[global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimClient")]
3766	public partial class DimClient : INotifyPropertyChanging, INotifyPropertyChanged
3767	{
3768
3769	private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3770
3771	private System.Guid _Id;
3772
3773	private string _Name;
3774
3775	private System.Guid _ResourceId;
3776
3777	private System.Nullable<System.DateTime> _ExpirationTime;
3778
3779	private System.Nullable<System.Guid> _ResourceGroupId;
3780
3781	private System.Nullable<System.Guid> _ResourceGroup2Id;
3782
3783	private string _GroupName;
3784
3785	private string _GroupName2;
3786
3787	private EntitySet<FactTask> _FactTasks;
3788
3789	private EntitySet<FactClientInfo> _FactClientInfos;
3790
3791	#region Extensibility Method Definitions
3792	partial void OnLoaded();
3793	partial void OnValidate(System.Data.Linq.ChangeAction action);
3794	partial void OnCreated();
3795	partial void OnIdChanging(System.Guid value);
3796	partial void OnIdChanged();
3797	partial void OnNameChanging(string value);
3798	partial void OnNameChanged();
3799	partial void OnResourceIdChanging(System.Guid value);
3800	partial void OnResourceIdChanged();
3801	partial void OnExpirationTimeChanging(System.Nullable<System.DateTime> value);
3802	partial void OnExpirationTimeChanged();
3803	partial void OnResourceGroupIdChanging(System.Nullable<System.Guid> value);
3804	partial void OnResourceGroupIdChanged();
3805	partial void OnResourceGroup2IdChanging(System.Nullable<System.Guid> value);
3806	partial void OnResourceGroup2IdChanged();
3807	partial void OnGroupNameChanging(string value);
3808	partial void OnGroupNameChanged();
3809	partial void OnGroupName2Changing(string value);
3810	partial void OnGroupName2Changed();
3811	#endregion
3812
3813	public DimClient()
3814	{
3815	this._FactTasks = new EntitySet<FactTask>(new Action<FactTask>(this.attach_FactTasks), new Action<FactTask>(this.detach_FactTasks));
3816	this._FactClientInfos = new EntitySet<FactClientInfo>(new Action<FactClientInfo>(this.attach_FactClientInfos), new Action<FactClientInfo>(this.detach_FactClientInfos));
3817	OnCreated();
3818	}
3819
3820	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
3821	public System.Guid Id
3822	{
3823	get
3824	{
3825	return this._Id;
3826	}
3827	set
3828	{
3829	if ((this._Id != value))
3830	{
3831	this.OnIdChanging(value);
3832	this.SendPropertyChanging();
3833	this._Id = value;
3834	this.SendPropertyChanged("Id");
3835	this.OnIdChanged();
3836	}
3837	}
3838	}
3839
3840	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
3841	public string Name
3842	{
3843	get
3844	{
3845	return this._Name;
3846	}
3847	set
3848	{
3849	if ((this._Name != value))
3850	{
3851	this.OnNameChanging(value);
3852	this.SendPropertyChanging();
3853	this._Name = value;
3854	this.SendPropertyChanged("Name");
3855	this.OnNameChanged();
3856	}
3857	}
3858	}
3859
3860	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier NOT NULL")]
3861	public System.Guid ResourceId
3862	{
3863	get
3864	{
3865	return this._ResourceId;
3866	}
3867	set
3868	{
3869	if ((this._ResourceId != value))
3870	{
3871	this.OnResourceIdChanging(value);
3872	this.SendPropertyChanging();
3873	this._ResourceId = value;
3874	this.SendPropertyChanged("ResourceId");
3875	this.OnResourceIdChanged();
3876	}
3877	}
3878	}
3879
3880	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ExpirationTime", DbType="DateTime")]
3881	public System.Nullable<System.DateTime> ExpirationTime
3882	{
3883	get
3884	{
3885	return this._ExpirationTime;
3886	}
3887	set
3888	{
3889	if ((this._ExpirationTime != value))
3890	{
3891	this.OnExpirationTimeChanging(value);
3892	this.SendPropertyChanging();
3893	this._ExpirationTime = value;
3894	this.SendPropertyChanged("ExpirationTime");
3895	this.OnExpirationTimeChanged();
3896	}
3897	}
3898	}
3899
3900	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceGroupId", DbType="UniqueIdentifier")]
3901	public System.Nullable<System.Guid> ResourceGroupId
3902	{
3903	get
3904	{
3905	return this._ResourceGroupId;
3906	}
3907	set
3908	{
3909	if ((this._ResourceGroupId != value))
3910	{
3911	this.OnResourceGroupIdChanging(value);
3912	this.SendPropertyChanging();
3913	this._ResourceGroupId = value;
3914	this.SendPropertyChanged("ResourceGroupId");
3915	this.OnResourceGroupIdChanged();
3916	}
3917	}
3918	}
3919
3920	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceGroup2Id", DbType="UniqueIdentifier")]
3921	public System.Nullable<System.Guid> ResourceGroup2Id
3922	{
3923	get
3924	{
3925	return this._ResourceGroup2Id;
3926	}
3927	set
3928	{
3929	if ((this._ResourceGroup2Id != value))
3930	{
3931	this.OnResourceGroup2IdChanging(value);
3932	this.SendPropertyChanging();
3933	this._ResourceGroup2Id = value;
3934	this.SendPropertyChanged("ResourceGroup2Id");
3935	this.OnResourceGroup2IdChanged();
3936	}
3937	}
3938	}
3939
3940	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GroupName")]
3941	public string GroupName
3942	{
3943	get
3944	{
3945	return this._GroupName;
3946	}
3947	set
3948	{
3949	if ((this._GroupName != value))
3950	{
3951	this.OnGroupNameChanging(value);
3952	this.SendPropertyChanging();
3953	this._GroupName = value;
3954	this.SendPropertyChanged("GroupName");
3955	this.OnGroupNameChanged();
3956	}
3957	}
3958	}
3959
3960	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GroupName2")]
3961	public string GroupName2
3962	{
3963	get
3964	{
3965	return this._GroupName2;
3966	}
3967	set
3968	{
3969	if ((this._GroupName2 != value))
3970	{
3971	this.OnGroupName2Changing(value);
3972	this.SendPropertyChanging();
3973	this._GroupName2 = value;
3974	this.SendPropertyChanged("GroupName2");
3975	this.OnGroupName2Changed();
3976	}
3977	}
3978	}
3979
3980	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactTask", Storage="_FactTasks", ThisKey="Id", OtherKey="LastClientId")]
3981	public EntitySet<FactTask> FactTasks
3982	{
3983	get
3984	{
3985	return this._FactTasks;
3986	}
3987	set
3988	{
3989	this._FactTasks.Assign(value);
3990	}
3991	}
3992
3993	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactClientInfo", Storage="_FactClientInfos", ThisKey="Id", OtherKey="ClientId")]
3994	public EntitySet<FactClientInfo> FactClientInfos
3995	{
3996	get
3997	{
3998	return this._FactClientInfos;
3999	}
4000	set
4001	{
4002	this._FactClientInfos.Assign(value);
4003	}
4004	}
4005
4006	public event PropertyChangingEventHandler PropertyChanging;
4007
4008	public event PropertyChangedEventHandler PropertyChanged;
4009
4010	protected virtual void SendPropertyChanging()
4011	{
4012	if ((this.PropertyChanging != null))
4013	{
4014	this.PropertyChanging(this, emptyChangingEventArgs);
4015	}
4016	}
4017
4018	protected virtual void SendPropertyChanged(String propertyName)
4019	{
4020	if ((this.PropertyChanged != null))
4021	{
4022	this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
4023	}
4024	}
4025
4026	private void attach_FactTasks(FactTask entity)
4027	{
4028	this.SendPropertyChanging();
4029	entity.DimClient = this;
4030	}
4031
4032	private void detach_FactTasks(FactTask entity)
4033	{
4034	this.SendPropertyChanging();
4035	entity.DimClient = null;
4036	}
4037
4038	private void attach_FactClientInfos(FactClientInfo entity)
4039	{
4040	this.SendPropertyChanging();
4041	entity.DimClient = this;
4042	}
4043
4044	private void detach_FactClientInfos(FactClientInfo entity)
4045	{
4046	this.SendPropertyChanging();
4047	entity.DimClient = null;
4048	}
4049	}
4050
4051	[global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].FactTask")]
4052	public partial class FactTask : INotifyPropertyChanging, INotifyPropertyChanged
4053	{
4054
4055	private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
4056
4057	private System.Guid _TaskId;
4058
4059	private long _TotalRuntime;
4060
4061	private long _TotalWaitingTime;
4062
4063	private long _TotalTransferTime;
4064
4065	private int _NumCalculationRuns;
4066
4067	private int _NumFails;
4068
4069	private int _CoresRequired;
4070
4071	private int _MemoryRequired;
4072
4073	private int _Priority;
4074
4075	private System.Nullable<System.Guid> _LastClientId;
4076
4077	private System.Guid _JobId;
4078
4079	private System.Nullable<System.DateTime> _EndTime;
4080
4081	private global::HeuristicLab.Services.Hive.DataAccess.TaskState _TaskState;
4082
4083	private string _Exception;
4084
4085	private long _InitialWaitingTimeMs;
4086
4087	private System.Nullable<System.DateTime> _StartTime;
4088
4089	private EntityRef<DimClient> _DimClient;
4090
4091	private EntityRef<DimJob> _DimJob;
4092
4093	#region Extensibility Method Definitions
4094	partial void OnLoaded();
4095	partial void OnValidate(System.Data.Linq.ChangeAction action);
4096	partial void OnCreated();
4097	partial void OnTaskIdChanging(System.Guid value);
4098	partial void OnTaskIdChanged();
4099	partial void OnCalculatingTimeChanging(long value);
4100	partial void OnCalculatingTimeChanged();
4101	partial void OnWaitingTimeChanging(long value);
4102	partial void OnWaitingTimeChanged();
4103	partial void OnTransferTimeChanging(long value);
4104	partial void OnTransferTimeChanged();
4105	partial void OnNumCalculationRunsChanging(int value);
4106	partial void OnNumCalculationRunsChanged();
4107	partial void OnNumRetriesChanging(int value);
4108	partial void OnNumRetriesChanged();
4109	partial void OnCoresRequiredChanging(int value);
4110	partial void OnCoresRequiredChanged();
4111	partial void OnMemoryRequiredChanging(int value);
4112	partial void OnMemoryRequiredChanged();
4113	partial void OnPriorityChanging(int value);
4114	partial void OnPriorityChanged();
4115	partial void OnLastClientIdChanging(System.Nullable<System.Guid> value);
4116	partial void OnLastClientIdChanged();
4117	partial void OnJobIdChanging(System.Guid value);
4118	partial void OnJobIdChanged();
4119	partial void OnEndTimeChanging(System.Nullable<System.DateTime> value);
4120	partial void OnEndTimeChanged();
4121	partial void OnTaskStateChanging(global::HeuristicLab.Services.Hive.DataAccess.TaskState value);
4122	partial void OnTaskStateChanged();
4123	partial void OnExceptionChanging(string value);
4124	partial void OnExceptionChanged();
4125	partial void OnInitialWaitingTimeChanging(long value);
4126	partial void OnInitialWaitingTimeChanged();
4127	partial void OnStartTimeChanging(System.Nullable<System.DateTime> value);
4128	partial void OnStartTimeChanged();
4129	#endregion
4130
4131	public FactTask()
4132	{
4133	this._DimClient = default(EntityRef<DimClient>);
4134	this._DimJob = default(EntityRef<DimJob>);
4135	OnCreated();
4136	}
4137
4138	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TaskId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
4139	public System.Guid TaskId
4140	{
4141	get
4142	{
4143	return this._TaskId;
4144	}
4145	set
4146	{
4147	if ((this._TaskId != value))
4148	{
4149	this.OnTaskIdChanging(value);
4150	this.SendPropertyChanging();
4151	this._TaskId = value;
4152	this.SendPropertyChanged("TaskId");
4153	this.OnTaskIdChanged();
4154	}
4155	}
4156	}
4157
4158	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalRuntime", DbType="INT NOT NULL")]
4159	public long CalculatingTime
4160	{
4161	get
4162	{
4163	return this._TotalRuntime;
4164	}
4165	set
4166	{
4167	if ((this._TotalRuntime != value))
4168	{
4169	this.OnCalculatingTimeChanging(value);
4170	this.SendPropertyChanging();
4171	this._TotalRuntime = value;
4172	this.SendPropertyChanged("CalculatingTime");
4173	this.OnCalculatingTimeChanged();
4174	}
4175	}
4176	}
4177
4178	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalWaitingTime", DbType="INT NOT NULL")]
4179	public long WaitingTime
4180	{
4181	get
4182	{
4183	return this._TotalWaitingTime;
4184	}
4185	set
4186	{
4187	if ((this._TotalWaitingTime != value))
4188	{
4189	this.OnWaitingTimeChanging(value);
4190	this.SendPropertyChanging();
4191	this._TotalWaitingTime = value;
4192	this.SendPropertyChanged("WaitingTime");
4193	this.OnWaitingTimeChanged();
4194	}
4195	}
4196	}
4197
4198	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTransferTime", DbType="INT NOT NULL")]
4199	public long TransferTime
4200	{
4201	get
4202	{
4203	return this._TotalTransferTime;
4204	}
4205	set
4206	{
4207	if ((this._TotalTransferTime != value))
4208	{
4209	this.OnTransferTimeChanging(value);
4210	this.SendPropertyChanging();
4211	this._TotalTransferTime = value;
4212	this.SendPropertyChanged("TransferTime");
4213	this.OnTransferTimeChanged();
4214	}
4215	}
4216	}
4217
4218	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumCalculationRuns", DbType="Int NOT NULL")]
4219	public int NumCalculationRuns
4220	{
4221	get
4222	{
4223	return this._NumCalculationRuns;
4224	}
4225	set
4226	{
4227	if ((this._NumCalculationRuns != value))
4228	{
4229	this.OnNumCalculationRunsChanging(value);
4230	this.SendPropertyChanging();
4231	this._NumCalculationRuns = value;
4232	this.SendPropertyChanged("NumCalculationRuns");
4233	this.OnNumCalculationRunsChanged();
4234	}
4235	}
4236	}
4237
4238	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumFails", DbType="Int NOT NULL")]
4239	public int NumRetries
4240	{
4241	get
4242	{
4243	return this._NumFails;
4244	}
4245	set
4246	{
4247	if ((this._NumFails != value))
4248	{
4249	this.OnNumRetriesChanging(value);
4250	this.SendPropertyChanging();
4251	this._NumFails = value;
4252	this.SendPropertyChanged("NumRetries");
4253	this.OnNumRetriesChanged();
4254	}
4255	}
4256	}
4257
4258	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CoresRequired", DbType="Int NOT NULL")]
4259	public int CoresRequired
4260	{
4261	get
4262	{
4263	return this._CoresRequired;
4264	}
4265	set
4266	{
4267	if ((this._CoresRequired != value))
4268	{
4269	this.OnCoresRequiredChanging(value);
4270	this.SendPropertyChanging();
4271	this._CoresRequired = value;
4272	this.SendPropertyChanged("CoresRequired");
4273	this.OnCoresRequiredChanged();
4274	}
4275	}
4276	}
4277
4278	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_MemoryRequired", DbType="Int NOT NULL")]
4279	public int MemoryRequired
4280	{
4281	get
4282	{
4283	return this._MemoryRequired;
4284	}
4285	set
4286	{
4287	if ((this._MemoryRequired != value))
4288	{
4289	this.OnMemoryRequiredChanging(value);
4290	this.SendPropertyChanging();
4291	this._MemoryRequired = value;
4292	this.SendPropertyChanged("MemoryRequired");
4293	this.OnMemoryRequiredChanged();
4294	}
4295	}
4296	}
4297
4298	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Priority", DbType="Int NOT NULL")]
4299	public int Priority
4300	{
4301	get
4302	{
4303	return this._Priority;
4304	}
4305	set
4306	{
4307	if ((this._Priority != value))
4308	{
4309	this.OnPriorityChanging(value);
4310	this.SendPropertyChanging();
4311	this._Priority = value;
4312	this.SendPropertyChanged("Priority");
4313	this.OnPriorityChanged();
4314	}
4315	}
4316	}
4317
4318	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastClientId", DbType="UniqueIdentifier NOT NULL")]
4319	public System.Nullable<System.Guid> LastClientId
4320	{
4321	get
4322	{
4323	return this._LastClientId;
4324	}
4325	set
4326	{
4327	if ((this._LastClientId != value))
4328	{
4329	if (this._DimClient.HasLoadedOrAssignedValue)
4330	{
4331	throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
4332	}
4333	this.OnLastClientIdChanging(value);
4334	this.SendPropertyChanging();
4335	this._LastClientId = value;
4336	this.SendPropertyChanged("LastClientId");
4337	this.OnLastClientIdChanged();
4338	}
4339	}
4340	}
4341
4342	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL")]
4343	public System.Guid JobId
4344	{
4345	get
4346	{
4347	return this._JobId;
4348	}
4349	set
4350	{
4351	if ((this._JobId != value))
4352	{
4353	if (this._DimJob.HasLoadedOrAssignedValue)
4354	{
4355	throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
4356	}
4357	this.OnJobIdChanging(value);
4358	this.SendPropertyChanging();
4359	this._JobId = value;
4360	this.SendPropertyChanged("JobId");
4361	this.OnJobIdChanged();
4362	}
4363	}
4364	}
4365
4366	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_EndTime", DbType="DateTime NOT NULL")]
4367	public System.Nullable<System.DateTime> EndTime
4368	{
4369	get
4370	{
4371	return this._EndTime;
4372	}
4373	set
4374	{
4375	if ((this._EndTime != value))
4376	{
4377	this.OnEndTimeChanging(value);
4378	this.SendPropertyChanging();
4379	this._EndTime = value;
4380	this.SendPropertyChanged("EndTime");
4381	this.OnEndTimeChanged();
4382	}
4383	}
4384	}
4385
4386	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TaskState", DbType="varchar(30)", CanBeNull=false)]
4387	public global::HeuristicLab.Services.Hive.DataAccess.TaskState TaskState
4388	{
4389	get
4390	{
4391	return this._TaskState;
4392	}
4393	set
4394	{
4395	if ((this._TaskState != value))
4396	{
4397	this.OnTaskStateChanging(value);
4398	this.SendPropertyChanging();
4399	this._TaskState = value;
4400	this.SendPropertyChanged("TaskState");
4401	this.OnTaskStateChanged();
4402	}
4403	}
4404	}
4405
4406	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Exception", DbType="varchar(MAX)")]
4407	public string Exception
4408	{
4409	get
4410	{
4411	return this._Exception;
4412	}
4413	set
4414	{
4415	if ((this._Exception != value))
4416	{
4417	this.OnExceptionChanging(value);
4418	this.SendPropertyChanging();
4419	this._Exception = value;
4420	this.SendPropertyChanged("Exception");
4421	this.OnExceptionChanged();
4422	}
4423	}
4424	}
4425
4426	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_InitialWaitingTimeMs", DbType="INT")]
4427	public long InitialWaitingTime
4428	{
4429	get
4430	{
4431	return this._InitialWaitingTimeMs;
4432	}
4433	set
4434	{
4435	if ((this._InitialWaitingTimeMs != value))
4436	{
4437	this.OnInitialWaitingTimeChanging(value);
4438	this.SendPropertyChanging();
4439	this._InitialWaitingTimeMs = value;
4440	this.SendPropertyChanged("InitialWaitingTime");
4441	this.OnInitialWaitingTimeChanged();
4442	}
4443	}
4444	}
4445
4446	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StartTime")]
4447	public System.Nullable<System.DateTime> StartTime
4448	{
4449	get
4450	{
4451	return this._StartTime;
4452	}
4453	set
4454	{
4455	if ((this._StartTime != value))
4456	{
4457	this.OnStartTimeChanging(value);
4458	this.SendPropertyChanging();
4459	this._StartTime = value;
4460	this.SendPropertyChanged("StartTime");
4461	this.OnStartTimeChanged();
4462	}
4463	}
4464	}
4465
4466	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactTask", Storage="_DimClient", ThisKey="LastClientId", OtherKey="Id", IsForeignKey=true)]
4467	public DimClient DimClient
4468	{
4469	get
4470	{
4471	return this._DimClient.Entity;
4472	}
4473	set
4474	{
4475	DimClient previousValue = this._DimClient.Entity;
4476	if (((previousValue != value)
4477	\|\| (this._DimClient.HasLoadedOrAssignedValue == false)))
4478	{
4479	this.SendPropertyChanging();
4480	if ((previousValue != null))
4481	{
4482	this._DimClient.Entity = null;
4483	previousValue.FactTasks.Remove(this);
4484	}
4485	this._DimClient.Entity = value;
4486	if ((value != null))
4487	{
4488	value.FactTasks.Add(this);
4489	this._LastClientId = value.Id;
4490	}
4491	else
4492	{
4493	this._LastClientId = default(Nullable<System.Guid>);
4494	}
4495	this.SendPropertyChanged("DimClient");
4496	}
4497	}
4498	}
4499
4500	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimJob_FactTask", Storage="_DimJob", ThisKey="JobId", OtherKey="JobId", IsForeignKey=true)]
4501	public DimJob DimJob
4502	{
4503	get
4504	{
4505	return this._DimJob.Entity;
4506	}
4507	set
4508	{
4509	DimJob previousValue = this._DimJob.Entity;
4510	if (((previousValue != value)
4511	\|\| (this._DimJob.HasLoadedOrAssignedValue == false)))
4512	{
4513	this.SendPropertyChanging();
4514	if ((previousValue != null))
4515	{
4516	this._DimJob.Entity = null;
4517	previousValue.FactTasks.Remove(this);
4518	}
4519	this._DimJob.Entity = value;
4520	if ((value != null))
4521	{
4522	value.FactTasks.Add(this);
4523	this._JobId = value.JobId;
4524	}
4525	else
4526	{
4527	this._JobId = default(System.Guid);
4528	}
4529	this.SendPropertyChanged("DimJob");
4530	}
4531	}
4532	}
4533
4534	public event PropertyChangingEventHandler PropertyChanging;
4535
4536	public event PropertyChangedEventHandler PropertyChanged;
4537
4538	protected virtual void SendPropertyChanging()
4539	{
4540	if ((this.PropertyChanging != null))
4541	{
4542	this.PropertyChanging(this, emptyChangingEventArgs);
4543	}
4544	}
4545
4546	protected virtual void SendPropertyChanged(String propertyName)
4547	{
4548	if ((this.PropertyChanged != null))
4549	{
4550	this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
4551	}
4552	}
4553	}
4554
4555	[global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimJob")]
4556	public partial class DimJob : INotifyPropertyChanging, INotifyPropertyChanged
4557	{
4558
4559	private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
4560
4561	private System.Guid _JobId;
4562
4563	private System.Guid _UserId;
4564
4565	private string _JobName;
4566
4567	private string _UserName;
4568
4569	private System.DateTime _DateCreated;
4570
4571	private int _TotalTasks;
4572
4573	private int _CompletedTasks;
4574
4575	private System.Nullable<System.DateTime> _DateCompleted;
4576
4577	private EntitySet<FactTask> _FactTasks;
4578
4579	#region Extensibility Method Definitions
4580	partial void OnLoaded();
4581	partial void OnValidate(System.Data.Linq.ChangeAction action);
4582	partial void OnCreated();
4583	partial void OnJobIdChanging(System.Guid value);
4584	partial void OnJobIdChanged();
4585	partial void OnUserIdChanging(System.Guid value);
4586	partial void OnUserIdChanged();
4587	partial void OnJobNameChanging(string value);
4588	partial void OnJobNameChanged();
4589	partial void OnUserNameChanging(string value);
4590	partial void OnUserNameChanged();
4591	partial void OnDateCreatedChanging(System.DateTime value);
4592	partial void OnDateCreatedChanged();
4593	partial void OnTotalTasksChanging(int value);
4594	partial void OnTotalTasksChanged();
4595	partial void OnCompletedTasksChanging(int value);
4596	partial void OnCompletedTasksChanged();
4597	partial void OnDateCompletedChanging(System.Nullable<System.DateTime> value);
4598	partial void OnDateCompletedChanged();
4599	#endregion
4600
4601	public DimJob()
4602	{
4603	this._FactTasks = new EntitySet<FactTask>(new Action<FactTask>(this.attach_FactTasks), new Action<FactTask>(this.detach_FactTasks));
4604	OnCreated();
4605	}
4606
4607	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
4608	public System.Guid JobId
4609	{
4610	get
4611	{
4612	return this._JobId;
4613	}
4614	set
4615	{
4616	if ((this._JobId != value))
4617	{
4618	this.OnJobIdChanging(value);
4619	this.SendPropertyChanging();
4620	this._JobId = value;
4621	this.SendPropertyChanged("JobId");
4622	this.OnJobIdChanged();
4623	}
4624	}
4625	}
4626
4627	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL")]
4628	public System.Guid UserId
4629	{
4630	get
4631	{
4632	return this._UserId;
4633	}
4634	set
4635	{
4636	if ((this._UserId != value))
4637	{
4638	this.OnUserIdChanging(value);
4639	this.SendPropertyChanging();
4640	this._UserId = value;
4641	this.SendPropertyChanged("UserId");
4642	this.OnUserIdChanged();
4643	}
4644	}
4645	}
4646
4647	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobName", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
4648	public string JobName
4649	{
4650	get
4651	{
4652	return this._JobName;
4653	}
4654	set
4655	{
4656	if ((this._JobName != value))
4657	{
4658	this.OnJobNameChanging(value);
4659	this.SendPropertyChanging();
4660	this._JobName = value;
4661	this.SendPropertyChanged("JobName");
4662	this.OnJobNameChanged();
4663	}
4664	}
4665	}
4666
4667	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserName", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
4668	public string UserName
4669	{
4670	get
4671	{
4672	return this._UserName;
4673	}
4674	set
4675	{
4676	if ((this._UserName != value))
4677	{
4678	this.OnUserNameChanging(value);
4679	this.SendPropertyChanging();
4680	this._UserName = value;
4681	this.SendPropertyChanged("UserName");
4682	this.OnUserNameChanged();
4683	}
4684	}
4685	}
4686
4687	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateCreated", DbType="DateTime NOT NULL")]
4688	public System.DateTime DateCreated
4689	{
4690	get
4691	{
4692	return this._DateCreated;
4693	}
4694	set
4695	{
4696	if ((this._DateCreated != value))
4697	{
4698	this.OnDateCreatedChanging(value);
4699	this.SendPropertyChanging();
4700	this._DateCreated = value;
4701	this.SendPropertyChanged("DateCreated");
4702	this.OnDateCreatedChanged();
4703	}
4704	}
4705	}
4706
4707	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTasks", DbType="INT NOT NULL")]
4708	public int TotalTasks
4709	{
4710	get
4711	{
4712	return this._TotalTasks;
4713	}
4714	set
4715	{
4716	if ((this._TotalTasks != value))
4717	{
4718	this.OnTotalTasksChanging(value);
4719	this.SendPropertyChanging();
4720	this._TotalTasks = value;
4721	this.SendPropertyChanged("TotalTasks");
4722	this.OnTotalTasksChanged();
4723	}
4724	}
4725	}
4726
4727	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CompletedTasks", DbType="INT NOT NULL")]
4728	public int CompletedTasks
4729	{
4730	get
4731	{
4732	return this._CompletedTasks;
4733	}
4734	set
4735	{
4736	if ((this._CompletedTasks != value))
4737	{
4738	this.OnCompletedTasksChanging(value);
4739	this.SendPropertyChanging();
4740	this._CompletedTasks = value;
4741	this.SendPropertyChanged("CompletedTasks");
4742	this.OnCompletedTasksChanged();
4743	}
4744	}
4745	}
4746
4747	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateCompleted", DbType="DateTime NULL")]
4748	public System.Nullable<System.DateTime> DateCompleted
4749	{
4750	get
4751	{
4752	return this._DateCompleted;
4753	}
4754	set
4755	{
4756	if ((this._DateCompleted != value))
4757	{
4758	this.OnDateCompletedChanging(value);
4759	this.SendPropertyChanging();
4760	this._DateCompleted = value;
4761	this.SendPropertyChanged("DateCompleted");
4762	this.OnDateCompletedChanged();
4763	}
4764	}
4765	}
4766
4767	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimJob_FactTask", Storage="_FactTasks", ThisKey="JobId", OtherKey="JobId")]
4768	public EntitySet<FactTask> FactTasks
4769	{
4770	get
4771	{
4772	return this._FactTasks;
4773	}
4774	set
4775	{
4776	this._FactTasks.Assign(value);
4777	}
4778	}
4779
4780	public event PropertyChangingEventHandler PropertyChanging;
4781
4782	public event PropertyChangedEventHandler PropertyChanged;
4783
4784	protected virtual void SendPropertyChanging()
4785	{
4786	if ((this.PropertyChanging != null))
4787	{
4788	this.PropertyChanging(this, emptyChangingEventArgs);
4789	}
4790	}
4791
4792	protected virtual void SendPropertyChanged(String propertyName)
4793	{
4794	if ((this.PropertyChanged != null))
4795	{
4796	this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
4797	}
4798	}
4799
4800	private void attach_FactTasks(FactTask entity)
4801	{
4802	this.SendPropertyChanging();
4803	entity.DimJob = this;
4804	}
4805
4806	private void detach_FactTasks(FactTask entity)
4807	{
4808	this.SendPropertyChanging();
4809	entity.DimJob = null;
4810	}
4811	}
4812
4813	[global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimTime")]
4814	public partial class DimTime : INotifyPropertyChanging, INotifyPropertyChanged
4815	{
4816
4817	private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
4818
4819	private System.DateTime _Time;
4820
4821	private System.DateTime _Hour;
4822
4823	private System.DateTime _Day;
4824
4825	private System.DateTime _Month;
4826
4827	private System.DateTime _Year;
4828
4829	private System.DateTime _Minute;
4830
4831	private EntitySet<FactClientInfo> _FactClientInfos;
4832
4833	#region Extensibility Method Definitions
4834	partial void OnLoaded();
4835	partial void OnValidate(System.Data.Linq.ChangeAction action);
4836	partial void OnCreated();
4837	partial void OnTimeChanging(System.DateTime value);
4838	partial void OnTimeChanged();
4839	partial void OnHourChanging(System.DateTime value);
4840	partial void OnHourChanged();
4841	partial void OnDayChanging(System.DateTime value);
4842	partial void OnDayChanged();
4843	partial void OnMonthChanging(System.DateTime value);
4844	partial void OnMonthChanged();
4845	partial void OnYearChanging(System.DateTime value);
4846	partial void OnYearChanged();
4847	partial void OnMinuteChanging(System.DateTime value);
4848	partial void OnMinuteChanged();
4849	#endregion
4850
4851	public DimTime()
4852	{
4853	this._FactClientInfos = new EntitySet<FactClientInfo>(new Action<FactClientInfo>(this.attach_FactClientInfos), new Action<FactClientInfo>(this.detach_FactClientInfos));
4854	OnCreated();
4855	}
4856
4857	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Time", DbType="DateTime NOT NULL", IsPrimaryKey=true)]
4858	public System.DateTime Time
4859	{
4860	get
4861	{
4862	return this._Time;
4863	}
4864	set
4865	{
4866	if ((this._Time != value))
4867	{
4868	this.OnTimeChanging(value);
4869	this.SendPropertyChanging();
4870	this._Time = value;
4871	this.SendPropertyChanged("Time");
4872	this.OnTimeChanged();
4873	}
4874	}
4875	}
4876
4877	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Hour", DbType="DateTime NOT NULL")]
4878	public System.DateTime Hour
4879	{
4880	get
4881	{
4882	return this._Hour;
4883	}
4884	set
4885	{
4886	if ((this._Hour != value))
4887	{
4888	this.OnHourChanging(value);
4889	this.SendPropertyChanging();
4890	this._Hour = value;
4891	this.SendPropertyChanged("Hour");
4892	this.OnHourChanged();
4893	}
4894	}
4895	}
4896
4897	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Day", DbType="Date NOT NULL")]
4898	public System.DateTime Day
4899	{
4900	get
4901	{
4902	return this._Day;
4903	}
4904	set
4905	{
4906	if ((this._Day != value))
4907	{
4908	this.OnDayChanging(value);
4909	this.SendPropertyChanging();
4910	this._Day = value;
4911	this.SendPropertyChanged("Day");
4912	this.OnDayChanged();
4913	}
4914	}
4915	}
4916
4917	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Month", DbType="Date NOT NULL")]
4918	public System.DateTime Month
4919	{
4920	get
4921	{
4922	return this._Month;
4923	}
4924	set
4925	{
4926	if ((this._Month != value))
4927	{
4928	this.OnMonthChanging(value);
4929	this.SendPropertyChanging();
4930	this._Month = value;
4931	this.SendPropertyChanged("Month");
4932	this.OnMonthChanged();
4933	}
4934	}
4935	}
4936
4937	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Year", DbType="Date NOT NULL")]
4938	public System.DateTime Year
4939	{
4940	get
4941	{
4942	return this._Year;
4943	}
4944	set
4945	{
4946	if ((this._Year != value))
4947	{
4948	this.OnYearChanging(value);
4949	this.SendPropertyChanging();
4950	this._Year = value;
4951	this.SendPropertyChanged("Year");
4952	this.OnYearChanged();
4953	}
4954	}
4955	}
4956
4957	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Minute")]
4958	public System.DateTime Minute
4959	{
4960	get
4961	{
4962	return this._Minute;
4963	}
4964	set
4965	{
4966	if ((this._Minute != value))
4967	{
4968	this.OnMinuteChanging(value);
4969	this.SendPropertyChanging();
4970	this._Minute = value;
4971	this.SendPropertyChanged("Minute");
4972	this.OnMinuteChanged();
4973	}
4974	}
4975	}
4976
4977	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimTime_FactClientInfo", Storage="_FactClientInfos", ThisKey="Time", OtherKey="Time")]
4978	public EntitySet<FactClientInfo> FactClientInfos
4979	{
4980	get
4981	{
4982	return this._FactClientInfos;
4983	}
4984	set
4985	{
4986	this._FactClientInfos.Assign(value);
4987	}
4988	}
4989
4990	public event PropertyChangingEventHandler PropertyChanging;
4991
4992	public event PropertyChangedEventHandler PropertyChanged;
4993
4994	protected virtual void SendPropertyChanging()
4995	{
4996	if ((this.PropertyChanging != null))
4997	{
4998	this.PropertyChanging(this, emptyChangingEventArgs);
4999	}
5000	}
5001
5002	protected virtual void SendPropertyChanged(String propertyName)
5003	{
5004	if ((this.PropertyChanged != null))
5005	{
5006	this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
5007	}
5008	}
5009
5010	private void attach_FactClientInfos(FactClientInfo entity)
5011	{
5012	this.SendPropertyChanging();
5013	entity.DimTime = this;
5014	}
5015
5016	private void detach_FactClientInfos(FactClientInfo entity)
5017	{
5018	this.SendPropertyChanging();
5019	entity.DimTime = null;
5020	}
5021	}
5022
5023	[global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimUser")]
5024	public partial class DimUser : INotifyPropertyChanging, INotifyPropertyChanged
5025	{
5026
5027	private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
5028
5029	private System.Guid _UserId;
5030
5031	private string _Name;
5032
5033	private EntitySet<FactClientInfo> _FactClientInfos;
5034
5035	#region Extensibility Method Definitions
5036	partial void OnLoaded();
5037	partial void OnValidate(System.Data.Linq.ChangeAction action);
5038	partial void OnCreated();
5039	partial void OnUserIdChanging(System.Guid value);
5040	partial void OnUserIdChanged();
5041	partial void OnNameChanging(string value);
5042	partial void OnNameChanged();
5043	#endregion
5044
5045	public DimUser()
5046	{
5047	this._FactClientInfos = new EntitySet<FactClientInfo>(new Action<FactClientInfo>(this.attach_FactClientInfos), new Action<FactClientInfo>(this.detach_FactClientInfos));
5048	OnCreated();
5049	}
5050
5051	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
5052	public System.Guid UserId
5053	{
5054	get
5055	{
5056	return this._UserId;
5057	}
5058	set
5059	{
5060	if ((this._UserId != value))
5061	{
5062	this.OnUserIdChanging(value);
5063	this.SendPropertyChanging();
5064	this._UserId = value;
5065	this.SendPropertyChanged("UserId");
5066	this.OnUserIdChanged();
5067	}
5068	}
5069	}
5070
5071	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
5072	public string Name
5073	{
5074	get
5075	{
5076	return this._Name;
5077	}
5078	set
5079	{
5080	if ((this._Name != value))
5081	{
5082	this.OnNameChanging(value);
5083	this.SendPropertyChanging();
5084	this._Name = value;
5085	this.SendPropertyChanged("Name");
5086	this.OnNameChanged();
5087	}
5088	}
5089	}
5090
5091	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimUser_FactClientInfo", Storage="_FactClientInfos", ThisKey="UserId", OtherKey="UserId")]
5092	public EntitySet<FactClientInfo> FactClientInfos
5093	{
5094	get
5095	{
5096	return this._FactClientInfos;
5097	}
5098	set
5099	{
5100	this._FactClientInfos.Assign(value);
5101	}
5102	}
5103
5104	public event PropertyChangingEventHandler PropertyChanging;
5105
5106	public event PropertyChangedEventHandler PropertyChanged;
5107
5108	protected virtual void SendPropertyChanging()
5109	{
5110	if ((this.PropertyChanging != null))
5111	{
5112	this.PropertyChanging(this, emptyChangingEventArgs);
5113	}
5114	}
5115
5116	protected virtual void SendPropertyChanged(String propertyName)
5117	{
5118	if ((this.PropertyChanged != null))
5119	{
5120	this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
5121	}
5122	}
5123
5124	private void attach_FactClientInfos(FactClientInfo entity)
5125	{
5126	this.SendPropertyChanging();
5127	entity.DimUser = this;
5128	}
5129
5130	private void detach_FactClientInfos(FactClientInfo entity)
5131	{
5132	this.SendPropertyChanging();
5133	entity.DimUser = null;
5134	}
5135	}
5136
5137	[global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].FactClientInfo")]
5138	public partial class FactClientInfo : INotifyPropertyChanging, INotifyPropertyChanged
5139	{
5140
5141	private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
5142
5143	private System.Guid _ClientId;
5144
5145	private System.DateTime _Time;
5146
5147	private System.Guid _UserId;
5148
5149	private int _NumUsedCores;
5150
5151	private int _NumTotalCores;
5152
5153	private int _UsedMemory;
5154
5155	private int _TotalMemory;
5156
5157	private double _CpuUtilization;
5158
5159	private long _TotalTimeIdle;
5160
5161	private long _TotalTimeOffline;
5162
5163	private long _TotalTimeUnavailable;
5164
5165	private global::HeuristicLab.Services.Hive.DataAccess.SlaveState _SlaveState;
5166
5167	private bool _IsAllowedToCalculate;
5168
5169	private EntityRef<DimClient> _DimClient;
5170
5171	private EntityRef<DimTime> _DimTime;
5172
5173	private EntityRef<DimUser> _DimUser;
5174
5175	#region Extensibility Method Definitions
5176	partial void OnLoaded();
5177	partial void OnValidate(System.Data.Linq.ChangeAction action);
5178	partial void OnCreated();
5179	partial void OnClientIdChanging(System.Guid value);
5180	partial void OnClientIdChanged();
5181	partial void OnTimeChanging(System.DateTime value);
5182	partial void OnTimeChanged();
5183	partial void OnUserIdChanging(System.Guid value);
5184	partial void OnUserIdChanged();
5185	partial void OnNumUsedCoresChanging(int value);
5186	partial void OnNumUsedCoresChanged();
5187	partial void OnNumTotalCoresChanging(int value);
5188	partial void OnNumTotalCoresChanged();
5189	partial void OnUsedMemoryChanging(int value);
5190	partial void OnUsedMemoryChanged();
5191	partial void OnTotalMemoryChanging(int value);
5192	partial void OnTotalMemoryChanged();
5193	partial void OnCpuUtilizationChanging(double value);
5194	partial void OnCpuUtilizationChanged();
5195	partial void OnIdleTimeChanging(long value);
5196	partial void OnIdleTimeChanged();
5197	partial void OnOfflineTimeChanging(long value);
5198	partial void OnOfflineTimeChanged();
5199	partial void OnUnavailableTimeChanging(long value);
5200	partial void OnUnavailableTimeChanged();
5201	partial void OnSlaveStateChanging(global::HeuristicLab.Services.Hive.DataAccess.SlaveState value);
5202	partial void OnSlaveStateChanged();
5203	partial void OnIsAllowedToCalculateChanging(bool value);
5204	partial void OnIsAllowedToCalculateChanged();
5205	#endregion
5206
5207	public FactClientInfo()
5208	{
5209	this._DimClient = default(EntityRef<DimClient>);
5210	this._DimTime = default(EntityRef<DimTime>);
5211	this._DimUser = default(EntityRef<DimUser>);
5212	OnCreated();
5213	}
5214
5215	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ClientId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
5216	public System.Guid ClientId
5217	{
5218	get
5219	{
5220	return this._ClientId;
5221	}
5222	set
5223	{
5224	if ((this._ClientId != value))
5225	{
5226	if (this._DimClient.HasLoadedOrAssignedValue)
5227	{
5228	throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
5229	}
5230	this.OnClientIdChanging(value);
5231	this.SendPropertyChanging();
5232	this._ClientId = value;
5233	this.SendPropertyChanged("ClientId");
5234	this.OnClientIdChanged();
5235	}
5236	}
5237	}
5238
5239	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Time", DbType="DateTime NOT NULL", IsPrimaryKey=true)]
5240	public System.DateTime Time
5241	{
5242	get
5243	{
5244	return this._Time;
5245	}
5246	set
5247	{
5248	if ((this._Time != value))
5249	{
5250	if (this._DimTime.HasLoadedOrAssignedValue)
5251	{
5252	throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
5253	}
5254	this.OnTimeChanging(value);
5255	this.SendPropertyChanging();
5256	this._Time = value;
5257	this.SendPropertyChanged("Time");
5258	this.OnTimeChanged();
5259	}
5260	}
5261	}
5262
5263	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NULL", IsPrimaryKey=true)]
5264	public System.Guid UserId
5265	{
5266	get
5267	{
5268	return this._UserId;
5269	}
5270	set
5271	{
5272	if ((this._UserId != value))
5273	{
5274	if (this._DimUser.HasLoadedOrAssignedValue)
5275	{
5276	throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
5277	}
5278	this.OnUserIdChanging(value);
5279	this.SendPropertyChanging();
5280	this._UserId = value;
5281	this.SendPropertyChanged("UserId");
5282	this.OnUserIdChanged();
5283	}
5284	}
5285	}
5286
5287	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumUsedCores", DbType="Int NOT NULL")]
5288	public int NumUsedCores
5289	{
5290	get
5291	{
5292	return this._NumUsedCores;
5293	}
5294	set
5295	{
5296	if ((this._NumUsedCores != value))
5297	{
5298	this.OnNumUsedCoresChanging(value);
5299	this.SendPropertyChanging();
5300	this._NumUsedCores = value;
5301	this.SendPropertyChanged("NumUsedCores");
5302	this.OnNumUsedCoresChanged();
5303	}
5304	}
5305	}
5306
5307	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumTotalCores", DbType="Int NOT NULL")]
5308	public int NumTotalCores
5309	{
5310	get
5311	{
5312	return this._NumTotalCores;
5313	}
5314	set
5315	{
5316	if ((this._NumTotalCores != value))
5317	{
5318	this.OnNumTotalCoresChanging(value);
5319	this.SendPropertyChanging();
5320	this._NumTotalCores = value;
5321	this.SendPropertyChanged("NumTotalCores");
5322	this.OnNumTotalCoresChanged();
5323	}
5324	}
5325	}
5326
5327	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UsedMemory", DbType="Int NOT NULL")]
5328	public int UsedMemory
5329	{
5330	get
5331	{
5332	return this._UsedMemory;
5333	}
5334	set
5335	{
5336	if ((this._UsedMemory != value))
5337	{
5338	this.OnUsedMemoryChanging(value);
5339	this.SendPropertyChanging();
5340	this._UsedMemory = value;
5341	this.SendPropertyChanged("UsedMemory");
5342	this.OnUsedMemoryChanged();
5343	}
5344	}
5345	}
5346
5347	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalMemory", DbType="Int NOT NULL")]
5348	public int TotalMemory
5349	{
5350	get
5351	{
5352	return this._TotalMemory;
5353	}
5354	set
5355	{
5356	if ((this._TotalMemory != value))
5357	{
5358	this.OnTotalMemoryChanging(value);
5359	this.SendPropertyChanging();
5360	this._TotalMemory = value;
5361	this.SendPropertyChanged("TotalMemory");
5362	this.OnTotalMemoryChanged();
5363	}
5364	}
5365	}
5366
5367	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CpuUtilization", DbType="Float NOT NULL")]
5368	public double CpuUtilization
5369	{
5370	get
5371	{
5372	return this._CpuUtilization;
5373	}
5374	set
5375	{
5376	if ((this._CpuUtilization != value))
5377	{
5378	this.OnCpuUtilizationChanging(value);
5379	this.SendPropertyChanging();
5380	this._CpuUtilization = value;
5381	this.SendPropertyChanged("CpuUtilization");
5382	this.OnCpuUtilizationChanged();
5383	}
5384	}
5385	}
5386
5387	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTimeIdle", DbType="INT NOT NULL")]
5388	public long IdleTime
5389	{
5390	get
5391	{
5392	return this._TotalTimeIdle;
5393	}
5394	set
5395	{
5396	if ((this._TotalTimeIdle != value))
5397	{
5398	this.OnIdleTimeChanging(value);
5399	this.SendPropertyChanging();
5400	this._TotalTimeIdle = value;
5401	this.SendPropertyChanged("IdleTime");
5402	this.OnIdleTimeChanged();
5403	}
5404	}
5405	}
5406
5407	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTimeOffline", DbType="INT NOT NULL")]
5408	public long OfflineTime
5409	{
5410	get
5411	{
5412	return this._TotalTimeOffline;
5413	}
5414	set
5415	{
5416	if ((this._TotalTimeOffline != value))
5417	{
5418	this.OnOfflineTimeChanging(value);
5419	this.SendPropertyChanging();
5420	this._TotalTimeOffline = value;
5421	this.SendPropertyChanged("OfflineTime");
5422	this.OnOfflineTimeChanged();
5423	}
5424	}
5425	}
5426
5427	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTimeUnavailable", DbType="INT NOT NULL")]
5428	public long UnavailableTime
5429	{
5430	get
5431	{
5432	return this._TotalTimeUnavailable;
5433	}
5434	set
5435	{
5436	if ((this._TotalTimeUnavailable != value))
5437	{
5438	this.OnUnavailableTimeChanging(value);
5439	this.SendPropertyChanging();
5440	this._TotalTimeUnavailable = value;
5441	this.SendPropertyChanged("UnavailableTime");
5442	this.OnUnavailableTimeChanged();
5443	}
5444	}
5445	}
5446
5447	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_SlaveState", DbType="VarChar(15)", CanBeNull=false)]
5448	public global::HeuristicLab.Services.Hive.DataAccess.SlaveState SlaveState
5449	{
5450	get
5451	{
5452	return this._SlaveState;
5453	}
5454	set
5455	{
5456	if ((this._SlaveState != value))
5457	{
5458	this.OnSlaveStateChanging(value);
5459	this.SendPropertyChanging();
5460	this._SlaveState = value;
5461	this.SendPropertyChanged("SlaveState");
5462	this.OnSlaveStateChanged();
5463	}
5464	}
5465	}
5466
5467	[global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsAllowedToCalculate", DbType="BIT")]
5468	public bool IsAllowedToCalculate
5469	{
5470	get
5471	{
5472	return this._IsAllowedToCalculate;
5473	}
5474	set
5475	{
5476	if ((this._IsAllowedToCalculate != value))
5477	{
5478	this.OnIsAllowedToCalculateChanging(value);
5479	this.SendPropertyChanging();
5480	this._IsAllowedToCalculate = value;
5481	this.SendPropertyChanged("IsAllowedToCalculate");
5482	this.OnIsAllowedToCalculateChanged();
5483	}
5484	}
5485	}
5486
5487	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactClientInfo", Storage="_DimClient", ThisKey="ClientId", OtherKey="Id", IsForeignKey=true)]
5488	public DimClient DimClient
5489	{
5490	get
5491	{
5492	return this._DimClient.Entity;
5493	}
5494	set
5495	{
5496	DimClient previousValue = this._DimClient.Entity;
5497	if (((previousValue != value)
5498	\|\| (this._DimClient.HasLoadedOrAssignedValue == false)))
5499	{
5500	this.SendPropertyChanging();
5501	if ((previousValue != null))
5502	{
5503	this._DimClient.Entity = null;
5504	previousValue.FactClientInfos.Remove(this);
5505	}
5506	this._DimClient.Entity = value;
5507	if ((value != null))
5508	{
5509	value.FactClientInfos.Add(this);
5510	this._ClientId = value.Id;
5511	}
5512	else
5513	{
5514	this._ClientId = default(System.Guid);
5515	}
5516	this.SendPropertyChanged("DimClient");
5517	}
5518	}
5519	}
5520
5521	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimTime_FactClientInfo", Storage="_DimTime", ThisKey="Time", OtherKey="Time", IsForeignKey=true)]
5522	public DimTime DimTime
5523	{
5524	get
5525	{
5526	return this._DimTime.Entity;
5527	}
5528	set
5529	{
5530	DimTime previousValue = this._DimTime.Entity;
5531	if (((previousValue != value)
5532	\|\| (this._DimTime.HasLoadedOrAssignedValue == false)))
5533	{
5534	this.SendPropertyChanging();
5535	if ((previousValue != null))
5536	{
5537	this._DimTime.Entity = null;
5538	previousValue.FactClientInfos.Remove(this);
5539	}
5540	this._DimTime.Entity = value;
5541	if ((value != null))
5542	{
5543	value.FactClientInfos.Add(this);
5544	this._Time = value.Time;
5545	}
5546	else
5547	{
5548	this._Time = default(System.DateTime);
5549	}
5550	this.SendPropertyChanged("DimTime");
5551	}
5552	}
5553	}
5554
5555	[global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimUser_FactClientInfo", Storage="_DimUser", ThisKey="UserId", OtherKey="UserId", IsForeignKey=true)]
5556	public DimUser DimUser
5557	{
5558	get
5559	{
5560	return this._DimUser.Entity;
5561	}
5562	set
5563	{
5564	DimUser previousValue = this._DimUser.Entity;
5565	if (((previousValue != value)
5566	\|\| (this._DimUser.HasLoadedOrAssignedValue == false)))
5567	{
5568	this.SendPropertyChanging();
5569	if ((previousValue != null))
5570	{
5571	this._DimUser.Entity = null;
5572	previousValue.FactClientInfos.Remove(this);
5573	}
5574	this._DimUser.Entity = value;
5575	if ((value != null))
5576	{
5577	value.FactClientInfos.Add(this);
5578	this._UserId = value.UserId;
5579	}
5580	else
5581	{
5582	this._UserId = default(System.Guid);
5583	}
5584	this.SendPropertyChanged("DimUser");
5585	}
5586	}
5587	}
5588
5589	public event PropertyChangingEventHandler PropertyChanging;
5590
5591	public event PropertyChangedEventHandler PropertyChanged;
5592
5593	protected virtual void SendPropertyChanging()
5594	{
5595	if ((this.PropertyChanging != null))
5596	{
5597	this.PropertyChanging(this, emptyChangingEventArgs);
5598	}
5599	}
5600
5601	protected virtual void SendPropertyChanged(String propertyName)
5602	{
5603	if ((this.PropertyChanged != null))
5604	{
5605	this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
5606	}
5607	}
5608	}
5609	}
5610	#pragma warning restore 1591

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

Download in other formats:

Update cookies preferences