Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.Services.Hive.DataAccess/3.3/HiveDataContext.designer.cs @ 8957

Last change on this file since 8957 was 8957, checked in by ascheibe, 11 years ago

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