source: branches/HiveStatistics/sources/HeuristicLab.Services.Hive.DataAccess/3.3/HiveDataContext.designer.cs @ 12768

Last change on this file since 12768 was 12768, checked in by dglaser, 6 years ago

#2388:

HeuristicLab.Services.Hive.DataAccess-3.3:

  • Removed old statistics tables
  • Updated SQL Scripts

HeuristicLab.Services.WebApp-3.3:
HeuristicLab.Services.WebApp.Status-3.3:
HeuristicLab.Services.WebApp.Statistics-3.3:

  • Minor changes
File size: 146.5 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-3.3")]
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 bool _IsPrivileged;
1623   
1624    private EntitySet<AssignedResource> _AssignedResources;
1625   
1626    private EntitySet<RequiredPlugin> _RequiredPlugins;
1627   
1628    private EntitySet<Task> _Jobs;
1629   
1630    private EntityRef<TaskData> _JobData;
1631   
1632    private EntitySet<StateLog> _StateLogs;
1633   
1634    private EntityRef<Task> _Job1;
1635   
1636    private EntityRef<Job> _HiveExperiment;
1637   
1638    #region Extensibility Method Definitions
1639    partial void OnLoaded();
1640    partial void OnValidate(System.Data.Linq.ChangeAction action);
1641    partial void OnCreated();
1642    partial void OnTaskIdChanging(System.Guid value);
1643    partial void OnTaskIdChanged();
1644    partial void OnStateChanging(global::HeuristicLab.Services.Hive.DataAccess.TaskState value);
1645    partial void OnStateChanged();
1646    partial void OnExecutionTimeMsChanging(double value);
1647    partial void OnExecutionTimeMsChanged();
1648    partial void OnLastHeartbeatChanging(System.Nullable<System.DateTime> value);
1649    partial void OnLastHeartbeatChanged();
1650    partial void OnParentTaskIdChanging(System.Nullable<System.Guid> value);
1651    partial void OnParentTaskIdChanged();
1652    partial void OnPriorityChanging(int value);
1653    partial void OnPriorityChanged();
1654    partial void OnCoresNeededChanging(int value);
1655    partial void OnCoresNeededChanged();
1656    partial void OnMemoryNeededChanging(int value);
1657    partial void OnMemoryNeededChanged();
1658    partial void OnIsParentTaskChanging(bool value);
1659    partial void OnIsParentTaskChanged();
1660    partial void OnFinishWhenChildJobsFinishedChanging(bool value);
1661    partial void OnFinishWhenChildJobsFinishedChanged();
1662    partial void OnCommandChanging(global::HeuristicLab.Services.Hive.DataAccess.Command? value);
1663    partial void OnCommandChanged();
1664    partial void OnJobIdChanging(System.Guid value);
1665    partial void OnJobIdChanged();
1666    partial void OnIsPrivilegedChanging(bool value);
1667    partial void OnIsPrivilegedChanged();
1668    #endregion
1669   
1670    public Task()
1671    {
1672      this._AssignedResources = new EntitySet<AssignedResource>(new Action<AssignedResource>(this.attach_AssignedResources), new Action<AssignedResource>(this.detach_AssignedResources));
1673      this._RequiredPlugins = new EntitySet<RequiredPlugin>(new Action<RequiredPlugin>(this.attach_RequiredPlugins), new Action<RequiredPlugin>(this.detach_RequiredPlugins));
1674      this._Jobs = new EntitySet<Task>(new Action<Task>(this.attach_Jobs), new Action<Task>(this.detach_Jobs));
1675      this._JobData = default(EntityRef<TaskData>);
1676      this._StateLogs = new EntitySet<StateLog>(new Action<StateLog>(this.attach_StateLogs), new Action<StateLog>(this.detach_StateLogs));
1677      this._Job1 = default(EntityRef<Task>);
1678      this._HiveExperiment = default(EntityRef<Job>);
1679      OnCreated();
1680    }
1681   
1682    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
1683    public System.Guid TaskId
1684    {
1685      get
1686      {
1687        return this._JobId;
1688      }
1689      set
1690      {
1691        if ((this._JobId != value))
1692        {
1693          this.OnTaskIdChanging(value);
1694          this.SendPropertyChanging();
1695          this._JobId = value;
1696          this.SendPropertyChanged("TaskId");
1697          this.OnTaskIdChanged();
1698        }
1699      }
1700    }
1701   
1702    [global::System.Data.Linq.Mapping.ColumnAttribute(Name="TaskState", Storage="_State", DbType="VarChar(30)", CanBeNull=false)]
1703    public global::HeuristicLab.Services.Hive.DataAccess.TaskState State
1704    {
1705      get
1706      {
1707        return this._State;
1708      }
1709      set
1710      {
1711        if ((this._State != value))
1712        {
1713          this.OnStateChanging(value);
1714          this.SendPropertyChanging();
1715          this._State = value;
1716          this.SendPropertyChanged("State");
1717          this.OnStateChanged();
1718        }
1719      }
1720    }
1721   
1722    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ExecutionTime", DbType="float")]
1723    public double ExecutionTimeMs
1724    {
1725      get
1726      {
1727        return this._ExecutionTime;
1728      }
1729      set
1730      {
1731        if ((this._ExecutionTime != value))
1732        {
1733          this.OnExecutionTimeMsChanging(value);
1734          this.SendPropertyChanging();
1735          this._ExecutionTime = value;
1736          this.SendPropertyChanged("ExecutionTimeMs");
1737          this.OnExecutionTimeMsChanged();
1738        }
1739      }
1740    }
1741   
1742    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastHeartbeat", DbType="DateTime")]
1743    public System.Nullable<System.DateTime> LastHeartbeat
1744    {
1745      get
1746      {
1747        return this._LastHeartbeat;
1748      }
1749      set
1750      {
1751        if ((this._LastHeartbeat != value))
1752        {
1753          this.OnLastHeartbeatChanging(value);
1754          this.SendPropertyChanging();
1755          this._LastHeartbeat = value;
1756          this.SendPropertyChanged("LastHeartbeat");
1757          this.OnLastHeartbeatChanged();
1758        }
1759      }
1760    }
1761   
1762    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ParentJobId", DbType="UniqueIdentifier")]
1763    public System.Nullable<System.Guid> ParentTaskId
1764    {
1765      get
1766      {
1767        return this._ParentJobId;
1768      }
1769      set
1770      {
1771        if ((this._ParentJobId != value))
1772        {
1773          if (this._Job1.HasLoadedOrAssignedValue)
1774          {
1775            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
1776          }
1777          this.OnParentTaskIdChanging(value);
1778          this.SendPropertyChanging();
1779          this._ParentJobId = value;
1780          this.SendPropertyChanged("ParentTaskId");
1781          this.OnParentTaskIdChanged();
1782        }
1783      }
1784    }
1785   
1786    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Priority", DbType="Int NOT NULL")]
1787    public int Priority
1788    {
1789      get
1790      {
1791        return this._Priority;
1792      }
1793      set
1794      {
1795        if ((this._Priority != value))
1796        {
1797          this.OnPriorityChanging(value);
1798          this.SendPropertyChanging();
1799          this._Priority = value;
1800          this.SendPropertyChanged("Priority");
1801          this.OnPriorityChanged();
1802        }
1803      }
1804    }
1805   
1806    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CoresNeeded", DbType="Int NOT NULL")]
1807    public int CoresNeeded
1808    {
1809      get
1810      {
1811        return this._CoresNeeded;
1812      }
1813      set
1814      {
1815        if ((this._CoresNeeded != value))
1816        {
1817          this.OnCoresNeededChanging(value);
1818          this.SendPropertyChanging();
1819          this._CoresNeeded = value;
1820          this.SendPropertyChanged("CoresNeeded");
1821          this.OnCoresNeededChanged();
1822        }
1823      }
1824    }
1825   
1826    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_MemoryNeeded", DbType="Int NOT NULL")]
1827    public int MemoryNeeded
1828    {
1829      get
1830      {
1831        return this._MemoryNeeded;
1832      }
1833      set
1834      {
1835        if ((this._MemoryNeeded != value))
1836        {
1837          this.OnMemoryNeededChanging(value);
1838          this.SendPropertyChanging();
1839          this._MemoryNeeded = value;
1840          this.SendPropertyChanged("MemoryNeeded");
1841          this.OnMemoryNeededChanged();
1842        }
1843      }
1844    }
1845   
1846    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsParentJob", DbType="Bit")]
1847    public bool IsParentTask
1848    {
1849      get
1850      {
1851        return this._IsParentJob;
1852      }
1853      set
1854      {
1855        if ((this._IsParentJob != value))
1856        {
1857          this.OnIsParentTaskChanging(value);
1858          this.SendPropertyChanging();
1859          this._IsParentJob = value;
1860          this.SendPropertyChanged("IsParentTask");
1861          this.OnIsParentTaskChanged();
1862        }
1863      }
1864    }
1865   
1866    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_FinishWhenChildJobsFinished", DbType="Bit")]
1867    public bool FinishWhenChildJobsFinished
1868    {
1869      get
1870      {
1871        return this._FinishWhenChildJobsFinished;
1872      }
1873      set
1874      {
1875        if ((this._FinishWhenChildJobsFinished != value))
1876        {
1877          this.OnFinishWhenChildJobsFinishedChanging(value);
1878          this.SendPropertyChanging();
1879          this._FinishWhenChildJobsFinished = value;
1880          this.SendPropertyChanged("FinishWhenChildJobsFinished");
1881          this.OnFinishWhenChildJobsFinishedChanged();
1882        }
1883      }
1884    }
1885   
1886    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Command", DbType="VarChar(30)", CanBeNull=true)]
1887    public global::HeuristicLab.Services.Hive.DataAccess.Command? Command
1888    {
1889      get
1890      {
1891        return this._Command;
1892      }
1893      set
1894      {
1895        if ((this._Command != value))
1896        {
1897          this.OnCommandChanging(value);
1898          this.SendPropertyChanging();
1899          this._Command = value;
1900          this.SendPropertyChanged("Command");
1901          this.OnCommandChanged();
1902        }
1903      }
1904    }
1905   
1906    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_HiveExperimentId", DbType="UniqueIdentifier NOT NULL")]
1907    public System.Guid JobId
1908    {
1909      get
1910      {
1911        return this._HiveExperimentId;
1912      }
1913      set
1914      {
1915        if ((this._HiveExperimentId != value))
1916        {
1917          if (this._HiveExperiment.HasLoadedOrAssignedValue)
1918          {
1919            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
1920          }
1921          this.OnJobIdChanging(value);
1922          this.SendPropertyChanging();
1923          this._HiveExperimentId = value;
1924          this.SendPropertyChanged("JobId");
1925          this.OnJobIdChanged();
1926        }
1927      }
1928    }
1929   
1930    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsPrivileged", DbType="Bit")]
1931    public bool IsPrivileged
1932    {
1933      get
1934      {
1935        return this._IsPrivileged;
1936      }
1937      set
1938      {
1939        if ((this._IsPrivileged != value))
1940        {
1941          this.OnIsPrivilegedChanging(value);
1942          this.SendPropertyChanging();
1943          this._IsPrivileged = value;
1944          this.SendPropertyChanged("IsPrivileged");
1945          this.OnIsPrivilegedChanged();
1946        }
1947      }
1948    }
1949   
1950    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_AssignedResource", Storage="_AssignedResources", ThisKey="TaskId", OtherKey="TaskId")]
1951    public EntitySet<AssignedResource> AssignedResources
1952    {
1953      get
1954      {
1955        return this._AssignedResources;
1956      }
1957      set
1958      {
1959        this._AssignedResources.Assign(value);
1960      }
1961    }
1962   
1963    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_RequiredPlugin", Storage="_RequiredPlugins", ThisKey="TaskId", OtherKey="TaskId")]
1964    public EntitySet<RequiredPlugin> RequiredPlugins
1965    {
1966      get
1967      {
1968        return this._RequiredPlugins;
1969      }
1970      set
1971      {
1972        this._RequiredPlugins.Assign(value);
1973      }
1974    }
1975   
1976    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_Task", Storage="_Jobs", ThisKey="TaskId", OtherKey="ParentTaskId")]
1977    public EntitySet<Task> ChildJobs
1978    {
1979      get
1980      {
1981        return this._Jobs;
1982      }
1983      set
1984      {
1985        this._Jobs.Assign(value);
1986      }
1987    }
1988   
1989    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_TaskData", Storage="_JobData", ThisKey="TaskId", OtherKey="TaskId", IsUnique=true, IsForeignKey=false)]
1990    public TaskData JobData
1991    {
1992      get
1993      {
1994        return this._JobData.Entity;
1995      }
1996      set
1997      {
1998        TaskData previousValue = this._JobData.Entity;
1999        if (((previousValue != value)
2000              || (this._JobData.HasLoadedOrAssignedValue == false)))
2001        {
2002          this.SendPropertyChanging();
2003          if ((previousValue != null))
2004          {
2005            this._JobData.Entity = null;
2006            previousValue.Task = null;
2007          }
2008          this._JobData.Entity = value;
2009          if ((value != null))
2010          {
2011            value.Task = this;
2012          }
2013          this.SendPropertyChanged("JobData");
2014        }
2015      }
2016    }
2017   
2018    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_StateLog", Storage="_StateLogs", ThisKey="TaskId", OtherKey="TaskId")]
2019    public EntitySet<StateLog> StateLogs
2020    {
2021      get
2022      {
2023        return this._StateLogs;
2024      }
2025      set
2026      {
2027        this._StateLogs.Assign(value);
2028      }
2029    }
2030   
2031    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_Task", Storage="_Job1", ThisKey="ParentTaskId", OtherKey="TaskId", IsForeignKey=true)]
2032    public Task ParentJob
2033    {
2034      get
2035      {
2036        return this._Job1.Entity;
2037      }
2038      set
2039      {
2040        Task previousValue = this._Job1.Entity;
2041        if (((previousValue != value)
2042              || (this._Job1.HasLoadedOrAssignedValue == false)))
2043        {
2044          this.SendPropertyChanging();
2045          if ((previousValue != null))
2046          {
2047            this._Job1.Entity = null;
2048            previousValue.ChildJobs.Remove(this);
2049          }
2050          this._Job1.Entity = value;
2051          if ((value != null))
2052          {
2053            value.ChildJobs.Add(this);
2054            this._ParentJobId = value.TaskId;
2055          }
2056          else
2057          {
2058            this._ParentJobId = default(Nullable<System.Guid>);
2059          }
2060          this.SendPropertyChanged("ParentJob");
2061        }
2062      }
2063    }
2064   
2065    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_Task", Storage="_HiveExperiment", ThisKey="JobId", OtherKey="JobId", IsForeignKey=true)]
2066    public Job Job
2067    {
2068      get
2069      {
2070        return this._HiveExperiment.Entity;
2071      }
2072      set
2073      {
2074        Job previousValue = this._HiveExperiment.Entity;
2075        if (((previousValue != value)
2076              || (this._HiveExperiment.HasLoadedOrAssignedValue == false)))
2077        {
2078          this.SendPropertyChanging();
2079          if ((previousValue != null))
2080          {
2081            this._HiveExperiment.Entity = null;
2082            previousValue.Tasks.Remove(this);
2083          }
2084          this._HiveExperiment.Entity = value;
2085          if ((value != null))
2086          {
2087            value.Tasks.Add(this);
2088            this._HiveExperimentId = value.JobId;
2089          }
2090          else
2091          {
2092            this._HiveExperimentId = default(System.Guid);
2093          }
2094          this.SendPropertyChanged("Job");
2095        }
2096      }
2097    }
2098   
2099    public event PropertyChangingEventHandler PropertyChanging;
2100   
2101    public event PropertyChangedEventHandler PropertyChanged;
2102   
2103    protected virtual void SendPropertyChanging()
2104    {
2105      if ((this.PropertyChanging != null))
2106      {
2107        this.PropertyChanging(this, emptyChangingEventArgs);
2108      }
2109    }
2110   
2111    protected virtual void SendPropertyChanged(String propertyName)
2112    {
2113      if ((this.PropertyChanged != null))
2114      {
2115        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2116      }
2117    }
2118   
2119    private void attach_AssignedResources(AssignedResource entity)
2120    {
2121      this.SendPropertyChanging();
2122      entity.Task = this;
2123    }
2124   
2125    private void detach_AssignedResources(AssignedResource entity)
2126    {
2127      this.SendPropertyChanging();
2128      entity.Task = null;
2129    }
2130   
2131    private void attach_RequiredPlugins(RequiredPlugin entity)
2132    {
2133      this.SendPropertyChanging();
2134      entity.Task = this;
2135    }
2136   
2137    private void detach_RequiredPlugins(RequiredPlugin entity)
2138    {
2139      this.SendPropertyChanging();
2140      entity.Task = null;
2141    }
2142   
2143    private void attach_Jobs(Task entity)
2144    {
2145      this.SendPropertyChanging();
2146      entity.ParentJob = this;
2147    }
2148   
2149    private void detach_Jobs(Task entity)
2150    {
2151      this.SendPropertyChanging();
2152      entity.ParentJob = null;
2153    }
2154   
2155    private void attach_StateLogs(StateLog entity)
2156    {
2157      this.SendPropertyChanging();
2158      entity.Task = this;
2159    }
2160   
2161    private void detach_StateLogs(StateLog entity)
2162    {
2163      this.SendPropertyChanging();
2164      entity.Task = null;
2165    }
2166  }
2167 
2168  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Downtime")]
2169  public partial class Downtime : INotifyPropertyChanging, INotifyPropertyChanged
2170  {
2171   
2172    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2173   
2174    private System.Guid _UptimeCalendarId;
2175   
2176    private System.Guid _ResourceId;
2177   
2178    private System.DateTime _StartDate;
2179   
2180    private System.DateTime _EndDate;
2181   
2182    private bool _AllDayEvent;
2183   
2184    private bool _Recurring;
2185   
2186    private System.Guid _RecurringId;
2187   
2188    private global::HeuristicLab.Services.Hive.DataAccess.DowntimeType _Type;
2189   
2190    private EntityRef<Resource> _Resource;
2191   
2192    #region Extensibility Method Definitions
2193    partial void OnLoaded();
2194    partial void OnValidate(System.Data.Linq.ChangeAction action);
2195    partial void OnCreated();
2196    partial void OnDowntimeIdChanging(System.Guid value);
2197    partial void OnDowntimeIdChanged();
2198    partial void OnResourceIdChanging(System.Guid value);
2199    partial void OnResourceIdChanged();
2200    partial void OnStartDateChanging(System.DateTime value);
2201    partial void OnStartDateChanged();
2202    partial void OnEndDateChanging(System.DateTime value);
2203    partial void OnEndDateChanged();
2204    partial void OnAllDayEventChanging(bool value);
2205    partial void OnAllDayEventChanged();
2206    partial void OnRecurringChanging(bool value);
2207    partial void OnRecurringChanged();
2208    partial void OnRecurringIdChanging(System.Guid value);
2209    partial void OnRecurringIdChanged();
2210    partial void OnDowntimeTypeChanging(global::HeuristicLab.Services.Hive.DataAccess.DowntimeType value);
2211    partial void OnDowntimeTypeChanged();
2212    #endregion
2213   
2214    public Downtime()
2215    {
2216      this._Resource = default(EntityRef<Resource>);
2217      OnCreated();
2218    }
2219   
2220    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UptimeCalendarId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier", IsPrimaryKey=true, IsDbGenerated=true)]
2221    public System.Guid DowntimeId
2222    {
2223      get
2224      {
2225        return this._UptimeCalendarId;
2226      }
2227      set
2228      {
2229        if ((this._UptimeCalendarId != value))
2230        {
2231          this.OnDowntimeIdChanging(value);
2232          this.SendPropertyChanging();
2233          this._UptimeCalendarId = value;
2234          this.SendPropertyChanged("DowntimeId");
2235          this.OnDowntimeIdChanged();
2236        }
2237      }
2238    }
2239   
2240    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier")]
2241    public System.Guid ResourceId
2242    {
2243      get
2244      {
2245        return this._ResourceId;
2246      }
2247      set
2248      {
2249        if ((this._ResourceId != value))
2250        {
2251          if (this._Resource.HasLoadedOrAssignedValue)
2252          {
2253            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2254          }
2255          this.OnResourceIdChanging(value);
2256          this.SendPropertyChanging();
2257          this._ResourceId = value;
2258          this.SendPropertyChanged("ResourceId");
2259          this.OnResourceIdChanged();
2260        }
2261      }
2262    }
2263   
2264    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StartDate", DbType="DateTime")]
2265    public System.DateTime StartDate
2266    {
2267      get
2268      {
2269        return this._StartDate;
2270      }
2271      set
2272      {
2273        if ((this._StartDate != value))
2274        {
2275          this.OnStartDateChanging(value);
2276          this.SendPropertyChanging();
2277          this._StartDate = value;
2278          this.SendPropertyChanged("StartDate");
2279          this.OnStartDateChanged();
2280        }
2281      }
2282    }
2283   
2284    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_EndDate", DbType="DateTime")]
2285    public System.DateTime EndDate
2286    {
2287      get
2288      {
2289        return this._EndDate;
2290      }
2291      set
2292      {
2293        if ((this._EndDate != value))
2294        {
2295          this.OnEndDateChanging(value);
2296          this.SendPropertyChanging();
2297          this._EndDate = value;
2298          this.SendPropertyChanged("EndDate");
2299          this.OnEndDateChanged();
2300        }
2301      }
2302    }
2303   
2304    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_AllDayEvent", DbType="Bit")]
2305    public bool AllDayEvent
2306    {
2307      get
2308      {
2309        return this._AllDayEvent;
2310      }
2311      set
2312      {
2313        if ((this._AllDayEvent != value))
2314        {
2315          this.OnAllDayEventChanging(value);
2316          this.SendPropertyChanging();
2317          this._AllDayEvent = value;
2318          this.SendPropertyChanged("AllDayEvent");
2319          this.OnAllDayEventChanged();
2320        }
2321      }
2322    }
2323   
2324    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Recurring", DbType="Bit")]
2325    public bool Recurring
2326    {
2327      get
2328      {
2329        return this._Recurring;
2330      }
2331      set
2332      {
2333        if ((this._Recurring != value))
2334        {
2335          this.OnRecurringChanging(value);
2336          this.SendPropertyChanging();
2337          this._Recurring = value;
2338          this.SendPropertyChanged("Recurring");
2339          this.OnRecurringChanged();
2340        }
2341      }
2342    }
2343   
2344    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_RecurringId", DbType="UniqueIdentifier")]
2345    public System.Guid RecurringId
2346    {
2347      get
2348      {
2349        return this._RecurringId;
2350      }
2351      set
2352      {
2353        if ((this._RecurringId != value))
2354        {
2355          this.OnRecurringIdChanging(value);
2356          this.SendPropertyChanging();
2357          this._RecurringId = value;
2358          this.SendPropertyChanged("RecurringId");
2359          this.OnRecurringIdChanged();
2360        }
2361      }
2362    }
2363   
2364    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Type", DbType="VarChar(MAX)", CanBeNull=false)]
2365    public global::HeuristicLab.Services.Hive.DataAccess.DowntimeType DowntimeType
2366    {
2367      get
2368      {
2369        return this._Type;
2370      }
2371      set
2372      {
2373        if ((this._Type != value))
2374        {
2375          this.OnDowntimeTypeChanging(value);
2376          this.SendPropertyChanging();
2377          this._Type = value;
2378          this.SendPropertyChanged("DowntimeType");
2379          this.OnDowntimeTypeChanged();
2380        }
2381      }
2382    }
2383   
2384    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_Downtime", Storage="_Resource", ThisKey="ResourceId", OtherKey="ResourceId", IsForeignKey=true, DeleteRule="CASCADE")]
2385    public Resource Resource
2386    {
2387      get
2388      {
2389        return this._Resource.Entity;
2390      }
2391      set
2392      {
2393        Resource previousValue = this._Resource.Entity;
2394        if (((previousValue != value)
2395              || (this._Resource.HasLoadedOrAssignedValue == false)))
2396        {
2397          this.SendPropertyChanging();
2398          if ((previousValue != null))
2399          {
2400            this._Resource.Entity = null;
2401            previousValue.Downtimes.Remove(this);
2402          }
2403          this._Resource.Entity = value;
2404          if ((value != null))
2405          {
2406            value.Downtimes.Add(this);
2407            this._ResourceId = value.ResourceId;
2408          }
2409          else
2410          {
2411            this._ResourceId = default(System.Guid);
2412          }
2413          this.SendPropertyChanged("Resource");
2414        }
2415      }
2416    }
2417   
2418    public event PropertyChangingEventHandler PropertyChanging;
2419   
2420    public event PropertyChangedEventHandler PropertyChanged;
2421   
2422    protected virtual void SendPropertyChanging()
2423    {
2424      if ((this.PropertyChanging != null))
2425      {
2426        this.PropertyChanging(this, emptyChangingEventArgs);
2427      }
2428    }
2429   
2430    protected virtual void SendPropertyChanged(String propertyName)
2431    {
2432      if ((this.PropertyChanged != null))
2433      {
2434        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2435      }
2436    }
2437  }
2438 
2439  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Job")]
2440  public partial class Job : INotifyPropertyChanging, INotifyPropertyChanged
2441  {
2442   
2443    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2444   
2445    private System.Guid _HiveExperimentId;
2446   
2447    private string _Name;
2448   
2449    private string _Description;
2450   
2451    private string _ResourceIds;
2452   
2453    private System.Guid _UserId;
2454   
2455    private System.DateTime _DateCreated;
2456   
2457    private EntitySet<Task> _Jobs;
2458   
2459    private EntitySet<JobPermission> _HiveExperimentPermissions;
2460   
2461    #region Extensibility Method Definitions
2462    partial void OnLoaded();
2463    partial void OnValidate(System.Data.Linq.ChangeAction action);
2464    partial void OnCreated();
2465    partial void OnJobIdChanging(System.Guid value);
2466    partial void OnJobIdChanged();
2467    partial void OnNameChanging(string value);
2468    partial void OnNameChanged();
2469    partial void OnDescriptionChanging(string value);
2470    partial void OnDescriptionChanged();
2471    partial void OnResourceIdsChanging(string value);
2472    partial void OnResourceIdsChanged();
2473    partial void OnOwnerUserIdChanging(System.Guid value);
2474    partial void OnOwnerUserIdChanged();
2475    partial void OnDateCreatedChanging(System.DateTime value);
2476    partial void OnDateCreatedChanged();
2477    #endregion
2478   
2479    public Job()
2480    {
2481      this._Jobs = new EntitySet<Task>(new Action<Task>(this.attach_Jobs), new Action<Task>(this.detach_Jobs));
2482      this._HiveExperimentPermissions = new EntitySet<JobPermission>(new Action<JobPermission>(this.attach_HiveExperimentPermissions), new Action<JobPermission>(this.detach_HiveExperimentPermissions));
2483      OnCreated();
2484    }
2485   
2486    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_HiveExperimentId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
2487    public System.Guid JobId
2488    {
2489      get
2490      {
2491        return this._HiveExperimentId;
2492      }
2493      set
2494      {
2495        if ((this._HiveExperimentId != value))
2496        {
2497          this.OnJobIdChanging(value);
2498          this.SendPropertyChanging();
2499          this._HiveExperimentId = value;
2500          this.SendPropertyChanged("JobId");
2501          this.OnJobIdChanged();
2502        }
2503      }
2504    }
2505   
2506    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX)", CanBeNull=false)]
2507    public string Name
2508    {
2509      get
2510      {
2511        return this._Name;
2512      }
2513      set
2514      {
2515        if ((this._Name != value))
2516        {
2517          this.OnNameChanging(value);
2518          this.SendPropertyChanging();
2519          this._Name = value;
2520          this.SendPropertyChanged("Name");
2521          this.OnNameChanged();
2522        }
2523      }
2524    }
2525   
2526    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Description", DbType="VarChar(MAX)")]
2527    public string Description
2528    {
2529      get
2530      {
2531        return this._Description;
2532      }
2533      set
2534      {
2535        if ((this._Description != value))
2536        {
2537          this.OnDescriptionChanging(value);
2538          this.SendPropertyChanging();
2539          this._Description = value;
2540          this.SendPropertyChanged("Description");
2541          this.OnDescriptionChanged();
2542        }
2543      }
2544    }
2545   
2546    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceIds", DbType="VarChar(MAX)")]
2547    public string ResourceIds
2548    {
2549      get
2550      {
2551        return this._ResourceIds;
2552      }
2553      set
2554      {
2555        if ((this._ResourceIds != value))
2556        {
2557          this.OnResourceIdsChanging(value);
2558          this.SendPropertyChanging();
2559          this._ResourceIds = value;
2560          this.SendPropertyChanged("ResourceIds");
2561          this.OnResourceIdsChanged();
2562        }
2563      }
2564    }
2565   
2566    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier")]
2567    public System.Guid OwnerUserId
2568    {
2569      get
2570      {
2571        return this._UserId;
2572      }
2573      set
2574      {
2575        if ((this._UserId != value))
2576        {
2577          this.OnOwnerUserIdChanging(value);
2578          this.SendPropertyChanging();
2579          this._UserId = value;
2580          this.SendPropertyChanged("OwnerUserId");
2581          this.OnOwnerUserIdChanged();
2582        }
2583      }
2584    }
2585   
2586    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateCreated", DbType="DateTime")]
2587    public System.DateTime DateCreated
2588    {
2589      get
2590      {
2591        return this._DateCreated;
2592      }
2593      set
2594      {
2595        if ((this._DateCreated != value))
2596        {
2597          this.OnDateCreatedChanging(value);
2598          this.SendPropertyChanging();
2599          this._DateCreated = value;
2600          this.SendPropertyChanged("DateCreated");
2601          this.OnDateCreatedChanged();
2602        }
2603      }
2604    }
2605   
2606    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_Task", Storage="_Jobs", ThisKey="JobId", OtherKey="JobId")]
2607    public EntitySet<Task> Tasks
2608    {
2609      get
2610      {
2611        return this._Jobs;
2612      }
2613      set
2614      {
2615        this._Jobs.Assign(value);
2616      }
2617    }
2618   
2619    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_JobPermission", Storage="_HiveExperimentPermissions", ThisKey="JobId", OtherKey="JobId")]
2620    public EntitySet<JobPermission> JobPermissions
2621    {
2622      get
2623      {
2624        return this._HiveExperimentPermissions;
2625      }
2626      set
2627      {
2628        this._HiveExperimentPermissions.Assign(value);
2629      }
2630    }
2631   
2632    public event PropertyChangingEventHandler PropertyChanging;
2633   
2634    public event PropertyChangedEventHandler PropertyChanged;
2635   
2636    protected virtual void SendPropertyChanging()
2637    {
2638      if ((this.PropertyChanging != null))
2639      {
2640        this.PropertyChanging(this, emptyChangingEventArgs);
2641      }
2642    }
2643   
2644    protected virtual void SendPropertyChanged(String propertyName)
2645    {
2646      if ((this.PropertyChanged != null))
2647      {
2648        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2649      }
2650    }
2651   
2652    private void attach_Jobs(Task entity)
2653    {
2654      this.SendPropertyChanging();
2655      entity.Job = this;
2656    }
2657   
2658    private void detach_Jobs(Task entity)
2659    {
2660      this.SendPropertyChanging();
2661      entity.Job = null;
2662    }
2663   
2664    private void attach_HiveExperimentPermissions(JobPermission entity)
2665    {
2666      this.SendPropertyChanging();
2667      entity.Job = this;
2668    }
2669   
2670    private void detach_HiveExperimentPermissions(JobPermission entity)
2671    {
2672      this.SendPropertyChanging();
2673      entity.Job = null;
2674    }
2675  }
2676 
2677  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.TaskData")]
2678  public partial class TaskData : INotifyPropertyChanging, INotifyPropertyChanged
2679  {
2680   
2681    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2682   
2683    private System.Guid _JobId;
2684   
2685    private System.Data.Linq.Link<byte[]> _Data;
2686   
2687    private System.DateTime _LastUpdate;
2688   
2689    private EntityRef<Task> _Job;
2690   
2691    #region Extensibility Method Definitions
2692    partial void OnLoaded();
2693    partial void OnValidate(System.Data.Linq.ChangeAction action);
2694    partial void OnCreated();
2695    partial void OnTaskIdChanging(System.Guid value);
2696    partial void OnTaskIdChanged();
2697    partial void OnDataChanging(byte[] value);
2698    partial void OnDataChanged();
2699    partial void OnLastUpdateChanging(System.DateTime value);
2700    partial void OnLastUpdateChanged();
2701    #endregion
2702   
2703    public TaskData()
2704    {
2705      this._Job = default(EntityRef<Task>);
2706      OnCreated();
2707    }
2708   
2709    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
2710    public System.Guid TaskId
2711    {
2712      get
2713      {
2714        return this._JobId;
2715      }
2716      set
2717      {
2718        if ((this._JobId != value))
2719        {
2720          if (this._Job.HasLoadedOrAssignedValue)
2721          {
2722            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2723          }
2724          this.OnTaskIdChanging(value);
2725          this.SendPropertyChanging();
2726          this._JobId = value;
2727          this.SendPropertyChanged("TaskId");
2728          this.OnTaskIdChanged();
2729        }
2730      }
2731    }
2732   
2733    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Data", DbType="VarBinary(MAX)", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
2734    public byte[] Data
2735    {
2736      get
2737      {
2738        return this._Data.Value;
2739      }
2740      set
2741      {
2742        if ((this._Data.Value != value))
2743        {
2744          this.OnDataChanging(value);
2745          this.SendPropertyChanging();
2746          this._Data.Value = value;
2747          this.SendPropertyChanged("Data");
2748          this.OnDataChanged();
2749        }
2750      }
2751    }
2752   
2753    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastUpdate", DbType="DateTime")]
2754    public System.DateTime LastUpdate
2755    {
2756      get
2757      {
2758        return this._LastUpdate;
2759      }
2760      set
2761      {
2762        if ((this._LastUpdate != value))
2763        {
2764          this.OnLastUpdateChanging(value);
2765          this.SendPropertyChanging();
2766          this._LastUpdate = value;
2767          this.SendPropertyChanged("LastUpdate");
2768          this.OnLastUpdateChanged();
2769        }
2770      }
2771    }
2772   
2773    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_TaskData", Storage="_Job", ThisKey="TaskId", OtherKey="TaskId", IsForeignKey=true)]
2774    public Task Task
2775    {
2776      get
2777      {
2778        return this._Job.Entity;
2779      }
2780      set
2781      {
2782        Task previousValue = this._Job.Entity;
2783        if (((previousValue != value)
2784              || (this._Job.HasLoadedOrAssignedValue == false)))
2785        {
2786          this.SendPropertyChanging();
2787          if ((previousValue != null))
2788          {
2789            this._Job.Entity = null;
2790            previousValue.JobData = null;
2791          }
2792          this._Job.Entity = value;
2793          if ((value != null))
2794          {
2795            value.JobData = this;
2796            this._JobId = value.TaskId;
2797          }
2798          else
2799          {
2800            this._JobId = default(System.Guid);
2801          }
2802          this.SendPropertyChanged("Task");
2803        }
2804      }
2805    }
2806   
2807    public event PropertyChangingEventHandler PropertyChanging;
2808   
2809    public event PropertyChangedEventHandler PropertyChanged;
2810   
2811    protected virtual void SendPropertyChanging()
2812    {
2813      if ((this.PropertyChanging != null))
2814      {
2815        this.PropertyChanging(this, emptyChangingEventArgs);
2816      }
2817    }
2818   
2819    protected virtual void SendPropertyChanged(String propertyName)
2820    {
2821      if ((this.PropertyChanged != null))
2822      {
2823        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2824      }
2825    }
2826  }
2827 
2828  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.PluginData")]
2829  public partial class PluginData : INotifyPropertyChanging, INotifyPropertyChanged
2830  {
2831   
2832    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2833   
2834    private System.Guid _PluginDataId;
2835   
2836    private System.Guid _PluginId;
2837   
2838    private System.Data.Linq.Link<byte[]> _Data;
2839   
2840    private string _FileName;
2841   
2842    private EntityRef<Plugin> _Plugin;
2843   
2844    #region Extensibility Method Definitions
2845    partial void OnLoaded();
2846    partial void OnValidate(System.Data.Linq.ChangeAction action);
2847    partial void OnCreated();
2848    partial void OnPluginDataIdChanging(System.Guid value);
2849    partial void OnPluginDataIdChanged();
2850    partial void OnPluginIdChanging(System.Guid value);
2851    partial void OnPluginIdChanged();
2852    partial void OnDataChanging(byte[] value);
2853    partial void OnDataChanged();
2854    partial void OnFileNameChanging(string value);
2855    partial void OnFileNameChanged();
2856    #endregion
2857   
2858    public PluginData()
2859    {
2860      this._Plugin = default(EntityRef<Plugin>);
2861      OnCreated();
2862    }
2863   
2864    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginDataId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
2865    public System.Guid PluginDataId
2866    {
2867      get
2868      {
2869        return this._PluginDataId;
2870      }
2871      set
2872      {
2873        if ((this._PluginDataId != value))
2874        {
2875          this.OnPluginDataIdChanging(value);
2876          this.SendPropertyChanging();
2877          this._PluginDataId = value;
2878          this.SendPropertyChanged("PluginDataId");
2879          this.OnPluginDataIdChanged();
2880        }
2881      }
2882    }
2883   
2884    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginId", DbType="UniqueIdentifier NOT NULL")]
2885    public System.Guid PluginId
2886    {
2887      get
2888      {
2889        return this._PluginId;
2890      }
2891      set
2892      {
2893        if ((this._PluginId != value))
2894        {
2895          if (this._Plugin.HasLoadedOrAssignedValue)
2896          {
2897            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2898          }
2899          this.OnPluginIdChanging(value);
2900          this.SendPropertyChanging();
2901          this._PluginId = value;
2902          this.SendPropertyChanged("PluginId");
2903          this.OnPluginIdChanged();
2904        }
2905      }
2906    }
2907   
2908    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Data", DbType="VarBinary(MAX) NOT NULL", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
2909    public byte[] Data
2910    {
2911      get
2912      {
2913        return this._Data.Value;
2914      }
2915      set
2916      {
2917        if ((this._Data.Value != value))
2918        {
2919          this.OnDataChanging(value);
2920          this.SendPropertyChanging();
2921          this._Data.Value = value;
2922          this.SendPropertyChanged("Data");
2923          this.OnDataChanged();
2924        }
2925      }
2926    }
2927   
2928    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_FileName", DbType="VarChar(MAX)", CanBeNull=false)]
2929    public string FileName
2930    {
2931      get
2932      {
2933        return this._FileName;
2934      }
2935      set
2936      {
2937        if ((this._FileName != value))
2938        {
2939          this.OnFileNameChanging(value);
2940          this.SendPropertyChanging();
2941          this._FileName = value;
2942          this.SendPropertyChanged("FileName");
2943          this.OnFileNameChanged();
2944        }
2945      }
2946    }
2947   
2948    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_PluginData", Storage="_Plugin", ThisKey="PluginId", OtherKey="PluginId", IsForeignKey=true)]
2949    public Plugin Plugin
2950    {
2951      get
2952      {
2953        return this._Plugin.Entity;
2954      }
2955      set
2956      {
2957        Plugin previousValue = this._Plugin.Entity;
2958        if (((previousValue != value)
2959              || (this._Plugin.HasLoadedOrAssignedValue == false)))
2960        {
2961          this.SendPropertyChanging();
2962          if ((previousValue != null))
2963          {
2964            this._Plugin.Entity = null;
2965            previousValue.PluginData.Remove(this);
2966          }
2967          this._Plugin.Entity = value;
2968          if ((value != null))
2969          {
2970            value.PluginData.Add(this);
2971            this._PluginId = value.PluginId;
2972          }
2973          else
2974          {
2975            this._PluginId = default(System.Guid);
2976          }
2977          this.SendPropertyChanged("Plugin");
2978        }
2979      }
2980    }
2981   
2982    public event PropertyChangingEventHandler PropertyChanging;
2983   
2984    public event PropertyChangedEventHandler PropertyChanged;
2985   
2986    protected virtual void SendPropertyChanging()
2987    {
2988      if ((this.PropertyChanging != null))
2989      {
2990        this.PropertyChanging(this, emptyChangingEventArgs);
2991      }
2992    }
2993   
2994    protected virtual void SendPropertyChanged(String propertyName)
2995    {
2996      if ((this.PropertyChanged != null))
2997      {
2998        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2999      }
3000    }
3001  }
3002 
3003  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.StateLog")]
3004  public partial class StateLog : INotifyPropertyChanging, INotifyPropertyChanged
3005  {
3006   
3007    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3008   
3009    private System.Guid _StateLogId;
3010   
3011    private global::HeuristicLab.Services.Hive.DataAccess.TaskState _State;
3012   
3013    private System.DateTime _DateTime;
3014   
3015    private System.Guid _JobId;
3016   
3017    private System.Nullable<System.Guid> _UserId;
3018   
3019    private System.Nullable<System.Guid> _SlaveId;
3020   
3021    private string _Exception;
3022   
3023    private EntityRef<Task> _Job;
3024   
3025    private EntityRef<Resource> _Resource;
3026   
3027    #region Extensibility Method Definitions
3028    partial void OnLoaded();
3029    partial void OnValidate(System.Data.Linq.ChangeAction action);
3030    partial void OnCreated();
3031    partial void OnStateLogIdChanging(System.Guid value);
3032    partial void OnStateLogIdChanged();
3033    partial void OnStateChanging(global::HeuristicLab.Services.Hive.DataAccess.TaskState value);
3034    partial void OnStateChanged();
3035    partial void OnDateTimeChanging(System.DateTime value);
3036    partial void OnDateTimeChanged();
3037    partial void OnTaskIdChanging(System.Guid value);
3038    partial void OnTaskIdChanged();
3039    partial void OnUserIdChanging(System.Nullable<System.Guid> value);
3040    partial void OnUserIdChanged();
3041    partial void OnSlaveIdChanging(System.Nullable<System.Guid> value);
3042    partial void OnSlaveIdChanged();
3043    partial void OnExceptionChanging(string value);
3044    partial void OnExceptionChanged();
3045    #endregion
3046   
3047    public StateLog()
3048    {
3049      this._Job = default(EntityRef<Task>);
3050      this._Resource = default(EntityRef<Resource>);
3051      OnCreated();
3052    }
3053   
3054    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StateLogId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
3055    public System.Guid StateLogId
3056    {
3057      get
3058      {
3059        return this._StateLogId;
3060      }
3061      set
3062      {
3063        if ((this._StateLogId != value))
3064        {
3065          this.OnStateLogIdChanging(value);
3066          this.SendPropertyChanging();
3067          this._StateLogId = value;
3068          this.SendPropertyChanged("StateLogId");
3069          this.OnStateLogIdChanged();
3070        }
3071      }
3072    }
3073   
3074    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_State", DbType="VarChar(30) NOT NULL", CanBeNull=false)]
3075    public global::HeuristicLab.Services.Hive.DataAccess.TaskState State
3076    {
3077      get
3078      {
3079        return this._State;
3080      }
3081      set
3082      {
3083        if ((this._State != value))
3084        {
3085          this.OnStateChanging(value);
3086          this.SendPropertyChanging();
3087          this._State = value;
3088          this.SendPropertyChanged("State");
3089          this.OnStateChanged();
3090        }
3091      }
3092    }
3093   
3094    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateTime", DbType="DateTime NOT NULL")]
3095    public System.DateTime DateTime
3096    {
3097      get
3098      {
3099        return this._DateTime;
3100      }
3101      set
3102      {
3103        if ((this._DateTime != value))
3104        {
3105          this.OnDateTimeChanging(value);
3106          this.SendPropertyChanging();
3107          this._DateTime = value;
3108          this.SendPropertyChanged("DateTime");
3109          this.OnDateTimeChanged();
3110        }
3111      }
3112    }
3113   
3114    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL")]
3115    public System.Guid TaskId
3116    {
3117      get
3118      {
3119        return this._JobId;
3120      }
3121      set
3122      {
3123        if ((this._JobId != value))
3124        {
3125          if (this._Job.HasLoadedOrAssignedValue)
3126          {
3127            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3128          }
3129          this.OnTaskIdChanging(value);
3130          this.SendPropertyChanging();
3131          this._JobId = value;
3132          this.SendPropertyChanged("TaskId");
3133          this.OnTaskIdChanged();
3134        }
3135      }
3136    }
3137   
3138    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier")]
3139    public System.Nullable<System.Guid> UserId
3140    {
3141      get
3142      {
3143        return this._UserId;
3144      }
3145      set
3146      {
3147        if ((this._UserId != value))
3148        {
3149          this.OnUserIdChanging(value);
3150          this.SendPropertyChanging();
3151          this._UserId = value;
3152          this.SendPropertyChanged("UserId");
3153          this.OnUserIdChanged();
3154        }
3155      }
3156    }
3157   
3158    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_SlaveId", DbType="UniqueIdentifier")]
3159    public System.Nullable<System.Guid> SlaveId
3160    {
3161      get
3162      {
3163        return this._SlaveId;
3164      }
3165      set
3166      {
3167        if ((this._SlaveId != value))
3168        {
3169          if (this._Resource.HasLoadedOrAssignedValue)
3170          {
3171            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3172          }
3173          this.OnSlaveIdChanging(value);
3174          this.SendPropertyChanging();
3175          this._SlaveId = value;
3176          this.SendPropertyChanged("SlaveId");
3177          this.OnSlaveIdChanged();
3178        }
3179      }
3180    }
3181   
3182    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Exception", DbType="VarChar(MAX)", CanBeNull=false)]
3183    public string Exception
3184    {
3185      get
3186      {
3187        return this._Exception;
3188      }
3189      set
3190      {
3191        if ((this._Exception != value))
3192        {
3193          this.OnExceptionChanging(value);
3194          this.SendPropertyChanging();
3195          this._Exception = value;
3196          this.SendPropertyChanged("Exception");
3197          this.OnExceptionChanged();
3198        }
3199      }
3200    }
3201   
3202    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Task_StateLog", Storage="_Job", ThisKey="TaskId", OtherKey="TaskId", IsForeignKey=true)]
3203    public Task Task
3204    {
3205      get
3206      {
3207        return this._Job.Entity;
3208      }
3209      set
3210      {
3211        Task previousValue = this._Job.Entity;
3212        if (((previousValue != value)
3213              || (this._Job.HasLoadedOrAssignedValue == false)))
3214        {
3215          this.SendPropertyChanging();
3216          if ((previousValue != null))
3217          {
3218            this._Job.Entity = null;
3219            previousValue.StateLogs.Remove(this);
3220          }
3221          this._Job.Entity = value;
3222          if ((value != null))
3223          {
3224            value.StateLogs.Add(this);
3225            this._JobId = value.TaskId;
3226          }
3227          else
3228          {
3229            this._JobId = default(System.Guid);
3230          }
3231          this.SendPropertyChanged("Task");
3232        }
3233      }
3234    }
3235   
3236    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_StateLog", Storage="_Resource", ThisKey="SlaveId", OtherKey="ResourceId", IsForeignKey=true)]
3237    public Resource Resource
3238    {
3239      get
3240      {
3241        return this._Resource.Entity;
3242      }
3243      set
3244      {
3245        Resource previousValue = this._Resource.Entity;
3246        if (((previousValue != value)
3247              || (this._Resource.HasLoadedOrAssignedValue == false)))
3248        {
3249          this.SendPropertyChanging();
3250          if ((previousValue != null))
3251          {
3252            this._Resource.Entity = null;
3253            previousValue.StateLogs.Remove(this);
3254          }
3255          this._Resource.Entity = value;
3256          if ((value != null))
3257          {
3258            value.StateLogs.Add(this);
3259            this._SlaveId = value.ResourceId;
3260          }
3261          else
3262          {
3263            this._SlaveId = default(Nullable<System.Guid>);
3264          }
3265          this.SendPropertyChanged("Resource");
3266        }
3267      }
3268    }
3269   
3270    public event PropertyChangingEventHandler PropertyChanging;
3271   
3272    public event PropertyChangedEventHandler PropertyChanged;
3273   
3274    protected virtual void SendPropertyChanging()
3275    {
3276      if ((this.PropertyChanging != null))
3277      {
3278        this.PropertyChanging(this, emptyChangingEventArgs);
3279      }
3280    }
3281   
3282    protected virtual void SendPropertyChanged(String propertyName)
3283    {
3284      if ((this.PropertyChanged != null))
3285      {
3286        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3287      }
3288    }
3289  }
3290 
3291  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.JobPermission")]
3292  public partial class JobPermission : INotifyPropertyChanging, INotifyPropertyChanged
3293  {
3294   
3295    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3296   
3297    private System.Guid _HiveExperimentId;
3298   
3299    private System.Guid _GrantedUserId;
3300   
3301    private System.Guid _GrantedByUserId;
3302   
3303    private global::HeuristicLab.Services.Hive.DataAccess.Permission _Permission;
3304   
3305    private EntityRef<Job> _HiveExperiment;
3306   
3307    #region Extensibility Method Definitions
3308    partial void OnLoaded();
3309    partial void OnValidate(System.Data.Linq.ChangeAction action);
3310    partial void OnCreated();
3311    partial void OnJobIdChanging(System.Guid value);
3312    partial void OnJobIdChanged();
3313    partial void OnGrantedUserIdChanging(System.Guid value);
3314    partial void OnGrantedUserIdChanged();
3315    partial void OnGrantedByUserIdChanging(System.Guid value);
3316    partial void OnGrantedByUserIdChanged();
3317    partial void OnPermissionChanging(global::HeuristicLab.Services.Hive.DataAccess.Permission value);
3318    partial void OnPermissionChanged();
3319    #endregion
3320   
3321    public JobPermission()
3322    {
3323      this._HiveExperiment = default(EntityRef<Job>);
3324      OnCreated();
3325    }
3326   
3327    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_HiveExperimentId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
3328    public System.Guid JobId
3329    {
3330      get
3331      {
3332        return this._HiveExperimentId;
3333      }
3334      set
3335      {
3336        if ((this._HiveExperimentId != value))
3337        {
3338          if (this._HiveExperiment.HasLoadedOrAssignedValue)
3339          {
3340            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3341          }
3342          this.OnJobIdChanging(value);
3343          this.SendPropertyChanging();
3344          this._HiveExperimentId = value;
3345          this.SendPropertyChanged("JobId");
3346          this.OnJobIdChanged();
3347        }
3348      }
3349    }
3350   
3351    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GrantedUserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
3352    public System.Guid GrantedUserId
3353    {
3354      get
3355      {
3356        return this._GrantedUserId;
3357      }
3358      set
3359      {
3360        if ((this._GrantedUserId != value))
3361        {
3362          this.OnGrantedUserIdChanging(value);
3363          this.SendPropertyChanging();
3364          this._GrantedUserId = value;
3365          this.SendPropertyChanged("GrantedUserId");
3366          this.OnGrantedUserIdChanged();
3367        }
3368      }
3369    }
3370   
3371    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GrantedByUserId", DbType="UniqueIdentifier NOT NULL")]
3372    public System.Guid GrantedByUserId
3373    {
3374      get
3375      {
3376        return this._GrantedByUserId;
3377      }
3378      set
3379      {
3380        if ((this._GrantedByUserId != value))
3381        {
3382          this.OnGrantedByUserIdChanging(value);
3383          this.SendPropertyChanging();
3384          this._GrantedByUserId = value;
3385          this.SendPropertyChanged("GrantedByUserId");
3386          this.OnGrantedByUserIdChanged();
3387        }
3388      }
3389    }
3390   
3391    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Permission", DbType="VarChar(15) NOT NULL", CanBeNull=false)]
3392    public global::HeuristicLab.Services.Hive.DataAccess.Permission Permission
3393    {
3394      get
3395      {
3396        return this._Permission;
3397      }
3398      set
3399      {
3400        if ((this._Permission != value))
3401        {
3402          this.OnPermissionChanging(value);
3403          this.SendPropertyChanging();
3404          this._Permission = value;
3405          this.SendPropertyChanged("Permission");
3406          this.OnPermissionChanged();
3407        }
3408      }
3409    }
3410   
3411    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_JobPermission", Storage="_HiveExperiment", ThisKey="JobId", OtherKey="JobId", IsForeignKey=true)]
3412    public Job Job
3413    {
3414      get
3415      {
3416        return this._HiveExperiment.Entity;
3417      }
3418      set
3419      {
3420        Job previousValue = this._HiveExperiment.Entity;
3421        if (((previousValue != value)
3422              || (this._HiveExperiment.HasLoadedOrAssignedValue == false)))
3423        {
3424          this.SendPropertyChanging();
3425          if ((previousValue != null))
3426          {
3427            this._HiveExperiment.Entity = null;
3428            previousValue.JobPermissions.Remove(this);
3429          }
3430          this._HiveExperiment.Entity = value;
3431          if ((value != null))
3432          {
3433            value.JobPermissions.Add(this);
3434            this._HiveExperimentId = value.JobId;
3435          }
3436          else
3437          {
3438            this._HiveExperimentId = default(System.Guid);
3439          }
3440          this.SendPropertyChanged("Job");
3441        }
3442      }
3443    }
3444   
3445    public event PropertyChangingEventHandler PropertyChanging;
3446   
3447    public event PropertyChangedEventHandler PropertyChanged;
3448   
3449    protected virtual void SendPropertyChanging()
3450    {
3451      if ((this.PropertyChanging != null))
3452      {
3453        this.PropertyChanging(this, emptyChangingEventArgs);
3454      }
3455    }
3456   
3457    protected virtual void SendPropertyChanged(String propertyName)
3458    {
3459      if ((this.PropertyChanged != null))
3460      {
3461        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3462      }
3463    }
3464  }
3465 
3466  [global::System.Data.Linq.Mapping.TableAttribute(Name="")]
3467  public partial class Lifecycle : INotifyPropertyChanging, INotifyPropertyChanged
3468  {
3469   
3470    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3471   
3472    private int _LifecycleId;
3473   
3474    private System.DateTime _LastCleanup;
3475   
3476    #region Extensibility Method Definitions
3477    partial void OnLoaded();
3478    partial void OnValidate(System.Data.Linq.ChangeAction action);
3479    partial void OnCreated();
3480    partial void OnLifecycleIdChanging(int value);
3481    partial void OnLifecycleIdChanged();
3482    partial void OnLastCleanupChanging(System.DateTime value);
3483    partial void OnLastCleanupChanged();
3484    #endregion
3485   
3486    public Lifecycle()
3487    {
3488      OnCreated();
3489    }
3490   
3491    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LifecycleId", DbType="Int", IsPrimaryKey=true)]
3492    public int LifecycleId
3493    {
3494      get
3495      {
3496        return this._LifecycleId;
3497      }
3498      set
3499      {
3500        if ((this._LifecycleId != value))
3501        {
3502          this.OnLifecycleIdChanging(value);
3503          this.SendPropertyChanging();
3504          this._LifecycleId = value;
3505          this.SendPropertyChanged("LifecycleId");
3506          this.OnLifecycleIdChanged();
3507        }
3508      }
3509    }
3510   
3511    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastCleanup", DbType="DateTime")]
3512    public System.DateTime LastCleanup
3513    {
3514      get
3515      {
3516        return this._LastCleanup;
3517      }
3518      set
3519      {
3520        if ((this._LastCleanup != value))
3521        {
3522          this.OnLastCleanupChanging(value);
3523          this.SendPropertyChanging();
3524          this._LastCleanup = value;
3525          this.SendPropertyChanged("LastCleanup");
3526          this.OnLastCleanupChanged();
3527        }
3528      }
3529    }
3530   
3531    public event PropertyChangingEventHandler PropertyChanging;
3532   
3533    public event PropertyChangedEventHandler PropertyChanged;
3534   
3535    protected virtual void SendPropertyChanging()
3536    {
3537      if ((this.PropertyChanging != null))
3538      {
3539        this.PropertyChanging(this, emptyChangingEventArgs);
3540      }
3541    }
3542   
3543    protected virtual void SendPropertyChanged(String propertyName)
3544    {
3545      if ((this.PropertyChanged != null))
3546      {
3547        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3548      }
3549    }
3550  }
3551 
3552  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ResourcePermission")]
3553  public partial class ResourcePermission : INotifyPropertyChanging, INotifyPropertyChanged
3554  {
3555   
3556    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3557   
3558    private System.Guid _ResourceId;
3559   
3560    private System.Guid _GrantedUserId;
3561   
3562    private System.Guid _GrantedByUserId;
3563   
3564    private EntityRef<Resource> _Resource;
3565   
3566    #region Extensibility Method Definitions
3567    partial void OnLoaded();
3568    partial void OnValidate(System.Data.Linq.ChangeAction action);
3569    partial void OnCreated();
3570    partial void OnResourceIdChanging(System.Guid value);
3571    partial void OnResourceIdChanged();
3572    partial void OnGrantedUserIdChanging(System.Guid value);
3573    partial void OnGrantedUserIdChanged();
3574    partial void OnGrantedByUserIdChanging(System.Guid value);
3575    partial void OnGrantedByUserIdChanged();
3576    #endregion
3577   
3578    public ResourcePermission()
3579    {
3580      this._Resource = default(EntityRef<Resource>);
3581      OnCreated();
3582    }
3583   
3584    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
3585    public System.Guid ResourceId
3586    {
3587      get
3588      {
3589        return this._ResourceId;
3590      }
3591      set
3592      {
3593        if ((this._ResourceId != value))
3594        {
3595          if (this._Resource.HasLoadedOrAssignedValue)
3596          {
3597            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3598          }
3599          this.OnResourceIdChanging(value);
3600          this.SendPropertyChanging();
3601          this._ResourceId = value;
3602          this.SendPropertyChanged("ResourceId");
3603          this.OnResourceIdChanged();
3604        }
3605      }
3606    }
3607   
3608    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GrantedUserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
3609    public System.Guid GrantedUserId
3610    {
3611      get
3612      {
3613        return this._GrantedUserId;
3614      }
3615      set
3616      {
3617        if ((this._GrantedUserId != value))
3618        {
3619          this.OnGrantedUserIdChanging(value);
3620          this.SendPropertyChanging();
3621          this._GrantedUserId = value;
3622          this.SendPropertyChanged("GrantedUserId");
3623          this.OnGrantedUserIdChanged();
3624        }
3625      }
3626    }
3627   
3628    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GrantedByUserId", DbType="UniqueIdentifier NOT NULL")]
3629    public System.Guid GrantedByUserId
3630    {
3631      get
3632      {
3633        return this._GrantedByUserId;
3634      }
3635      set
3636      {
3637        if ((this._GrantedByUserId != value))
3638        {
3639          this.OnGrantedByUserIdChanging(value);
3640          this.SendPropertyChanging();
3641          this._GrantedByUserId = value;
3642          this.SendPropertyChanged("GrantedByUserId");
3643          this.OnGrantedByUserIdChanged();
3644        }
3645      }
3646    }
3647   
3648    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_ResourcePermission", Storage="_Resource", ThisKey="ResourceId", OtherKey="ResourceId", IsForeignKey=true)]
3649    public Resource Resource
3650    {
3651      get
3652      {
3653        return this._Resource.Entity;
3654      }
3655      set
3656      {
3657        Resource previousValue = this._Resource.Entity;
3658        if (((previousValue != value)
3659              || (this._Resource.HasLoadedOrAssignedValue == false)))
3660        {
3661          this.SendPropertyChanging();
3662          if ((previousValue != null))
3663          {
3664            this._Resource.Entity = null;
3665            previousValue.ResourcePermissions.Remove(this);
3666          }
3667          this._Resource.Entity = value;
3668          if ((value != null))
3669          {
3670            value.ResourcePermissions.Add(this);
3671            this._ResourceId = value.ResourceId;
3672          }
3673          else
3674          {
3675            this._ResourceId = default(System.Guid);
3676          }
3677          this.SendPropertyChanged("Resource");
3678        }
3679      }
3680    }
3681   
3682    public event PropertyChangingEventHandler PropertyChanging;
3683   
3684    public event PropertyChangedEventHandler PropertyChanged;
3685   
3686    protected virtual void SendPropertyChanging()
3687    {
3688      if ((this.PropertyChanging != null))
3689      {
3690        this.PropertyChanging(this, emptyChangingEventArgs);
3691      }
3692    }
3693   
3694    protected virtual void SendPropertyChanged(String propertyName)
3695    {
3696      if ((this.PropertyChanged != null))
3697      {
3698        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3699      }
3700    }
3701  }
3702 
3703  [global::System.Data.Linq.Mapping.TableAttribute(Name="")]
3704  public partial class UserPriority : INotifyPropertyChanging, INotifyPropertyChanged
3705  {
3706   
3707    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3708   
3709    private System.Guid _UserId;
3710   
3711    private System.DateTime _DateEnqueued;
3712   
3713    #region Extensibility Method Definitions
3714    partial void OnLoaded();
3715    partial void OnValidate(System.Data.Linq.ChangeAction action);
3716    partial void OnCreated();
3717    partial void OnUserIdChanging(System.Guid value);
3718    partial void OnUserIdChanged();
3719    partial void OnDateEnqueuedChanging(System.DateTime value);
3720    partial void OnDateEnqueuedChanged();
3721    #endregion
3722   
3723    public UserPriority()
3724    {
3725      OnCreated();
3726    }
3727   
3728    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
3729    public System.Guid UserId
3730    {
3731      get
3732      {
3733        return this._UserId;
3734      }
3735      set
3736      {
3737        if ((this._UserId != value))
3738        {
3739          this.OnUserIdChanging(value);
3740          this.SendPropertyChanging();
3741          this._UserId = value;
3742          this.SendPropertyChanged("UserId");
3743          this.OnUserIdChanged();
3744        }
3745      }
3746    }
3747   
3748    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateEnqueued", DbType="DateTime NOT NULL")]
3749    public System.DateTime DateEnqueued
3750    {
3751      get
3752      {
3753        return this._DateEnqueued;
3754      }
3755      set
3756      {
3757        if ((this._DateEnqueued != value))
3758        {
3759          this.OnDateEnqueuedChanging(value);
3760          this.SendPropertyChanging();
3761          this._DateEnqueued = value;
3762          this.SendPropertyChanged("DateEnqueued");
3763          this.OnDateEnqueuedChanged();
3764        }
3765      }
3766    }
3767   
3768    public event PropertyChangingEventHandler PropertyChanging;
3769   
3770    public event PropertyChangedEventHandler PropertyChanged;
3771   
3772    protected virtual void SendPropertyChanging()
3773    {
3774      if ((this.PropertyChanging != null))
3775      {
3776        this.PropertyChanging(this, emptyChangingEventArgs);
3777      }
3778    }
3779   
3780    protected virtual void SendPropertyChanged(String propertyName)
3781    {
3782      if ((this.PropertyChanged != null))
3783      {
3784        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3785      }
3786    }
3787  }
3788 
3789  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimClient")]
3790  public partial class DimClient : INotifyPropertyChanging, INotifyPropertyChanged
3791  {
3792   
3793    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3794   
3795    private System.Guid _Id;
3796   
3797    private string _Name;
3798   
3799    private System.Guid _ResourceId;
3800   
3801    private System.Nullable<System.DateTime> _ExpirationTime;
3802   
3803    private System.Nullable<System.Guid> _ResourceGroupId;
3804   
3805    private System.Nullable<System.Guid> _ResourceGroup2Id;
3806   
3807    private string _GroupName;
3808   
3809    private string _GroupName2;
3810   
3811    private EntitySet<FactTask> _FactTasks;
3812   
3813    private EntitySet<FactClientInfo> _FactClientInfos;
3814   
3815    #region Extensibility Method Definitions
3816    partial void OnLoaded();
3817    partial void OnValidate(System.Data.Linq.ChangeAction action);
3818    partial void OnCreated();
3819    partial void OnIdChanging(System.Guid value);
3820    partial void OnIdChanged();
3821    partial void OnNameChanging(string value);
3822    partial void OnNameChanged();
3823    partial void OnResourceIdChanging(System.Guid value);
3824    partial void OnResourceIdChanged();
3825    partial void OnExpirationTimeChanging(System.Nullable<System.DateTime> value);
3826    partial void OnExpirationTimeChanged();
3827    partial void OnResourceGroupIdChanging(System.Nullable<System.Guid> value);
3828    partial void OnResourceGroupIdChanged();
3829    partial void OnResourceGroup2IdChanging(System.Nullable<System.Guid> value);
3830    partial void OnResourceGroup2IdChanged();
3831    partial void OnGroupNameChanging(string value);
3832    partial void OnGroupNameChanged();
3833    partial void OnGroupName2Changing(string value);
3834    partial void OnGroupName2Changed();
3835    #endregion
3836   
3837    public DimClient()
3838    {
3839      this._FactTasks = new EntitySet<FactTask>(new Action<FactTask>(this.attach_FactTasks), new Action<FactTask>(this.detach_FactTasks));
3840      this._FactClientInfos = new EntitySet<FactClientInfo>(new Action<FactClientInfo>(this.attach_FactClientInfos), new Action<FactClientInfo>(this.detach_FactClientInfos));
3841      OnCreated();
3842    }
3843   
3844    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
3845    public System.Guid Id
3846    {
3847      get
3848      {
3849        return this._Id;
3850      }
3851      set
3852      {
3853        if ((this._Id != value))
3854        {
3855          this.OnIdChanging(value);
3856          this.SendPropertyChanging();
3857          this._Id = value;
3858          this.SendPropertyChanged("Id");
3859          this.OnIdChanged();
3860        }
3861      }
3862    }
3863   
3864    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
3865    public string Name
3866    {
3867      get
3868      {
3869        return this._Name;
3870      }
3871      set
3872      {
3873        if ((this._Name != value))
3874        {
3875          this.OnNameChanging(value);
3876          this.SendPropertyChanging();
3877          this._Name = value;
3878          this.SendPropertyChanged("Name");
3879          this.OnNameChanged();
3880        }
3881      }
3882    }
3883   
3884    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier NOT NULL")]
3885    public System.Guid ResourceId
3886    {
3887      get
3888      {
3889        return this._ResourceId;
3890      }
3891      set
3892      {
3893        if ((this._ResourceId != value))
3894        {
3895          this.OnResourceIdChanging(value);
3896          this.SendPropertyChanging();
3897          this._ResourceId = value;
3898          this.SendPropertyChanged("ResourceId");
3899          this.OnResourceIdChanged();
3900        }
3901      }
3902    }
3903   
3904    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ExpirationTime", DbType="DateTime")]
3905    public System.Nullable<System.DateTime> ExpirationTime
3906    {
3907      get
3908      {
3909        return this._ExpirationTime;
3910      }
3911      set
3912      {
3913        if ((this._ExpirationTime != value))
3914        {
3915          this.OnExpirationTimeChanging(value);
3916          this.SendPropertyChanging();
3917          this._ExpirationTime = value;
3918          this.SendPropertyChanged("ExpirationTime");
3919          this.OnExpirationTimeChanged();
3920        }
3921      }
3922    }
3923   
3924    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceGroupId", DbType="UniqueIdentifier")]
3925    public System.Nullable<System.Guid> ResourceGroupId
3926    {
3927      get
3928      {
3929        return this._ResourceGroupId;
3930      }
3931      set
3932      {
3933        if ((this._ResourceGroupId != value))
3934        {
3935          this.OnResourceGroupIdChanging(value);
3936          this.SendPropertyChanging();
3937          this._ResourceGroupId = value;
3938          this.SendPropertyChanged("ResourceGroupId");
3939          this.OnResourceGroupIdChanged();
3940        }
3941      }
3942    }
3943   
3944    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceGroup2Id", DbType="UniqueIdentifier")]
3945    public System.Nullable<System.Guid> ResourceGroup2Id
3946    {
3947      get
3948      {
3949        return this._ResourceGroup2Id;
3950      }
3951      set
3952      {
3953        if ((this._ResourceGroup2Id != value))
3954        {
3955          this.OnResourceGroup2IdChanging(value);
3956          this.SendPropertyChanging();
3957          this._ResourceGroup2Id = value;
3958          this.SendPropertyChanged("ResourceGroup2Id");
3959          this.OnResourceGroup2IdChanged();
3960        }
3961      }
3962    }
3963   
3964    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GroupName")]
3965    public string GroupName
3966    {
3967      get
3968      {
3969        return this._GroupName;
3970      }
3971      set
3972      {
3973        if ((this._GroupName != value))
3974        {
3975          this.OnGroupNameChanging(value);
3976          this.SendPropertyChanging();
3977          this._GroupName = value;
3978          this.SendPropertyChanged("GroupName");
3979          this.OnGroupNameChanged();
3980        }
3981      }
3982    }
3983   
3984    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GroupName2")]
3985    public string GroupName2
3986    {
3987      get
3988      {
3989        return this._GroupName2;
3990      }
3991      set
3992      {
3993        if ((this._GroupName2 != value))
3994        {
3995          this.OnGroupName2Changing(value);
3996          this.SendPropertyChanging();
3997          this._GroupName2 = value;
3998          this.SendPropertyChanged("GroupName2");
3999          this.OnGroupName2Changed();
4000        }
4001      }
4002    }
4003   
4004    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactTask", Storage="_FactTasks", ThisKey="Id", OtherKey="LastClientId")]
4005    public EntitySet<FactTask> FactTasks
4006    {
4007      get
4008      {
4009        return this._FactTasks;
4010      }
4011      set
4012      {
4013        this._FactTasks.Assign(value);
4014      }
4015    }
4016   
4017    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactClientInfo", Storage="_FactClientInfos", ThisKey="Id", OtherKey="ClientId")]
4018    public EntitySet<FactClientInfo> FactClientInfos
4019    {
4020      get
4021      {
4022        return this._FactClientInfos;
4023      }
4024      set
4025      {
4026        this._FactClientInfos.Assign(value);
4027      }
4028    }
4029   
4030    public event PropertyChangingEventHandler PropertyChanging;
4031   
4032    public event PropertyChangedEventHandler PropertyChanged;
4033   
4034    protected virtual void SendPropertyChanging()
4035    {
4036      if ((this.PropertyChanging != null))
4037      {
4038        this.PropertyChanging(this, emptyChangingEventArgs);
4039      }
4040    }
4041   
4042    protected virtual void SendPropertyChanged(String propertyName)
4043    {
4044      if ((this.PropertyChanged != null))
4045      {
4046        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
4047      }
4048    }
4049   
4050    private void attach_FactTasks(FactTask entity)
4051    {
4052      this.SendPropertyChanging();
4053      entity.DimClient = this;
4054    }
4055   
4056    private void detach_FactTasks(FactTask entity)
4057    {
4058      this.SendPropertyChanging();
4059      entity.DimClient = null;
4060    }
4061   
4062    private void attach_FactClientInfos(FactClientInfo entity)
4063    {
4064      this.SendPropertyChanging();
4065      entity.DimClient = this;
4066    }
4067   
4068    private void detach_FactClientInfos(FactClientInfo entity)
4069    {
4070      this.SendPropertyChanging();
4071      entity.DimClient = null;
4072    }
4073  }
4074 
4075  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].FactTask")]
4076  public partial class FactTask : INotifyPropertyChanging, INotifyPropertyChanged
4077  {
4078   
4079    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
4080   
4081    private System.Guid _TaskId;
4082   
4083    private long _TotalRuntime;
4084   
4085    private long _TotalWaitingTime;
4086   
4087    private long _TotalTransferTime;
4088   
4089    private int _NumCalculationRuns;
4090   
4091    private int _NumFails;
4092   
4093    private int _CoresRequired;
4094   
4095    private int _MemoryRequired;
4096   
4097    private int _Priority;
4098   
4099    private System.Nullable<System.Guid> _LastClientId;
4100   
4101    private System.Guid _JobId;
4102   
4103    private System.Nullable<System.DateTime> _EndTime;
4104   
4105    private global::HeuristicLab.Services.Hive.DataAccess.TaskState _TaskState;
4106   
4107    private string _Exception;
4108   
4109    private long _InitialWaitingTimeMs;
4110   
4111    private System.Nullable<System.DateTime> _StartTime;
4112   
4113    private EntityRef<DimClient> _DimClient;
4114   
4115    private EntityRef<DimJob> _DimJob;
4116   
4117    #region Extensibility Method Definitions
4118    partial void OnLoaded();
4119    partial void OnValidate(System.Data.Linq.ChangeAction action);
4120    partial void OnCreated();
4121    partial void OnTaskIdChanging(System.Guid value);
4122    partial void OnTaskIdChanged();
4123    partial void OnCalculatingTimeChanging(long value);
4124    partial void OnCalculatingTimeChanged();
4125    partial void OnWaitingTimeChanging(long value);
4126    partial void OnWaitingTimeChanged();
4127    partial void OnTransferTimeChanging(long value);
4128    partial void OnTransferTimeChanged();
4129    partial void OnNumCalculationRunsChanging(int value);
4130    partial void OnNumCalculationRunsChanged();
4131    partial void OnNumRetriesChanging(int value);
4132    partial void OnNumRetriesChanged();
4133    partial void OnCoresRequiredChanging(int value);
4134    partial void OnCoresRequiredChanged();
4135    partial void OnMemoryRequiredChanging(int value);
4136    partial void OnMemoryRequiredChanged();
4137    partial void OnPriorityChanging(int value);
4138    partial void OnPriorityChanged();
4139    partial void OnLastClientIdChanging(System.Nullable<System.Guid> value);
4140    partial void OnLastClientIdChanged();
4141    partial void OnJobIdChanging(System.Guid value);
4142    partial void OnJobIdChanged();
4143    partial void OnEndTimeChanging(System.Nullable<System.DateTime> value);
4144    partial void OnEndTimeChanged();
4145    partial void OnTaskStateChanging(global::HeuristicLab.Services.Hive.DataAccess.TaskState value);
4146    partial void OnTaskStateChanged();
4147    partial void OnExceptionChanging(string value);
4148    partial void OnExceptionChanged();
4149    partial void OnInitialWaitingTimeChanging(long value);
4150    partial void OnInitialWaitingTimeChanged();
4151    partial void OnStartTimeChanging(System.Nullable<System.DateTime> value);
4152    partial void OnStartTimeChanged();
4153    #endregion
4154   
4155    public FactTask()
4156    {
4157      this._DimClient = default(EntityRef<DimClient>);
4158      this._DimJob = default(EntityRef<DimJob>);
4159      OnCreated();
4160    }
4161   
4162    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TaskId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
4163    public System.Guid TaskId
4164    {
4165      get
4166      {
4167        return this._TaskId;
4168      }
4169      set
4170      {
4171        if ((this._TaskId != value))
4172        {
4173          this.OnTaskIdChanging(value);
4174          this.SendPropertyChanging();
4175          this._TaskId = value;
4176          this.SendPropertyChanged("TaskId");
4177          this.OnTaskIdChanged();
4178        }
4179      }
4180    }
4181   
4182    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalRuntime", DbType="INT NOT NULL")]
4183    public long CalculatingTime
4184    {
4185      get
4186      {
4187        return this._TotalRuntime;
4188      }
4189      set
4190      {
4191        if ((this._TotalRuntime != value))
4192        {
4193          this.OnCalculatingTimeChanging(value);
4194          this.SendPropertyChanging();
4195          this._TotalRuntime = value;
4196          this.SendPropertyChanged("CalculatingTime");
4197          this.OnCalculatingTimeChanged();
4198        }
4199      }
4200    }
4201   
4202    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalWaitingTime", DbType="INT NOT NULL")]
4203    public long WaitingTime
4204    {
4205      get
4206      {
4207        return this._TotalWaitingTime;
4208      }
4209      set
4210      {
4211        if ((this._TotalWaitingTime != value))
4212        {
4213          this.OnWaitingTimeChanging(value);
4214          this.SendPropertyChanging();
4215          this._TotalWaitingTime = value;
4216          this.SendPropertyChanged("WaitingTime");
4217          this.OnWaitingTimeChanged();
4218        }
4219      }
4220    }
4221   
4222    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTransferTime", DbType="INT NOT NULL")]
4223    public long TransferTime
4224    {
4225      get
4226      {
4227        return this._TotalTransferTime;
4228      }
4229      set
4230      {
4231        if ((this._TotalTransferTime != value))
4232        {
4233          this.OnTransferTimeChanging(value);
4234          this.SendPropertyChanging();
4235          this._TotalTransferTime = value;
4236          this.SendPropertyChanged("TransferTime");
4237          this.OnTransferTimeChanged();
4238        }
4239      }
4240    }
4241   
4242    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumCalculationRuns", DbType="Int NOT NULL")]
4243    public int NumCalculationRuns
4244    {
4245      get
4246      {
4247        return this._NumCalculationRuns;
4248      }
4249      set
4250      {
4251        if ((this._NumCalculationRuns != value))
4252        {
4253          this.OnNumCalculationRunsChanging(value);
4254          this.SendPropertyChanging();
4255          this._NumCalculationRuns = value;
4256          this.SendPropertyChanged("NumCalculationRuns");
4257          this.OnNumCalculationRunsChanged();
4258        }
4259      }
4260    }
4261   
4262    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumFails", DbType="Int NOT NULL")]
4263    public int NumRetries
4264    {
4265      get
4266      {
4267        return this._NumFails;
4268      }
4269      set
4270      {
4271        if ((this._NumFails != value))
4272        {
4273          this.OnNumRetriesChanging(value);
4274          this.SendPropertyChanging();
4275          this._NumFails = value;
4276          this.SendPropertyChanged("NumRetries");
4277          this.OnNumRetriesChanged();
4278        }
4279      }
4280    }
4281   
4282    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CoresRequired", DbType="Int NOT NULL")]
4283    public int CoresRequired
4284    {
4285      get
4286      {
4287        return this._CoresRequired;
4288      }
4289      set
4290      {
4291        if ((this._CoresRequired != value))
4292        {
4293          this.OnCoresRequiredChanging(value);
4294          this.SendPropertyChanging();
4295          this._CoresRequired = value;
4296          this.SendPropertyChanged("CoresRequired");
4297          this.OnCoresRequiredChanged();
4298        }
4299      }
4300    }
4301   
4302    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_MemoryRequired", DbType="Int NOT NULL")]
4303    public int MemoryRequired
4304    {
4305      get
4306      {
4307        return this._MemoryRequired;
4308      }
4309      set
4310      {
4311        if ((this._MemoryRequired != value))
4312        {
4313          this.OnMemoryRequiredChanging(value);
4314          this.SendPropertyChanging();
4315          this._MemoryRequired = value;
4316          this.SendPropertyChanged("MemoryRequired");
4317          this.OnMemoryRequiredChanged();
4318        }
4319      }
4320    }
4321   
4322    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Priority", DbType="Int NOT NULL")]
4323    public int Priority
4324    {
4325      get
4326      {
4327        return this._Priority;
4328      }
4329      set
4330      {
4331        if ((this._Priority != value))
4332        {
4333          this.OnPriorityChanging(value);
4334          this.SendPropertyChanging();
4335          this._Priority = value;
4336          this.SendPropertyChanged("Priority");
4337          this.OnPriorityChanged();
4338        }
4339      }
4340    }
4341   
4342    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastClientId", DbType="UniqueIdentifier NOT NULL")]
4343    public System.Nullable<System.Guid> LastClientId
4344    {
4345      get
4346      {
4347        return this._LastClientId;
4348      }
4349      set
4350      {
4351        if ((this._LastClientId != value))
4352        {
4353          if (this._DimClient.HasLoadedOrAssignedValue)
4354          {
4355            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
4356          }
4357          this.OnLastClientIdChanging(value);
4358          this.SendPropertyChanging();
4359          this._LastClientId = value;
4360          this.SendPropertyChanged("LastClientId");
4361          this.OnLastClientIdChanged();
4362        }
4363      }
4364    }
4365   
4366    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL")]
4367    public System.Guid JobId
4368    {
4369      get
4370      {
4371        return this._JobId;
4372      }
4373      set
4374      {
4375        if ((this._JobId != value))
4376        {
4377          if (this._DimJob.HasLoadedOrAssignedValue)
4378          {
4379            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
4380          }
4381          this.OnJobIdChanging(value);
4382          this.SendPropertyChanging();
4383          this._JobId = value;
4384          this.SendPropertyChanged("JobId");
4385          this.OnJobIdChanged();
4386        }
4387      }
4388    }
4389   
4390    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_EndTime", DbType="DateTime NOT NULL")]
4391    public System.Nullable<System.DateTime> EndTime
4392    {
4393      get
4394      {
4395        return this._EndTime;
4396      }
4397      set
4398      {
4399        if ((this._EndTime != value))
4400        {
4401          this.OnEndTimeChanging(value);
4402          this.SendPropertyChanging();
4403          this._EndTime = value;
4404          this.SendPropertyChanged("EndTime");
4405          this.OnEndTimeChanged();
4406        }
4407      }
4408    }
4409   
4410    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TaskState", DbType="varchar(30)", CanBeNull=false)]
4411    public global::HeuristicLab.Services.Hive.DataAccess.TaskState TaskState
4412    {
4413      get
4414      {
4415        return this._TaskState;
4416      }
4417      set
4418      {
4419        if ((this._TaskState != value))
4420        {
4421          this.OnTaskStateChanging(value);
4422          this.SendPropertyChanging();
4423          this._TaskState = value;
4424          this.SendPropertyChanged("TaskState");
4425          this.OnTaskStateChanged();
4426        }
4427      }
4428    }
4429   
4430    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Exception", DbType="varchar(MAX)")]
4431    public string Exception
4432    {
4433      get
4434      {
4435        return this._Exception;
4436      }
4437      set
4438      {
4439        if ((this._Exception != value))
4440        {
4441          this.OnExceptionChanging(value);
4442          this.SendPropertyChanging();
4443          this._Exception = value;
4444          this.SendPropertyChanged("Exception");
4445          this.OnExceptionChanged();
4446        }
4447      }
4448    }
4449   
4450    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_InitialWaitingTimeMs", DbType="INT")]
4451    public long InitialWaitingTime
4452    {
4453      get
4454      {
4455        return this._InitialWaitingTimeMs;
4456      }
4457      set
4458      {
4459        if ((this._InitialWaitingTimeMs != value))
4460        {
4461          this.OnInitialWaitingTimeChanging(value);
4462          this.SendPropertyChanging();
4463          this._InitialWaitingTimeMs = value;
4464          this.SendPropertyChanged("InitialWaitingTime");
4465          this.OnInitialWaitingTimeChanged();
4466        }
4467      }
4468    }
4469   
4470    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StartTime")]
4471    public System.Nullable<System.DateTime> StartTime
4472    {
4473      get
4474      {
4475        return this._StartTime;
4476      }
4477      set
4478      {
4479        if ((this._StartTime != value))
4480        {
4481          this.OnStartTimeChanging(value);
4482          this.SendPropertyChanging();
4483          this._StartTime = value;
4484          this.SendPropertyChanged("StartTime");
4485          this.OnStartTimeChanged();
4486        }
4487      }
4488    }
4489   
4490    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactTask", Storage="_DimClient", ThisKey="LastClientId", OtherKey="Id", IsForeignKey=true)]
4491    public DimClient DimClient
4492    {
4493      get
4494      {
4495        return this._DimClient.Entity;
4496      }
4497      set
4498      {
4499        DimClient previousValue = this._DimClient.Entity;
4500        if (((previousValue != value)
4501              || (this._DimClient.HasLoadedOrAssignedValue == false)))
4502        {
4503          this.SendPropertyChanging();
4504          if ((previousValue != null))
4505          {
4506            this._DimClient.Entity = null;
4507            previousValue.FactTasks.Remove(this);
4508          }
4509          this._DimClient.Entity = value;
4510          if ((value != null))
4511          {
4512            value.FactTasks.Add(this);
4513            this._LastClientId = value.Id;
4514          }
4515          else
4516          {
4517            this._LastClientId = default(Nullable<System.Guid>);
4518          }
4519          this.SendPropertyChanged("DimClient");
4520        }
4521      }
4522    }
4523   
4524    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimJob_FactTask", Storage="_DimJob", ThisKey="JobId", OtherKey="JobId", IsForeignKey=true)]
4525    public DimJob DimJob
4526    {
4527      get
4528      {
4529        return this._DimJob.Entity;
4530      }
4531      set
4532      {
4533        DimJob previousValue = this._DimJob.Entity;
4534        if (((previousValue != value)
4535              || (this._DimJob.HasLoadedOrAssignedValue == false)))
4536        {
4537          this.SendPropertyChanging();
4538          if ((previousValue != null))
4539          {
4540            this._DimJob.Entity = null;
4541            previousValue.FactTasks.Remove(this);
4542          }
4543          this._DimJob.Entity = value;
4544          if ((value != null))
4545          {
4546            value.FactTasks.Add(this);
4547            this._JobId = value.JobId;
4548          }
4549          else
4550          {
4551            this._JobId = default(System.Guid);
4552          }
4553          this.SendPropertyChanged("DimJob");
4554        }
4555      }
4556    }
4557   
4558    public event PropertyChangingEventHandler PropertyChanging;
4559   
4560    public event PropertyChangedEventHandler PropertyChanged;
4561   
4562    protected virtual void SendPropertyChanging()
4563    {
4564      if ((this.PropertyChanging != null))
4565      {
4566        this.PropertyChanging(this, emptyChangingEventArgs);
4567      }
4568    }
4569   
4570    protected virtual void SendPropertyChanged(String propertyName)
4571    {
4572      if ((this.PropertyChanged != null))
4573      {
4574        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
4575      }
4576    }
4577  }
4578 
4579  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimJob")]
4580  public partial class DimJob : INotifyPropertyChanging, INotifyPropertyChanged
4581  {
4582   
4583    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
4584   
4585    private System.Guid _JobId;
4586   
4587    private System.Guid _UserId;
4588   
4589    private string _JobName;
4590   
4591    private string _UserName;
4592   
4593    private System.DateTime _DateCreated;
4594   
4595    private int _TotalTasks;
4596   
4597    private int _CompletedTasks;
4598   
4599    private System.Nullable<System.DateTime> _DateCompleted;
4600   
4601    private EntitySet<FactTask> _FactTasks;
4602   
4603    #region Extensibility Method Definitions
4604    partial void OnLoaded();
4605    partial void OnValidate(System.Data.Linq.ChangeAction action);
4606    partial void OnCreated();
4607    partial void OnJobIdChanging(System.Guid value);
4608    partial void OnJobIdChanged();
4609    partial void OnUserIdChanging(System.Guid value);
4610    partial void OnUserIdChanged();
4611    partial void OnJobNameChanging(string value);
4612    partial void OnJobNameChanged();
4613    partial void OnUserNameChanging(string value);
4614    partial void OnUserNameChanged();
4615    partial void OnDateCreatedChanging(System.DateTime value);
4616    partial void OnDateCreatedChanged();
4617    partial void OnTotalTasksChanging(int value);
4618    partial void OnTotalTasksChanged();
4619    partial void OnCompletedTasksChanging(int value);
4620    partial void OnCompletedTasksChanged();
4621    partial void OnDateCompletedChanging(System.Nullable<System.DateTime> value);
4622    partial void OnDateCompletedChanged();
4623    #endregion
4624   
4625    public DimJob()
4626    {
4627      this._FactTasks = new EntitySet<FactTask>(new Action<FactTask>(this.attach_FactTasks), new Action<FactTask>(this.detach_FactTasks));
4628      OnCreated();
4629    }
4630   
4631    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
4632    public System.Guid JobId
4633    {
4634      get
4635      {
4636        return this._JobId;
4637      }
4638      set
4639      {
4640        if ((this._JobId != value))
4641        {
4642          this.OnJobIdChanging(value);
4643          this.SendPropertyChanging();
4644          this._JobId = value;
4645          this.SendPropertyChanged("JobId");
4646          this.OnJobIdChanged();
4647        }
4648      }
4649    }
4650   
4651    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL")]
4652    public System.Guid UserId
4653    {
4654      get
4655      {
4656        return this._UserId;
4657      }
4658      set
4659      {
4660        if ((this._UserId != value))
4661        {
4662          this.OnUserIdChanging(value);
4663          this.SendPropertyChanging();
4664          this._UserId = value;
4665          this.SendPropertyChanged("UserId");
4666          this.OnUserIdChanged();
4667        }
4668      }
4669    }
4670   
4671    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobName", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
4672    public string JobName
4673    {
4674      get
4675      {
4676        return this._JobName;
4677      }
4678      set
4679      {
4680        if ((this._JobName != value))
4681        {
4682          this.OnJobNameChanging(value);
4683          this.SendPropertyChanging();
4684          this._JobName = value;
4685          this.SendPropertyChanged("JobName");
4686          this.OnJobNameChanged();
4687        }
4688      }
4689    }
4690   
4691    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserName", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
4692    public string UserName
4693    {
4694      get
4695      {
4696        return this._UserName;
4697      }
4698      set
4699      {
4700        if ((this._UserName != value))
4701        {
4702          this.OnUserNameChanging(value);
4703          this.SendPropertyChanging();
4704          this._UserName = value;
4705          this.SendPropertyChanged("UserName");
4706          this.OnUserNameChanged();
4707        }
4708      }
4709    }
4710   
4711    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateCreated", DbType="DateTime NOT NULL")]
4712    public System.DateTime DateCreated
4713    {
4714      get
4715      {
4716        return this._DateCreated;
4717      }
4718      set
4719      {
4720        if ((this._DateCreated != value))
4721        {
4722          this.OnDateCreatedChanging(value);
4723          this.SendPropertyChanging();
4724          this._DateCreated = value;
4725          this.SendPropertyChanged("DateCreated");
4726          this.OnDateCreatedChanged();
4727        }
4728      }
4729    }
4730   
4731    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTasks", DbType="INT NOT NULL")]
4732    public int TotalTasks
4733    {
4734      get
4735      {
4736        return this._TotalTasks;
4737      }
4738      set
4739      {
4740        if ((this._TotalTasks != value))
4741        {
4742          this.OnTotalTasksChanging(value);
4743          this.SendPropertyChanging();
4744          this._TotalTasks = value;
4745          this.SendPropertyChanged("TotalTasks");
4746          this.OnTotalTasksChanged();
4747        }
4748      }
4749    }
4750   
4751    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CompletedTasks", DbType="INT NOT NULL")]
4752    public int CompletedTasks
4753    {
4754      get
4755      {
4756        return this._CompletedTasks;
4757      }
4758      set
4759      {
4760        if ((this._CompletedTasks != value))
4761        {
4762          this.OnCompletedTasksChanging(value);
4763          this.SendPropertyChanging();
4764          this._CompletedTasks = value;
4765          this.SendPropertyChanged("CompletedTasks");
4766          this.OnCompletedTasksChanged();
4767        }
4768      }
4769    }
4770   
4771    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateCompleted", DbType="DateTime NULL")]
4772    public System.Nullable<System.DateTime> DateCompleted
4773    {
4774      get
4775      {
4776        return this._DateCompleted;
4777      }
4778      set
4779      {
4780        if ((this._DateCompleted != value))
4781        {
4782          this.OnDateCompletedChanging(value);
4783          this.SendPropertyChanging();
4784          this._DateCompleted = value;
4785          this.SendPropertyChanged("DateCompleted");
4786          this.OnDateCompletedChanged();
4787        }
4788      }
4789    }
4790   
4791    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimJob_FactTask", Storage="_FactTasks", ThisKey="JobId", OtherKey="JobId")]
4792    public EntitySet<FactTask> FactTasks
4793    {
4794      get
4795      {
4796        return this._FactTasks;
4797      }
4798      set
4799      {
4800        this._FactTasks.Assign(value);
4801      }
4802    }
4803   
4804    public event PropertyChangingEventHandler PropertyChanging;
4805   
4806    public event PropertyChangedEventHandler PropertyChanged;
4807   
4808    protected virtual void SendPropertyChanging()
4809    {
4810      if ((this.PropertyChanging != null))
4811      {
4812        this.PropertyChanging(this, emptyChangingEventArgs);
4813      }
4814    }
4815   
4816    protected virtual void SendPropertyChanged(String propertyName)
4817    {
4818      if ((this.PropertyChanged != null))
4819      {
4820        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
4821      }
4822    }
4823   
4824    private void attach_FactTasks(FactTask entity)
4825    {
4826      this.SendPropertyChanging();
4827      entity.DimJob = this;
4828    }
4829   
4830    private void detach_FactTasks(FactTask entity)
4831    {
4832      this.SendPropertyChanging();
4833      entity.DimJob = null;
4834    }
4835  }
4836 
4837  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimTime")]
4838  public partial class DimTime : INotifyPropertyChanging, INotifyPropertyChanged
4839  {
4840   
4841    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
4842   
4843    private System.DateTime _Time;
4844   
4845    private System.DateTime _Hour;
4846   
4847    private System.DateTime _Day;
4848   
4849    private System.DateTime _Month;
4850   
4851    private System.DateTime _Year;
4852   
4853    private System.DateTime _Minute;
4854   
4855    private EntitySet<FactClientInfo> _FactClientInfos;
4856   
4857    #region Extensibility Method Definitions
4858    partial void OnLoaded();
4859    partial void OnValidate(System.Data.Linq.ChangeAction action);
4860    partial void OnCreated();
4861    partial void OnTimeChanging(System.DateTime value);
4862    partial void OnTimeChanged();
4863    partial void OnHourChanging(System.DateTime value);
4864    partial void OnHourChanged();
4865    partial void OnDayChanging(System.DateTime value);
4866    partial void OnDayChanged();
4867    partial void OnMonthChanging(System.DateTime value);
4868    partial void OnMonthChanged();
4869    partial void OnYearChanging(System.DateTime value);
4870    partial void OnYearChanged();
4871    partial void OnMinuteChanging(System.DateTime value);
4872    partial void OnMinuteChanged();
4873    #endregion
4874   
4875    public DimTime()
4876    {
4877      this._FactClientInfos = new EntitySet<FactClientInfo>(new Action<FactClientInfo>(this.attach_FactClientInfos), new Action<FactClientInfo>(this.detach_FactClientInfos));
4878      OnCreated();
4879    }
4880   
4881    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Time", DbType="DateTime NOT NULL", IsPrimaryKey=true)]
4882    public System.DateTime Time
4883    {
4884      get
4885      {
4886        return this._Time;
4887      }
4888      set
4889      {
4890        if ((this._Time != value))
4891        {
4892          this.OnTimeChanging(value);
4893          this.SendPropertyChanging();
4894          this._Time = value;
4895          this.SendPropertyChanged("Time");
4896          this.OnTimeChanged();
4897        }
4898      }
4899    }
4900   
4901    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Hour", DbType="DateTime NOT NULL")]
4902    public System.DateTime Hour
4903    {
4904      get
4905      {
4906        return this._Hour;
4907      }
4908      set
4909      {
4910        if ((this._Hour != value))
4911        {
4912          this.OnHourChanging(value);
4913          this.SendPropertyChanging();
4914          this._Hour = value;
4915          this.SendPropertyChanged("Hour");
4916          this.OnHourChanged();
4917        }
4918      }
4919    }
4920   
4921    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Day", DbType="Date NOT NULL")]
4922    public System.DateTime Day
4923    {
4924      get
4925      {
4926        return this._Day;
4927      }
4928      set
4929      {
4930        if ((this._Day != value))
4931        {
4932          this.OnDayChanging(value);
4933          this.SendPropertyChanging();
4934          this._Day = value;
4935          this.SendPropertyChanged("Day");
4936          this.OnDayChanged();
4937        }
4938      }
4939    }
4940   
4941    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Month", DbType="Date NOT NULL")]
4942    public System.DateTime Month
4943    {
4944      get
4945      {
4946        return this._Month;
4947      }
4948      set
4949      {
4950        if ((this._Month != value))
4951        {
4952          this.OnMonthChanging(value);
4953          this.SendPropertyChanging();
4954          this._Month = value;
4955          this.SendPropertyChanged("Month");
4956          this.OnMonthChanged();
4957        }
4958      }
4959    }
4960   
4961    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Year", DbType="Date NOT NULL")]
4962    public System.DateTime Year
4963    {
4964      get
4965      {
4966        return this._Year;
4967      }
4968      set
4969      {
4970        if ((this._Year != value))
4971        {
4972          this.OnYearChanging(value);
4973          this.SendPropertyChanging();
4974          this._Year = value;
4975          this.SendPropertyChanged("Year");
4976          this.OnYearChanged();
4977        }
4978      }
4979    }
4980   
4981    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Minute")]
4982    public System.DateTime Minute
4983    {
4984      get
4985      {
4986        return this._Minute;
4987      }
4988      set
4989      {
4990        if ((this._Minute != value))
4991        {
4992          this.OnMinuteChanging(value);
4993          this.SendPropertyChanging();
4994          this._Minute = value;
4995          this.SendPropertyChanged("Minute");
4996          this.OnMinuteChanged();
4997        }
4998      }
4999    }
5000   
5001    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimTime_FactClientInfo", Storage="_FactClientInfos", ThisKey="Time", OtherKey="Time")]
5002    public EntitySet<FactClientInfo> FactClientInfos
5003    {
5004      get
5005      {
5006        return this._FactClientInfos;
5007      }
5008      set
5009      {
5010        this._FactClientInfos.Assign(value);
5011      }
5012    }
5013   
5014    public event PropertyChangingEventHandler PropertyChanging;
5015   
5016    public event PropertyChangedEventHandler PropertyChanged;
5017   
5018    protected virtual void SendPropertyChanging()
5019    {
5020      if ((this.PropertyChanging != null))
5021      {
5022        this.PropertyChanging(this, emptyChangingEventArgs);
5023      }
5024    }
5025   
5026    protected virtual void SendPropertyChanged(String propertyName)
5027    {
5028      if ((this.PropertyChanged != null))
5029      {
5030        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
5031      }
5032    }
5033   
5034    private void attach_FactClientInfos(FactClientInfo entity)
5035    {
5036      this.SendPropertyChanging();
5037      entity.DimTime = this;
5038    }
5039   
5040    private void detach_FactClientInfos(FactClientInfo entity)
5041    {
5042      this.SendPropertyChanging();
5043      entity.DimTime = null;
5044    }
5045  }
5046 
5047  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].DimUser")]
5048  public partial class DimUser : INotifyPropertyChanging, INotifyPropertyChanged
5049  {
5050   
5051    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
5052   
5053    private System.Guid _UserId;
5054   
5055    private string _Name;
5056   
5057    private EntitySet<FactClientInfo> _FactClientInfos;
5058   
5059    #region Extensibility Method Definitions
5060    partial void OnLoaded();
5061    partial void OnValidate(System.Data.Linq.ChangeAction action);
5062    partial void OnCreated();
5063    partial void OnUserIdChanging(System.Guid value);
5064    partial void OnUserIdChanged();
5065    partial void OnNameChanging(string value);
5066    partial void OnNameChanged();
5067    #endregion
5068   
5069    public DimUser()
5070    {
5071      this._FactClientInfos = new EntitySet<FactClientInfo>(new Action<FactClientInfo>(this.attach_FactClientInfos), new Action<FactClientInfo>(this.detach_FactClientInfos));
5072      OnCreated();
5073    }
5074   
5075    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
5076    public System.Guid UserId
5077    {
5078      get
5079      {
5080        return this._UserId;
5081      }
5082      set
5083      {
5084        if ((this._UserId != value))
5085        {
5086          this.OnUserIdChanging(value);
5087          this.SendPropertyChanging();
5088          this._UserId = value;
5089          this.SendPropertyChanged("UserId");
5090          this.OnUserIdChanged();
5091        }
5092      }
5093    }
5094   
5095    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX) NOT NULL", CanBeNull=false)]
5096    public string Name
5097    {
5098      get
5099      {
5100        return this._Name;
5101      }
5102      set
5103      {
5104        if ((this._Name != value))
5105        {
5106          this.OnNameChanging(value);
5107          this.SendPropertyChanging();
5108          this._Name = value;
5109          this.SendPropertyChanged("Name");
5110          this.OnNameChanged();
5111        }
5112      }
5113    }
5114   
5115    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimUser_FactClientInfo", Storage="_FactClientInfos", ThisKey="UserId", OtherKey="UserId")]
5116    public EntitySet<FactClientInfo> FactClientInfos
5117    {
5118      get
5119      {
5120        return this._FactClientInfos;
5121      }
5122      set
5123      {
5124        this._FactClientInfos.Assign(value);
5125      }
5126    }
5127   
5128    public event PropertyChangingEventHandler PropertyChanging;
5129   
5130    public event PropertyChangedEventHandler PropertyChanged;
5131   
5132    protected virtual void SendPropertyChanging()
5133    {
5134      if ((this.PropertyChanging != null))
5135      {
5136        this.PropertyChanging(this, emptyChangingEventArgs);
5137      }
5138    }
5139   
5140    protected virtual void SendPropertyChanged(String propertyName)
5141    {
5142      if ((this.PropertyChanged != null))
5143      {
5144        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
5145      }
5146    }
5147   
5148    private void attach_FactClientInfos(FactClientInfo entity)
5149    {
5150      this.SendPropertyChanging();
5151      entity.DimUser = this;
5152    }
5153   
5154    private void detach_FactClientInfos(FactClientInfo entity)
5155    {
5156      this.SendPropertyChanging();
5157      entity.DimUser = null;
5158    }
5159  }
5160 
5161  [global::System.Data.Linq.Mapping.TableAttribute(Name="[statistics].FactClientInfo")]
5162  public partial class FactClientInfo : INotifyPropertyChanging, INotifyPropertyChanged
5163  {
5164   
5165    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
5166   
5167    private System.Guid _ClientId;
5168   
5169    private System.DateTime _Time;
5170   
5171    private System.Guid _UserId;
5172   
5173    private int _NumUsedCores;
5174   
5175    private int _NumTotalCores;
5176   
5177    private int _UsedMemory;
5178   
5179    private int _TotalMemory;
5180   
5181    private double _CpuUtilization;
5182   
5183    private long _TotalTimeIdle;
5184   
5185    private long _TotalTimeOffline;
5186   
5187    private long _TotalTimeUnavailable;
5188   
5189    private global::HeuristicLab.Services.Hive.DataAccess.SlaveState _SlaveState;
5190   
5191    private bool _IsAllowedToCalculate;
5192   
5193    private EntityRef<DimClient> _DimClient;
5194   
5195    private EntityRef<DimTime> _DimTime;
5196   
5197    private EntityRef<DimUser> _DimUser;
5198   
5199    #region Extensibility Method Definitions
5200    partial void OnLoaded();
5201    partial void OnValidate(System.Data.Linq.ChangeAction action);
5202    partial void OnCreated();
5203    partial void OnClientIdChanging(System.Guid value);
5204    partial void OnClientIdChanged();
5205    partial void OnTimeChanging(System.DateTime value);
5206    partial void OnTimeChanged();
5207    partial void OnUserIdChanging(System.Guid value);
5208    partial void OnUserIdChanged();
5209    partial void OnNumUsedCoresChanging(int value);
5210    partial void OnNumUsedCoresChanged();
5211    partial void OnNumTotalCoresChanging(int value);
5212    partial void OnNumTotalCoresChanged();
5213    partial void OnUsedMemoryChanging(int value);
5214    partial void OnUsedMemoryChanged();
5215    partial void OnTotalMemoryChanging(int value);
5216    partial void OnTotalMemoryChanged();
5217    partial void OnCpuUtilizationChanging(double value);
5218    partial void OnCpuUtilizationChanged();
5219    partial void OnIdleTimeChanging(long value);
5220    partial void OnIdleTimeChanged();
5221    partial void OnOfflineTimeChanging(long value);
5222    partial void OnOfflineTimeChanged();
5223    partial void OnUnavailableTimeChanging(long value);
5224    partial void OnUnavailableTimeChanged();
5225    partial void OnSlaveStateChanging(global::HeuristicLab.Services.Hive.DataAccess.SlaveState value);
5226    partial void OnSlaveStateChanged();
5227    partial void OnIsAllowedToCalculateChanging(bool value);
5228    partial void OnIsAllowedToCalculateChanged();
5229    #endregion
5230   
5231    public FactClientInfo()
5232    {
5233      this._DimClient = default(EntityRef<DimClient>);
5234      this._DimTime = default(EntityRef<DimTime>);
5235      this._DimUser = default(EntityRef<DimUser>);
5236      OnCreated();
5237    }
5238   
5239    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ClientId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
5240    public System.Guid ClientId
5241    {
5242      get
5243      {
5244        return this._ClientId;
5245      }
5246      set
5247      {
5248        if ((this._ClientId != value))
5249        {
5250          if (this._DimClient.HasLoadedOrAssignedValue)
5251          {
5252            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
5253          }
5254          this.OnClientIdChanging(value);
5255          this.SendPropertyChanging();
5256          this._ClientId = value;
5257          this.SendPropertyChanged("ClientId");
5258          this.OnClientIdChanged();
5259        }
5260      }
5261    }
5262   
5263    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Time", DbType="DateTime NOT NULL", IsPrimaryKey=true)]
5264    public System.DateTime Time
5265    {
5266      get
5267      {
5268        return this._Time;
5269      }
5270      set
5271      {
5272        if ((this._Time != value))
5273        {
5274          if (this._DimTime.HasLoadedOrAssignedValue)
5275          {
5276            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
5277          }
5278          this.OnTimeChanging(value);
5279          this.SendPropertyChanging();
5280          this._Time = value;
5281          this.SendPropertyChanged("Time");
5282          this.OnTimeChanged();
5283        }
5284      }
5285    }
5286   
5287    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier NULL", IsPrimaryKey=true)]
5288    public System.Guid UserId
5289    {
5290      get
5291      {
5292        return this._UserId;
5293      }
5294      set
5295      {
5296        if ((this._UserId != value))
5297        {
5298          if (this._DimUser.HasLoadedOrAssignedValue)
5299          {
5300            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
5301          }
5302          this.OnUserIdChanging(value);
5303          this.SendPropertyChanging();
5304          this._UserId = value;
5305          this.SendPropertyChanged("UserId");
5306          this.OnUserIdChanged();
5307        }
5308      }
5309    }
5310   
5311    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumUsedCores", DbType="Int NOT NULL")]
5312    public int NumUsedCores
5313    {
5314      get
5315      {
5316        return this._NumUsedCores;
5317      }
5318      set
5319      {
5320        if ((this._NumUsedCores != value))
5321        {
5322          this.OnNumUsedCoresChanging(value);
5323          this.SendPropertyChanging();
5324          this._NumUsedCores = value;
5325          this.SendPropertyChanged("NumUsedCores");
5326          this.OnNumUsedCoresChanged();
5327        }
5328      }
5329    }
5330   
5331    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumTotalCores", DbType="Int NOT NULL")]
5332    public int NumTotalCores
5333    {
5334      get
5335      {
5336        return this._NumTotalCores;
5337      }
5338      set
5339      {
5340        if ((this._NumTotalCores != value))
5341        {
5342          this.OnNumTotalCoresChanging(value);
5343          this.SendPropertyChanging();
5344          this._NumTotalCores = value;
5345          this.SendPropertyChanged("NumTotalCores");
5346          this.OnNumTotalCoresChanged();
5347        }
5348      }
5349    }
5350   
5351    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UsedMemory", DbType="Int NOT NULL")]
5352    public int UsedMemory
5353    {
5354      get
5355      {
5356        return this._UsedMemory;
5357      }
5358      set
5359      {
5360        if ((this._UsedMemory != value))
5361        {
5362          this.OnUsedMemoryChanging(value);
5363          this.SendPropertyChanging();
5364          this._UsedMemory = value;
5365          this.SendPropertyChanged("UsedMemory");
5366          this.OnUsedMemoryChanged();
5367        }
5368      }
5369    }
5370   
5371    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalMemory", DbType="Int NOT NULL")]
5372    public int TotalMemory
5373    {
5374      get
5375      {
5376        return this._TotalMemory;
5377      }
5378      set
5379      {
5380        if ((this._TotalMemory != value))
5381        {
5382          this.OnTotalMemoryChanging(value);
5383          this.SendPropertyChanging();
5384          this._TotalMemory = value;
5385          this.SendPropertyChanged("TotalMemory");
5386          this.OnTotalMemoryChanged();
5387        }
5388      }
5389    }
5390   
5391    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CpuUtilization", DbType="Float NOT NULL")]
5392    public double CpuUtilization
5393    {
5394      get
5395      {
5396        return this._CpuUtilization;
5397      }
5398      set
5399      {
5400        if ((this._CpuUtilization != value))
5401        {
5402          this.OnCpuUtilizationChanging(value);
5403          this.SendPropertyChanging();
5404          this._CpuUtilization = value;
5405          this.SendPropertyChanged("CpuUtilization");
5406          this.OnCpuUtilizationChanged();
5407        }
5408      }
5409    }
5410   
5411    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTimeIdle", DbType="INT NOT NULL")]
5412    public long IdleTime
5413    {
5414      get
5415      {
5416        return this._TotalTimeIdle;
5417      }
5418      set
5419      {
5420        if ((this._TotalTimeIdle != value))
5421        {
5422          this.OnIdleTimeChanging(value);
5423          this.SendPropertyChanging();
5424          this._TotalTimeIdle = value;
5425          this.SendPropertyChanged("IdleTime");
5426          this.OnIdleTimeChanged();
5427        }
5428      }
5429    }
5430   
5431    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTimeOffline", DbType="INT NOT NULL")]
5432    public long OfflineTime
5433    {
5434      get
5435      {
5436        return this._TotalTimeOffline;
5437      }
5438      set
5439      {
5440        if ((this._TotalTimeOffline != value))
5441        {
5442          this.OnOfflineTimeChanging(value);
5443          this.SendPropertyChanging();
5444          this._TotalTimeOffline = value;
5445          this.SendPropertyChanged("OfflineTime");
5446          this.OnOfflineTimeChanged();
5447        }
5448      }
5449    }
5450   
5451    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_TotalTimeUnavailable", DbType="INT NOT NULL")]
5452    public long UnavailableTime
5453    {
5454      get
5455      {
5456        return this._TotalTimeUnavailable;
5457      }
5458      set
5459      {
5460        if ((this._TotalTimeUnavailable != value))
5461        {
5462          this.OnUnavailableTimeChanging(value);
5463          this.SendPropertyChanging();
5464          this._TotalTimeUnavailable = value;
5465          this.SendPropertyChanged("UnavailableTime");
5466          this.OnUnavailableTimeChanged();
5467        }
5468      }
5469    }
5470   
5471    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_SlaveState", DbType="VarChar(15)", CanBeNull=false)]
5472    public global::HeuristicLab.Services.Hive.DataAccess.SlaveState SlaveState
5473    {
5474      get
5475      {
5476        return this._SlaveState;
5477      }
5478      set
5479      {
5480        if ((this._SlaveState != value))
5481        {
5482          this.OnSlaveStateChanging(value);
5483          this.SendPropertyChanging();
5484          this._SlaveState = value;
5485          this.SendPropertyChanged("SlaveState");
5486          this.OnSlaveStateChanged();
5487        }
5488      }
5489    }
5490   
5491    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsAllowedToCalculate", DbType="BIT")]
5492    public bool IsAllowedToCalculate
5493    {
5494      get
5495      {
5496        return this._IsAllowedToCalculate;
5497      }
5498      set
5499      {
5500        if ((this._IsAllowedToCalculate != value))
5501        {
5502          this.OnIsAllowedToCalculateChanging(value);
5503          this.SendPropertyChanging();
5504          this._IsAllowedToCalculate = value;
5505          this.SendPropertyChanged("IsAllowedToCalculate");
5506          this.OnIsAllowedToCalculateChanged();
5507        }
5508      }
5509    }
5510   
5511    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimClient_FactClientInfo", Storage="_DimClient", ThisKey="ClientId", OtherKey="Id", IsForeignKey=true)]
5512    public DimClient DimClient
5513    {
5514      get
5515      {
5516        return this._DimClient.Entity;
5517      }
5518      set
5519      {
5520        DimClient previousValue = this._DimClient.Entity;
5521        if (((previousValue != value)
5522              || (this._DimClient.HasLoadedOrAssignedValue == false)))
5523        {
5524          this.SendPropertyChanging();
5525          if ((previousValue != null))
5526          {
5527            this._DimClient.Entity = null;
5528            previousValue.FactClientInfos.Remove(this);
5529          }
5530          this._DimClient.Entity = value;
5531          if ((value != null))
5532          {
5533            value.FactClientInfos.Add(this);
5534            this._ClientId = value.Id;
5535          }
5536          else
5537          {
5538            this._ClientId = default(System.Guid);
5539          }
5540          this.SendPropertyChanged("DimClient");
5541        }
5542      }
5543    }
5544   
5545    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimTime_FactClientInfo", Storage="_DimTime", ThisKey="Time", OtherKey="Time", IsForeignKey=true)]
5546    public DimTime DimTime
5547    {
5548      get
5549      {
5550        return this._DimTime.Entity;
5551      }
5552      set
5553      {
5554        DimTime previousValue = this._DimTime.Entity;
5555        if (((previousValue != value)
5556              || (this._DimTime.HasLoadedOrAssignedValue == false)))
5557        {
5558          this.SendPropertyChanging();
5559          if ((previousValue != null))
5560          {
5561            this._DimTime.Entity = null;
5562            previousValue.FactClientInfos.Remove(this);
5563          }
5564          this._DimTime.Entity = value;
5565          if ((value != null))
5566          {
5567            value.FactClientInfos.Add(this);
5568            this._Time = value.Time;
5569          }
5570          else
5571          {
5572            this._Time = default(System.DateTime);
5573          }
5574          this.SendPropertyChanged("DimTime");
5575        }
5576      }
5577    }
5578   
5579    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="DimUser_FactClientInfo", Storage="_DimUser", ThisKey="UserId", OtherKey="UserId", IsForeignKey=true)]
5580    public DimUser DimUser
5581    {
5582      get
5583      {
5584        return this._DimUser.Entity;
5585      }
5586      set
5587      {
5588        DimUser previousValue = this._DimUser.Entity;
5589        if (((previousValue != value)
5590              || (this._DimUser.HasLoadedOrAssignedValue == false)))
5591        {
5592          this.SendPropertyChanging();
5593          if ((previousValue != null))
5594          {
5595            this._DimUser.Entity = null;
5596            previousValue.FactClientInfos.Remove(this);
5597          }
5598          this._DimUser.Entity = value;
5599          if ((value != null))
5600          {
5601            value.FactClientInfos.Add(this);
5602            this._UserId = value.UserId;
5603          }
5604          else
5605          {
5606            this._UserId = default(System.Guid);
5607          }
5608          this.SendPropertyChanged("DimUser");
5609        }
5610      }
5611    }
5612   
5613    public event PropertyChangingEventHandler PropertyChanging;
5614   
5615    public event PropertyChangedEventHandler PropertyChanged;
5616   
5617    protected virtual void SendPropertyChanging()
5618    {
5619      if ((this.PropertyChanging != null))
5620      {
5621        this.PropertyChanging(this, emptyChangingEventArgs);
5622      }
5623    }
5624   
5625    protected virtual void SendPropertyChanged(String propertyName)
5626    {
5627      if ((this.PropertyChanged != null))
5628      {
5629        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
5630      }
5631    }
5632  }
5633}
5634#pragma warning restore 1591
Note: See TracBrowser for help on using the repository browser.