Free cookie consent management tool by TermsFeed Policy Generator

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

Last change on this file since 8687 was 8687, checked in by jkarder, 10 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
12namespace 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.