Context Navigation

source: branches/HiveTaskScheduler/HeuristicLab.Services.Hive.DataAccess/3.3/HiveDataContext.designer.cs @ 8694

Visit:

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

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

Download in other formats:

Update cookies preferences