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

Last change on this file since 13321 was 12963, checked in by ascheibe, 7 years ago

#2355 merged r12926, r12927 and r12959 into stable

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