Free cookie consent management tool by TermsFeed Policy Generator

source: branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.DataAccess/3.4/HiveDataContext.designer.cs @ 6362

Last change on this file since 6362 was 6267, checked in by cneumuel, 14 years ago

#1233

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