Free cookie consent management tool by TermsFeed Policy Generator

source: branches/HLScript/HeuristicLab.Services.Hive.DataAccess/3.3/HiveDataContext.designer.cs @ 12955

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

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