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 @ 5708

Last change on this file since 5708 was 5593, checked in by cneumuel, 14 years ago

#1233

  • changed the way lifecycle methods are called. The new service method TriggerLifecycle checks when the latest cleanup was made and performs one (if necessary). This can also be called by an external program (like a windows task)
  • robustified logging
File size: 87.1 KB
Line 
1#pragma warning disable 1591
2//------------------------------------------------------------------------------
3// <auto-generated>
4//     This code was generated by a tool.
5//     Runtime Version:4.0.30319.208
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    #endregion
70   
71    public HiveDataContext(string connection) :
72        base(connection, mappingSource)
73    {
74      OnCreated();
75    }
76   
77    public HiveDataContext(System.Data.IDbConnection connection) :
78        base(connection, mappingSource)
79    {
80      OnCreated();
81    }
82   
83    public HiveDataContext(string connection, System.Data.Linq.Mapping.MappingSource mappingSource) :
84        base(connection, mappingSource)
85    {
86      OnCreated();
87    }
88   
89    public HiveDataContext(System.Data.IDbConnection connection, System.Data.Linq.Mapping.MappingSource mappingSource) :
90        base(connection, mappingSource)
91    {
92      OnCreated();
93    }
94   
95    public System.Data.Linq.Table<AssignedResource> AssignedResources
96    {
97      get
98      {
99        return this.GetTable<AssignedResource>();
100      }
101    }
102   
103    public System.Data.Linq.Table<Plugin> Plugins
104    {
105      get
106      {
107        return this.GetTable<Plugin>();
108      }
109    }
110   
111    public System.Data.Linq.Table<RequiredPlugin> RequiredPlugins
112    {
113      get
114      {
115        return this.GetTable<RequiredPlugin>();
116      }
117    }
118   
119    public System.Data.Linq.Table<Resource> Resources
120    {
121      get
122      {
123        return this.GetTable<Resource>();
124      }
125    }
126   
127    public System.Data.Linq.Table<Job> Jobs
128    {
129      get
130      {
131        return this.GetTable<Job>();
132      }
133    }
134   
135    public System.Data.Linq.Table<UptimeCalendar> UptimeCalendars
136    {
137      get
138      {
139        return this.GetTable<UptimeCalendar>();
140      }
141    }
142   
143    public System.Data.Linq.Table<HiveExperiment> HiveExperiments
144    {
145      get
146      {
147        return this.GetTable<HiveExperiment>();
148      }
149    }
150   
151    public System.Data.Linq.Table<JobData> JobDatas
152    {
153      get
154      {
155        return this.GetTable<JobData>();
156      }
157    }
158   
159    public System.Data.Linq.Table<PluginData> PluginDatas
160    {
161      get
162      {
163        return this.GetTable<PluginData>();
164      }
165    }
166   
167    public System.Data.Linq.Table<StateLog> StateLogs
168    {
169      get
170      {
171        return this.GetTable<StateLog>();
172      }
173    }
174   
175    public System.Data.Linq.Table<HiveExperimentPermission> HiveExperimentPermissions
176    {
177      get
178      {
179        return this.GetTable<HiveExperimentPermission>();
180      }
181    }
182   
183    public System.Data.Linq.Table<Lifecycle> Lifecycles
184    {
185      get
186      {
187        return this.GetTable<Lifecycle>();
188      }
189    }
190  }
191 
192  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.AssignedResources")]
193  public partial class AssignedResource : INotifyPropertyChanging, INotifyPropertyChanged
194  {
195   
196    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
197   
198    private System.Guid _ResourceId;
199   
200    private System.Guid _JobId;
201   
202    private System.Guid _AssignedRessourcesId;
203   
204    private EntityRef<Resource> _Resource;
205   
206    private EntityRef<Job> _Job;
207   
208    #region Extensibility Method Definitions
209    partial void OnLoaded();
210    partial void OnValidate(System.Data.Linq.ChangeAction action);
211    partial void OnCreated();
212    partial void OnResourceIdChanging(System.Guid value);
213    partial void OnResourceIdChanged();
214    partial void OnJobIdChanging(System.Guid value);
215    partial void OnJobIdChanged();
216    partial void OnAssignedRessourcesIdChanging(System.Guid value);
217    partial void OnAssignedRessourcesIdChanged();
218    #endregion
219   
220    public AssignedResource()
221    {
222      this._Resource = default(EntityRef<Resource>);
223      this._Job = default(EntityRef<Job>);
224      OnCreated();
225    }
226   
227    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier NOT NULL")]
228    public System.Guid ResourceId
229    {
230      get
231      {
232        return this._ResourceId;
233      }
234      set
235      {
236        if ((this._ResourceId != value))
237        {
238          if (this._Resource.HasLoadedOrAssignedValue)
239          {
240            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
241          }
242          this.OnResourceIdChanging(value);
243          this.SendPropertyChanging();
244          this._ResourceId = value;
245          this.SendPropertyChanged("ResourceId");
246          this.OnResourceIdChanged();
247        }
248      }
249    }
250   
251    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL")]
252    public System.Guid JobId
253    {
254      get
255      {
256        return this._JobId;
257      }
258      set
259      {
260        if ((this._JobId != value))
261        {
262          if (this._Job.HasLoadedOrAssignedValue)
263          {
264            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
265          }
266          this.OnJobIdChanging(value);
267          this.SendPropertyChanging();
268          this._JobId = value;
269          this.SendPropertyChanged("JobId");
270          this.OnJobIdChanged();
271        }
272      }
273    }
274   
275    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_AssignedRessourcesId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
276    public System.Guid AssignedRessourcesId
277    {
278      get
279      {
280        return this._AssignedRessourcesId;
281      }
282      set
283      {
284        if ((this._AssignedRessourcesId != value))
285        {
286          this.OnAssignedRessourcesIdChanging(value);
287          this.SendPropertyChanging();
288          this._AssignedRessourcesId = value;
289          this.SendPropertyChanged("AssignedRessourcesId");
290          this.OnAssignedRessourcesIdChanged();
291        }
292      }
293    }
294   
295    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_AssignedResource", Storage="_Resource", ThisKey="ResourceId", OtherKey="ResourceId", IsForeignKey=true, DeleteRule="CASCADE")]
296    public Resource Resource
297    {
298      get
299      {
300        return this._Resource.Entity;
301      }
302      set
303      {
304        Resource previousValue = this._Resource.Entity;
305        if (((previousValue != value)
306              || (this._Resource.HasLoadedOrAssignedValue == false)))
307        {
308          this.SendPropertyChanging();
309          if ((previousValue != null))
310          {
311            this._Resource.Entity = null;
312            previousValue.AssignedResources.Remove(this);
313          }
314          this._Resource.Entity = value;
315          if ((value != null))
316          {
317            value.AssignedResources.Add(this);
318            this._ResourceId = value.ResourceId;
319          }
320          else
321          {
322            this._ResourceId = default(System.Guid);
323          }
324          this.SendPropertyChanged("Resource");
325        }
326      }
327    }
328   
329    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_AssignedResource", Storage="_Job", ThisKey="JobId", OtherKey="JobId", IsForeignKey=true, DeleteRule="CASCADE")]
330    public Job Job
331    {
332      get
333      {
334        return this._Job.Entity;
335      }
336      set
337      {
338        Job previousValue = this._Job.Entity;
339        if (((previousValue != value)
340              || (this._Job.HasLoadedOrAssignedValue == false)))
341        {
342          this.SendPropertyChanging();
343          if ((previousValue != null))
344          {
345            this._Job.Entity = null;
346            previousValue.AssignedResources.Remove(this);
347          }
348          this._Job.Entity = value;
349          if ((value != null))
350          {
351            value.AssignedResources.Add(this);
352            this._JobId = value.JobId;
353          }
354          else
355          {
356            this._JobId = default(System.Guid);
357          }
358          this.SendPropertyChanged("Job");
359        }
360      }
361    }
362   
363    public event PropertyChangingEventHandler PropertyChanging;
364   
365    public event PropertyChangedEventHandler PropertyChanged;
366   
367    protected virtual void SendPropertyChanging()
368    {
369      if ((this.PropertyChanging != null))
370      {
371        this.PropertyChanging(this, emptyChangingEventArgs);
372      }
373    }
374   
375    protected virtual void SendPropertyChanged(String propertyName)
376    {
377      if ((this.PropertyChanged != null))
378      {
379        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
380      }
381    }
382  }
383 
384  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Plugin")]
385  public partial class Plugin : INotifyPropertyChanging, INotifyPropertyChanged
386  {
387   
388    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
389   
390    private System.Guid _PluginId;
391   
392    private string _Name;
393   
394    private string _Version;
395   
396    private bool _IsLocal;
397   
398    private System.Guid _UserId;
399   
400    private System.DateTime _DateCreated;
401   
402    private EntitySet<RequiredPlugin> _RequiredPlugins;
403   
404    private EntitySet<PluginData> _PluginData;
405   
406    #region Extensibility Method Definitions
407    partial void OnLoaded();
408    partial void OnValidate(System.Data.Linq.ChangeAction action);
409    partial void OnCreated();
410    partial void OnPluginIdChanging(System.Guid value);
411    partial void OnPluginIdChanged();
412    partial void OnNameChanging(string value);
413    partial void OnNameChanged();
414    partial void OnVersionChanging(string value);
415    partial void OnVersionChanged();
416    partial void OnIsLocalChanging(bool value);
417    partial void OnIsLocalChanged();
418    partial void OnUserIdChanging(System.Guid value);
419    partial void OnUserIdChanged();
420    partial void OnDateCreatedChanging(System.DateTime value);
421    partial void OnDateCreatedChanged();
422    #endregion
423   
424    public Plugin()
425    {
426      this._RequiredPlugins = new EntitySet<RequiredPlugin>(new Action<RequiredPlugin>(this.attach_RequiredPlugins), new Action<RequiredPlugin>(this.detach_RequiredPlugins));
427      this._PluginData = new EntitySet<PluginData>(new Action<PluginData>(this.attach_PluginData), new Action<PluginData>(this.detach_PluginData));
428      OnCreated();
429    }
430   
431    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
432    public System.Guid PluginId
433    {
434      get
435      {
436        return this._PluginId;
437      }
438      set
439      {
440        if ((this._PluginId != value))
441        {
442          this.OnPluginIdChanging(value);
443          this.SendPropertyChanging();
444          this._PluginId = value;
445          this.SendPropertyChanged("PluginId");
446          this.OnPluginIdChanged();
447        }
448      }
449    }
450   
451    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX)", CanBeNull=false)]
452    public string Name
453    {
454      get
455      {
456        return this._Name;
457      }
458      set
459      {
460        if ((this._Name != value))
461        {
462          this.OnNameChanging(value);
463          this.SendPropertyChanging();
464          this._Name = value;
465          this.SendPropertyChanged("Name");
466          this.OnNameChanged();
467        }
468      }
469    }
470   
471    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Version", DbType="VarChar(MAX)", CanBeNull=false)]
472    public string Version
473    {
474      get
475      {
476        return this._Version;
477      }
478      set
479      {
480        if ((this._Version != value))
481        {
482          this.OnVersionChanging(value);
483          this.SendPropertyChanging();
484          this._Version = value;
485          this.SendPropertyChanged("Version");
486          this.OnVersionChanged();
487        }
488      }
489    }
490   
491    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsLocal", DbType="Bit")]
492    public bool IsLocal
493    {
494      get
495      {
496        return this._IsLocal;
497      }
498      set
499      {
500        if ((this._IsLocal != value))
501        {
502          this.OnIsLocalChanging(value);
503          this.SendPropertyChanging();
504          this._IsLocal = value;
505          this.SendPropertyChanged("IsLocal");
506          this.OnIsLocalChanged();
507        }
508      }
509    }
510   
511    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier")]
512    public System.Guid UserId
513    {
514      get
515      {
516        return this._UserId;
517      }
518      set
519      {
520        if ((this._UserId != value))
521        {
522          this.OnUserIdChanging(value);
523          this.SendPropertyChanging();
524          this._UserId = value;
525          this.SendPropertyChanged("UserId");
526          this.OnUserIdChanged();
527        }
528      }
529    }
530   
531    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateCreated", DbType="DateTime")]
532    public System.DateTime DateCreated
533    {
534      get
535      {
536        return this._DateCreated;
537      }
538      set
539      {
540        if ((this._DateCreated != value))
541        {
542          this.OnDateCreatedChanging(value);
543          this.SendPropertyChanging();
544          this._DateCreated = value;
545          this.SendPropertyChanged("DateCreated");
546          this.OnDateCreatedChanged();
547        }
548      }
549    }
550   
551    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_RequiredPlugin", Storage="_RequiredPlugins", ThisKey="PluginId", OtherKey="PluginId")]
552    public EntitySet<RequiredPlugin> RequiredPlugins
553    {
554      get
555      {
556        return this._RequiredPlugins;
557      }
558      set
559      {
560        this._RequiredPlugins.Assign(value);
561      }
562    }
563   
564    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_PluginData", Storage="_PluginData", ThisKey="PluginId", OtherKey="PluginId")]
565    public EntitySet<PluginData> PluginData
566    {
567      get
568      {
569        return this._PluginData;
570      }
571      set
572      {
573        this._PluginData.Assign(value);
574      }
575    }
576   
577    public event PropertyChangingEventHandler PropertyChanging;
578   
579    public event PropertyChangedEventHandler PropertyChanged;
580   
581    protected virtual void SendPropertyChanging()
582    {
583      if ((this.PropertyChanging != null))
584      {
585        this.PropertyChanging(this, emptyChangingEventArgs);
586      }
587    }
588   
589    protected virtual void SendPropertyChanged(String propertyName)
590    {
591      if ((this.PropertyChanged != null))
592      {
593        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
594      }
595    }
596   
597    private void attach_RequiredPlugins(RequiredPlugin entity)
598    {
599      this.SendPropertyChanging();
600      entity.Plugin = this;
601    }
602   
603    private void detach_RequiredPlugins(RequiredPlugin entity)
604    {
605      this.SendPropertyChanging();
606      entity.Plugin = null;
607    }
608   
609    private void attach_PluginData(PluginData entity)
610    {
611      this.SendPropertyChanging();
612      entity.Plugin = this;
613    }
614   
615    private void detach_PluginData(PluginData entity)
616    {
617      this.SendPropertyChanging();
618      entity.Plugin = null;
619    }
620  }
621 
622  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.RequiredPlugins")]
623  public partial class RequiredPlugin : INotifyPropertyChanging, INotifyPropertyChanged
624  {
625   
626    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
627   
628    private System.Guid _RequiredPluginId;
629   
630    private System.Guid _JobId;
631   
632    private System.Guid _PluginId;
633   
634    private EntityRef<Plugin> _PluginInfo;
635   
636    private EntityRef<Job> _Job;
637   
638    #region Extensibility Method Definitions
639    partial void OnLoaded();
640    partial void OnValidate(System.Data.Linq.ChangeAction action);
641    partial void OnCreated();
642    partial void OnRequiredPluginIdChanging(System.Guid value);
643    partial void OnRequiredPluginIdChanged();
644    partial void OnJobIdChanging(System.Guid value);
645    partial void OnJobIdChanged();
646    partial void OnPluginIdChanging(System.Guid value);
647    partial void OnPluginIdChanged();
648    #endregion
649   
650    public RequiredPlugin()
651    {
652      this._PluginInfo = default(EntityRef<Plugin>);
653      this._Job = default(EntityRef<Job>);
654      OnCreated();
655    }
656   
657    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_RequiredPluginId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true, UpdateCheck=UpdateCheck.Never)]
658    public System.Guid RequiredPluginId
659    {
660      get
661      {
662        return this._RequiredPluginId;
663      }
664      set
665      {
666        if ((this._RequiredPluginId != value))
667        {
668          this.OnRequiredPluginIdChanging(value);
669          this.SendPropertyChanging();
670          this._RequiredPluginId = value;
671          this.SendPropertyChanged("RequiredPluginId");
672          this.OnRequiredPluginIdChanged();
673        }
674      }
675    }
676   
677    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL")]
678    public System.Guid JobId
679    {
680      get
681      {
682        return this._JobId;
683      }
684      set
685      {
686        if ((this._JobId != value))
687        {
688          if (this._Job.HasLoadedOrAssignedValue)
689          {
690            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
691          }
692          this.OnJobIdChanging(value);
693          this.SendPropertyChanging();
694          this._JobId = value;
695          this.SendPropertyChanged("JobId");
696          this.OnJobIdChanged();
697        }
698      }
699    }
700   
701    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginId", DbType="UniqueIdentifier NOT NULL")]
702    public System.Guid PluginId
703    {
704      get
705      {
706        return this._PluginId;
707      }
708      set
709      {
710        if ((this._PluginId != value))
711        {
712          if (this._PluginInfo.HasLoadedOrAssignedValue)
713          {
714            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
715          }
716          this.OnPluginIdChanging(value);
717          this.SendPropertyChanging();
718          this._PluginId = value;
719          this.SendPropertyChanged("PluginId");
720          this.OnPluginIdChanged();
721        }
722      }
723    }
724   
725    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_RequiredPlugin", Storage="_PluginInfo", ThisKey="PluginId", OtherKey="PluginId", IsForeignKey=true, DeleteRule="CASCADE")]
726    public Plugin Plugin
727    {
728      get
729      {
730        return this._PluginInfo.Entity;
731      }
732      set
733      {
734        Plugin previousValue = this._PluginInfo.Entity;
735        if (((previousValue != value)
736              || (this._PluginInfo.HasLoadedOrAssignedValue == false)))
737        {
738          this.SendPropertyChanging();
739          if ((previousValue != null))
740          {
741            this._PluginInfo.Entity = null;
742            previousValue.RequiredPlugins.Remove(this);
743          }
744          this._PluginInfo.Entity = value;
745          if ((value != null))
746          {
747            value.RequiredPlugins.Add(this);
748            this._PluginId = value.PluginId;
749          }
750          else
751          {
752            this._PluginId = default(System.Guid);
753          }
754          this.SendPropertyChanged("Plugin");
755        }
756      }
757    }
758   
759    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_RequiredPlugin", Storage="_Job", ThisKey="JobId", OtherKey="JobId", IsForeignKey=true)]
760    public Job Job
761    {
762      get
763      {
764        return this._Job.Entity;
765      }
766      set
767      {
768        Job previousValue = this._Job.Entity;
769        if (((previousValue != value)
770              || (this._Job.HasLoadedOrAssignedValue == false)))
771        {
772          this.SendPropertyChanging();
773          if ((previousValue != null))
774          {
775            this._Job.Entity = null;
776            previousValue.RequiredPlugins.Remove(this);
777          }
778          this._Job.Entity = value;
779          if ((value != null))
780          {
781            value.RequiredPlugins.Add(this);
782            this._JobId = value.JobId;
783          }
784          else
785          {
786            this._JobId = default(System.Guid);
787          }
788          this.SendPropertyChanged("Job");
789        }
790      }
791    }
792   
793    public event PropertyChangingEventHandler PropertyChanging;
794   
795    public event PropertyChangedEventHandler PropertyChanged;
796   
797    protected virtual void SendPropertyChanging()
798    {
799      if ((this.PropertyChanging != null))
800      {
801        this.PropertyChanging(this, emptyChangingEventArgs);
802      }
803    }
804   
805    protected virtual void SendPropertyChanged(String propertyName)
806    {
807      if ((this.PropertyChanged != null))
808      {
809        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
810      }
811    }
812  }
813 
814  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Resource")]
815  [global::System.Data.Linq.Mapping.InheritanceMappingAttribute(Code="RESOURCE", Type=typeof(Resource))]
816  [global::System.Data.Linq.Mapping.InheritanceMappingAttribute(Code="Slave", Type=typeof(Slave), IsDefault=true)]
817  [global::System.Data.Linq.Mapping.InheritanceMappingAttribute(Code="GROUP", Type=typeof(SlaveGroup))]
818  public partial class Resource : INotifyPropertyChanging, INotifyPropertyChanged
819  {
820   
821    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
822   
823    private System.Guid _ResourceId;
824   
825    private string _Name;
826   
827    private string _ResourceType;
828   
829    private System.Nullable<System.Guid> _ParentResourceId;
830   
831    private EntitySet<AssignedResource> _AssignedResources;
832   
833    private EntitySet<Resource> _ChildResources;
834   
835    private EntitySet<UptimeCalendar> _UptimeCalendars;
836   
837    private EntitySet<StateLog> _StateLogs;
838   
839    private EntityRef<Resource> _ParentResource;
840   
841    #region Extensibility Method Definitions
842    partial void OnLoaded();
843    partial void OnValidate(System.Data.Linq.ChangeAction action);
844    partial void OnCreated();
845    partial void OnResourceIdChanging(System.Guid value);
846    partial void OnResourceIdChanged();
847    partial void OnNameChanging(string value);
848    partial void OnNameChanged();
849    partial void OnResourceTypeChanging(string value);
850    partial void OnResourceTypeChanged();
851    partial void OnParentResourceIdChanging(System.Nullable<System.Guid> value);
852    partial void OnParentResourceIdChanged();
853    #endregion
854   
855    public Resource()
856    {
857      this._AssignedResources = new EntitySet<AssignedResource>(new Action<AssignedResource>(this.attach_AssignedResources), new Action<AssignedResource>(this.detach_AssignedResources));
858      this._ChildResources = new EntitySet<Resource>(new Action<Resource>(this.attach_ChildResources), new Action<Resource>(this.detach_ChildResources));
859      this._UptimeCalendars = new EntitySet<UptimeCalendar>(new Action<UptimeCalendar>(this.attach_UptimeCalendars), new Action<UptimeCalendar>(this.detach_UptimeCalendars));
860      this._StateLogs = new EntitySet<StateLog>(new Action<StateLog>(this.attach_StateLogs), new Action<StateLog>(this.detach_StateLogs));
861      this._ParentResource = default(EntityRef<Resource>);
862      OnCreated();
863    }
864   
865    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
866    public System.Guid ResourceId
867    {
868      get
869      {
870        return this._ResourceId;
871      }
872      set
873      {
874        if ((this._ResourceId != value))
875        {
876          this.OnResourceIdChanging(value);
877          this.SendPropertyChanging();
878          this._ResourceId = value;
879          this.SendPropertyChanged("ResourceId");
880          this.OnResourceIdChanged();
881        }
882      }
883    }
884   
885    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX)", CanBeNull=false)]
886    public string Name
887    {
888      get
889      {
890        return this._Name;
891      }
892      set
893      {
894        if ((this._Name != value))
895        {
896          this.OnNameChanging(value);
897          this.SendPropertyChanging();
898          this._Name = value;
899          this.SendPropertyChanged("Name");
900          this.OnNameChanged();
901        }
902      }
903    }
904   
905    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceType", CanBeNull=false, IsDiscriminator=true)]
906    public string ResourceType
907    {
908      get
909      {
910        return this._ResourceType;
911      }
912      set
913      {
914        if ((this._ResourceType != value))
915        {
916          this.OnResourceTypeChanging(value);
917          this.SendPropertyChanging();
918          this._ResourceType = value;
919          this.SendPropertyChanged("ResourceType");
920          this.OnResourceTypeChanged();
921        }
922      }
923    }
924   
925    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ParentResourceId", DbType="UniqueIdentifier")]
926    public System.Nullable<System.Guid> ParentResourceId
927    {
928      get
929      {
930        return this._ParentResourceId;
931      }
932      set
933      {
934        if ((this._ParentResourceId != value))
935        {
936          if (this._ParentResource.HasLoadedOrAssignedValue)
937          {
938            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
939          }
940          this.OnParentResourceIdChanging(value);
941          this.SendPropertyChanging();
942          this._ParentResourceId = value;
943          this.SendPropertyChanged("ParentResourceId");
944          this.OnParentResourceIdChanged();
945        }
946      }
947    }
948   
949    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_AssignedResource", Storage="_AssignedResources", ThisKey="ResourceId", OtherKey="ResourceId")]
950    public EntitySet<AssignedResource> AssignedResources
951    {
952      get
953      {
954        return this._AssignedResources;
955      }
956      set
957      {
958        this._AssignedResources.Assign(value);
959      }
960    }
961   
962    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_Resource", Storage="_ChildResources", ThisKey="ResourceId", OtherKey="ParentResourceId")]
963    public EntitySet<Resource> ChildResources
964    {
965      get
966      {
967        return this._ChildResources;
968      }
969      set
970      {
971        this._ChildResources.Assign(value);
972      }
973    }
974   
975    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_UptimeCalendar", Storage="_UptimeCalendars", ThisKey="ResourceId", OtherKey="ResourceId")]
976    public EntitySet<UptimeCalendar> UptimeCalendars
977    {
978      get
979      {
980        return this._UptimeCalendars;
981      }
982      set
983      {
984        this._UptimeCalendars.Assign(value);
985      }
986    }
987   
988    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_StateLog", Storage="_StateLogs", ThisKey="ResourceId", OtherKey="SlaveId")]
989    public EntitySet<StateLog> StateLogs
990    {
991      get
992      {
993        return this._StateLogs;
994      }
995      set
996      {
997        this._StateLogs.Assign(value);
998      }
999    }
1000   
1001    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_Resource", Storage="_ParentResource", ThisKey="ParentResourceId", OtherKey="ResourceId", IsForeignKey=true)]
1002    public Resource ParentResource
1003    {
1004      get
1005      {
1006        return this._ParentResource.Entity;
1007      }
1008      set
1009      {
1010        Resource previousValue = this._ParentResource.Entity;
1011        if (((previousValue != value)
1012              || (this._ParentResource.HasLoadedOrAssignedValue == false)))
1013        {
1014          this.SendPropertyChanging();
1015          if ((previousValue != null))
1016          {
1017            this._ParentResource.Entity = null;
1018            previousValue.ChildResources.Remove(this);
1019          }
1020          this._ParentResource.Entity = value;
1021          if ((value != null))
1022          {
1023            value.ChildResources.Add(this);
1024            this._ParentResourceId = value.ResourceId;
1025          }
1026          else
1027          {
1028            this._ParentResourceId = default(Nullable<System.Guid>);
1029          }
1030          this.SendPropertyChanged("ParentResource");
1031        }
1032      }
1033    }
1034   
1035    public event PropertyChangingEventHandler PropertyChanging;
1036   
1037    public event PropertyChangedEventHandler PropertyChanged;
1038   
1039    protected virtual void SendPropertyChanging()
1040    {
1041      if ((this.PropertyChanging != null))
1042      {
1043        this.PropertyChanging(this, emptyChangingEventArgs);
1044      }
1045    }
1046   
1047    protected virtual void SendPropertyChanged(String propertyName)
1048    {
1049      if ((this.PropertyChanged != null))
1050      {
1051        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1052      }
1053    }
1054   
1055    private void attach_AssignedResources(AssignedResource entity)
1056    {
1057      this.SendPropertyChanging();
1058      entity.Resource = this;
1059    }
1060   
1061    private void detach_AssignedResources(AssignedResource entity)
1062    {
1063      this.SendPropertyChanging();
1064      entity.Resource = null;
1065    }
1066   
1067    private void attach_ChildResources(Resource entity)
1068    {
1069      this.SendPropertyChanging();
1070      entity.ParentResource = this;
1071    }
1072   
1073    private void detach_ChildResources(Resource entity)
1074    {
1075      this.SendPropertyChanging();
1076      entity.ParentResource = null;
1077    }
1078   
1079    private void attach_UptimeCalendars(UptimeCalendar entity)
1080    {
1081      this.SendPropertyChanging();
1082      entity.Resource = this;
1083    }
1084   
1085    private void detach_UptimeCalendars(UptimeCalendar entity)
1086    {
1087      this.SendPropertyChanging();
1088      entity.Resource = null;
1089    }
1090   
1091    private void attach_StateLogs(StateLog entity)
1092    {
1093      this.SendPropertyChanging();
1094      entity.Resource = this;
1095    }
1096   
1097    private void detach_StateLogs(StateLog entity)
1098    {
1099      this.SendPropertyChanging();
1100      entity.Resource = null;
1101    }
1102  }
1103 
1104  public partial class Slave : Resource
1105  {
1106   
1107    private System.Nullable<int> _CPUSpeed;
1108   
1109    private System.Nullable<int> _Memory;
1110   
1111    private System.Nullable<System.DateTime> _Login;
1112   
1113    private global::HeuristicLab.Services.Hive.Common.DataTransfer.SlaveState _Status;
1114   
1115    private System.Nullable<int> _NumberOfCores;
1116   
1117    private System.Nullable<int> _NumberOfFreeCores;
1118   
1119    private System.Nullable<int> _FreeMemory;
1120   
1121    private bool _IsAllowedToCalculate;
1122   
1123    private global::HeuristicLab.Services.Hive.Common.DataTransfer.CpuArchitecture _CpuArchitecture;
1124   
1125    private string _OperatingSystem;
1126   
1127    private System.Nullable<System.DateTime> _LastHeartbeat;
1128   
1129    #region Extensibility Method Definitions
1130    partial void OnLoaded();
1131    partial void OnValidate(System.Data.Linq.ChangeAction action);
1132    partial void OnCreated();
1133    partial void OnCpuSpeedChanging(System.Nullable<int> value);
1134    partial void OnCpuSpeedChanged();
1135    partial void OnMemoryChanging(System.Nullable<int> value);
1136    partial void OnMemoryChanged();
1137    partial void OnLoginChanging(System.Nullable<System.DateTime> value);
1138    partial void OnLoginChanged();
1139    partial void OnSlaveStateChanging(global::HeuristicLab.Services.Hive.Common.DataTransfer.SlaveState value);
1140    partial void OnSlaveStateChanged();
1141    partial void OnCoresChanging(System.Nullable<int> value);
1142    partial void OnCoresChanged();
1143    partial void OnFreeCoresChanging(System.Nullable<int> value);
1144    partial void OnFreeCoresChanged();
1145    partial void OnFreeMemoryChanging(System.Nullable<int> value);
1146    partial void OnFreeMemoryChanged();
1147    partial void OnIsAllowedToCalculateChanging(bool value);
1148    partial void OnIsAllowedToCalculateChanged();
1149    partial void OnCpuArchitectureChanging(global::HeuristicLab.Services.Hive.Common.DataTransfer.CpuArchitecture value);
1150    partial void OnCpuArchitectureChanged();
1151    partial void OnOperatingSystemChanging(string value);
1152    partial void OnOperatingSystemChanged();
1153    partial void OnLastHeartbeatChanging(System.Nullable<System.DateTime> value);
1154    partial void OnLastHeartbeatChanged();
1155    #endregion
1156   
1157    public Slave()
1158    {
1159      OnCreated();
1160    }
1161   
1162    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CPUSpeed", DbType="Int")]
1163    public System.Nullable<int> CpuSpeed
1164    {
1165      get
1166      {
1167        return this._CPUSpeed;
1168      }
1169      set
1170      {
1171        if ((this._CPUSpeed != value))
1172        {
1173          this.OnCpuSpeedChanging(value);
1174          this.SendPropertyChanging();
1175          this._CPUSpeed = value;
1176          this.SendPropertyChanged("CpuSpeed");
1177          this.OnCpuSpeedChanged();
1178        }
1179      }
1180    }
1181   
1182    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Memory", DbType="Int")]
1183    public System.Nullable<int> Memory
1184    {
1185      get
1186      {
1187        return this._Memory;
1188      }
1189      set
1190      {
1191        if ((this._Memory != value))
1192        {
1193          this.OnMemoryChanging(value);
1194          this.SendPropertyChanging();
1195          this._Memory = value;
1196          this.SendPropertyChanged("Memory");
1197          this.OnMemoryChanged();
1198        }
1199      }
1200    }
1201   
1202    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Login", DbType="DateTime")]
1203    public System.Nullable<System.DateTime> Login
1204    {
1205      get
1206      {
1207        return this._Login;
1208      }
1209      set
1210      {
1211        if ((this._Login != value))
1212        {
1213          this.OnLoginChanging(value);
1214          this.SendPropertyChanging();
1215          this._Login = value;
1216          this.SendPropertyChanged("Login");
1217          this.OnLoginChanged();
1218        }
1219      }
1220    }
1221   
1222    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Status", DbType="VarChar(15)", CanBeNull=true)]
1223    public global::HeuristicLab.Services.Hive.Common.DataTransfer.SlaveState SlaveState
1224    {
1225      get
1226      {
1227        return this._Status;
1228      }
1229      set
1230      {
1231        if ((this._Status != value))
1232        {
1233          this.OnSlaveStateChanging(value);
1234          this.SendPropertyChanging();
1235          this._Status = value;
1236          this.SendPropertyChanged("SlaveState");
1237          this.OnSlaveStateChanged();
1238        }
1239      }
1240    }
1241   
1242    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumberOfCores", DbType="Int")]
1243    public System.Nullable<int> Cores
1244    {
1245      get
1246      {
1247        return this._NumberOfCores;
1248      }
1249      set
1250      {
1251        if ((this._NumberOfCores != value))
1252        {
1253          this.OnCoresChanging(value);
1254          this.SendPropertyChanging();
1255          this._NumberOfCores = value;
1256          this.SendPropertyChanged("Cores");
1257          this.OnCoresChanged();
1258        }
1259      }
1260    }
1261   
1262    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_NumberOfFreeCores", DbType="Int")]
1263    public System.Nullable<int> FreeCores
1264    {
1265      get
1266      {
1267        return this._NumberOfFreeCores;
1268      }
1269      set
1270      {
1271        if ((this._NumberOfFreeCores != value))
1272        {
1273          this.OnFreeCoresChanging(value);
1274          this.SendPropertyChanging();
1275          this._NumberOfFreeCores = value;
1276          this.SendPropertyChanged("FreeCores");
1277          this.OnFreeCoresChanged();
1278        }
1279      }
1280    }
1281   
1282    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_FreeMemory", DbType="Int")]
1283    public System.Nullable<int> FreeMemory
1284    {
1285      get
1286      {
1287        return this._FreeMemory;
1288      }
1289      set
1290      {
1291        if ((this._FreeMemory != value))
1292        {
1293          this.OnFreeMemoryChanging(value);
1294          this.SendPropertyChanging();
1295          this._FreeMemory = value;
1296          this.SendPropertyChanged("FreeMemory");
1297          this.OnFreeMemoryChanged();
1298        }
1299      }
1300    }
1301   
1302    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsAllowedToCalculate", DbType="Bit")]
1303    public bool IsAllowedToCalculate
1304    {
1305      get
1306      {
1307        return this._IsAllowedToCalculate;
1308      }
1309      set
1310      {
1311        if ((this._IsAllowedToCalculate != value))
1312        {
1313          this.OnIsAllowedToCalculateChanging(value);
1314          this.SendPropertyChanging();
1315          this._IsAllowedToCalculate = value;
1316          this.SendPropertyChanged("IsAllowedToCalculate");
1317          this.OnIsAllowedToCalculateChanged();
1318        }
1319      }
1320    }
1321   
1322    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CpuArchitecture", DbType="VarChar(3)", CanBeNull=false)]
1323    public global::HeuristicLab.Services.Hive.Common.DataTransfer.CpuArchitecture CpuArchitecture
1324    {
1325      get
1326      {
1327        return this._CpuArchitecture;
1328      }
1329      set
1330      {
1331        if ((this._CpuArchitecture != value))
1332        {
1333          this.OnCpuArchitectureChanging(value);
1334          this.SendPropertyChanging();
1335          this._CpuArchitecture = value;
1336          this.SendPropertyChanged("CpuArchitecture");
1337          this.OnCpuArchitectureChanged();
1338        }
1339      }
1340    }
1341   
1342    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_OperatingSystem", DbType="VarChar(MAX)", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
1343    public string OperatingSystem
1344    {
1345      get
1346      {
1347        return this._OperatingSystem;
1348      }
1349      set
1350      {
1351        if ((this._OperatingSystem != value))
1352        {
1353          this.OnOperatingSystemChanging(value);
1354          this.SendPropertyChanging();
1355          this._OperatingSystem = value;
1356          this.SendPropertyChanged("OperatingSystem");
1357          this.OnOperatingSystemChanged();
1358        }
1359      }
1360    }
1361   
1362    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastHeartbeat", DbType="DateTime")]
1363    public System.Nullable<System.DateTime> LastHeartbeat
1364    {
1365      get
1366      {
1367        return this._LastHeartbeat;
1368      }
1369      set
1370      {
1371        if ((this._LastHeartbeat != value))
1372        {
1373          this.OnLastHeartbeatChanging(value);
1374          this.SendPropertyChanging();
1375          this._LastHeartbeat = value;
1376          this.SendPropertyChanged("LastHeartbeat");
1377          this.OnLastHeartbeatChanged();
1378        }
1379      }
1380    }
1381  }
1382 
1383  public partial class SlaveGroup : Resource
1384  {
1385   
1386    #region Extensibility Method Definitions
1387    partial void OnLoaded();
1388    partial void OnValidate(System.Data.Linq.ChangeAction action);
1389    partial void OnCreated();
1390    #endregion
1391   
1392    public SlaveGroup()
1393    {
1394      OnCreated();
1395    }
1396  }
1397 
1398  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Job")]
1399  public partial class Job : INotifyPropertyChanging, INotifyPropertyChanged
1400  {
1401   
1402    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1403   
1404    private System.Guid _JobId;
1405   
1406    private global::HeuristicLab.Services.Hive.Common.DataTransfer.JobState _State;
1407   
1408    private string _ExecutionTime;
1409   
1410    private System.Nullable<System.DateTime> _LastHeartbeat;
1411   
1412    private System.Nullable<System.Guid> _ParentJobId;
1413   
1414    private int _Priority;
1415   
1416    private int _CoresNeeded;
1417   
1418    private int _MemoryNeeded;
1419   
1420    private bool _IsParentJob;
1421   
1422    private bool _FinishWhenChildJobsFinished;
1423   
1424    private EntitySet<AssignedResource> _AssignedResources;
1425   
1426    private EntitySet<RequiredPlugin> _RequiredPlugins;
1427   
1428    private EntitySet<Job> _Jobs;
1429   
1430    private EntityRef<JobData> _JobData;
1431   
1432    private EntitySet<StateLog> _StateLogs;
1433   
1434    private EntityRef<Job> _Job1;
1435   
1436    #region Extensibility Method Definitions
1437    partial void OnLoaded();
1438    partial void OnValidate(System.Data.Linq.ChangeAction action);
1439    partial void OnCreated();
1440    partial void OnJobIdChanging(System.Guid value);
1441    partial void OnJobIdChanged();
1442    partial void OnStateChanging(global::HeuristicLab.Services.Hive.Common.DataTransfer.JobState value);
1443    partial void OnStateChanged();
1444    partial void OnExecutionTimeChanging(string value);
1445    partial void OnExecutionTimeChanged();
1446    partial void OnLastHeartbeatChanging(System.Nullable<System.DateTime> value);
1447    partial void OnLastHeartbeatChanged();
1448    partial void OnParentJobIdChanging(System.Nullable<System.Guid> value);
1449    partial void OnParentJobIdChanged();
1450    partial void OnPriorityChanging(int value);
1451    partial void OnPriorityChanged();
1452    partial void OnCoresNeededChanging(int value);
1453    partial void OnCoresNeededChanged();
1454    partial void OnMemoryNeededChanging(int value);
1455    partial void OnMemoryNeededChanged();
1456    partial void OnIsParentJobChanging(bool value);
1457    partial void OnIsParentJobChanged();
1458    partial void OnFinishWhenChildJobsFinishedChanging(bool value);
1459    partial void OnFinishWhenChildJobsFinishedChanged();
1460    #endregion
1461   
1462    public Job()
1463    {
1464      this._AssignedResources = new EntitySet<AssignedResource>(new Action<AssignedResource>(this.attach_AssignedResources), new Action<AssignedResource>(this.detach_AssignedResources));
1465      this._RequiredPlugins = new EntitySet<RequiredPlugin>(new Action<RequiredPlugin>(this.attach_RequiredPlugins), new Action<RequiredPlugin>(this.detach_RequiredPlugins));
1466      this._Jobs = new EntitySet<Job>(new Action<Job>(this.attach_Jobs), new Action<Job>(this.detach_Jobs));
1467      this._JobData = default(EntityRef<JobData>);
1468      this._StateLogs = new EntitySet<StateLog>(new Action<StateLog>(this.attach_StateLogs), new Action<StateLog>(this.detach_StateLogs));
1469      this._Job1 = default(EntityRef<Job>);
1470      OnCreated();
1471    }
1472   
1473    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
1474    public System.Guid JobId
1475    {
1476      get
1477      {
1478        return this._JobId;
1479      }
1480      set
1481      {
1482        if ((this._JobId != value))
1483        {
1484          this.OnJobIdChanging(value);
1485          this.SendPropertyChanging();
1486          this._JobId = value;
1487          this.SendPropertyChanged("JobId");
1488          this.OnJobIdChanged();
1489        }
1490      }
1491    }
1492   
1493    [global::System.Data.Linq.Mapping.ColumnAttribute(Name="JobState", Storage="_State", DbType="VarChar(30)", CanBeNull=false)]
1494    public global::HeuristicLab.Services.Hive.Common.DataTransfer.JobState State
1495    {
1496      get
1497      {
1498        return this._State;
1499      }
1500      set
1501      {
1502        if ((this._State != value))
1503        {
1504          this.OnStateChanging(value);
1505          this.SendPropertyChanging();
1506          this._State = value;
1507          this.SendPropertyChanged("State");
1508          this.OnStateChanged();
1509        }
1510      }
1511    }
1512   
1513    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ExecutionTime", DbType="VarChar(30)")]
1514    public string ExecutionTime
1515    {
1516      get
1517      {
1518        return this._ExecutionTime;
1519      }
1520      set
1521      {
1522        if ((this._ExecutionTime != value))
1523        {
1524          this.OnExecutionTimeChanging(value);
1525          this.SendPropertyChanging();
1526          this._ExecutionTime = value;
1527          this.SendPropertyChanged("ExecutionTime");
1528          this.OnExecutionTimeChanged();
1529        }
1530      }
1531    }
1532   
1533    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastHeartbeat", DbType="DateTime")]
1534    public System.Nullable<System.DateTime> LastHeartbeat
1535    {
1536      get
1537      {
1538        return this._LastHeartbeat;
1539      }
1540      set
1541      {
1542        if ((this._LastHeartbeat != value))
1543        {
1544          this.OnLastHeartbeatChanging(value);
1545          this.SendPropertyChanging();
1546          this._LastHeartbeat = value;
1547          this.SendPropertyChanged("LastHeartbeat");
1548          this.OnLastHeartbeatChanged();
1549        }
1550      }
1551    }
1552   
1553    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ParentJobId", DbType="UniqueIdentifier")]
1554    public System.Nullable<System.Guid> ParentJobId
1555    {
1556      get
1557      {
1558        return this._ParentJobId;
1559      }
1560      set
1561      {
1562        if ((this._ParentJobId != value))
1563        {
1564          if (this._Job1.HasLoadedOrAssignedValue)
1565          {
1566            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
1567          }
1568          this.OnParentJobIdChanging(value);
1569          this.SendPropertyChanging();
1570          this._ParentJobId = value;
1571          this.SendPropertyChanged("ParentJobId");
1572          this.OnParentJobIdChanged();
1573        }
1574      }
1575    }
1576   
1577    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Priority", DbType="Int NOT NULL")]
1578    public int Priority
1579    {
1580      get
1581      {
1582        return this._Priority;
1583      }
1584      set
1585      {
1586        if ((this._Priority != value))
1587        {
1588          this.OnPriorityChanging(value);
1589          this.SendPropertyChanging();
1590          this._Priority = value;
1591          this.SendPropertyChanged("Priority");
1592          this.OnPriorityChanged();
1593        }
1594      }
1595    }
1596   
1597    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_CoresNeeded", DbType="Int NOT NULL")]
1598    public int CoresNeeded
1599    {
1600      get
1601      {
1602        return this._CoresNeeded;
1603      }
1604      set
1605      {
1606        if ((this._CoresNeeded != value))
1607        {
1608          this.OnCoresNeededChanging(value);
1609          this.SendPropertyChanging();
1610          this._CoresNeeded = value;
1611          this.SendPropertyChanged("CoresNeeded");
1612          this.OnCoresNeededChanged();
1613        }
1614      }
1615    }
1616   
1617    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_MemoryNeeded", DbType="Int NOT NULL")]
1618    public int MemoryNeeded
1619    {
1620      get
1621      {
1622        return this._MemoryNeeded;
1623      }
1624      set
1625      {
1626        if ((this._MemoryNeeded != value))
1627        {
1628          this.OnMemoryNeededChanging(value);
1629          this.SendPropertyChanging();
1630          this._MemoryNeeded = value;
1631          this.SendPropertyChanged("MemoryNeeded");
1632          this.OnMemoryNeededChanged();
1633        }
1634      }
1635    }
1636   
1637    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsParentJob", DbType="Bit")]
1638    public bool IsParentJob
1639    {
1640      get
1641      {
1642        return this._IsParentJob;
1643      }
1644      set
1645      {
1646        if ((this._IsParentJob != value))
1647        {
1648          this.OnIsParentJobChanging(value);
1649          this.SendPropertyChanging();
1650          this._IsParentJob = value;
1651          this.SendPropertyChanged("IsParentJob");
1652          this.OnIsParentJobChanged();
1653        }
1654      }
1655    }
1656   
1657    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_FinishWhenChildJobsFinished", DbType="Bit")]
1658    public bool FinishWhenChildJobsFinished
1659    {
1660      get
1661      {
1662        return this._FinishWhenChildJobsFinished;
1663      }
1664      set
1665      {
1666        if ((this._FinishWhenChildJobsFinished != value))
1667        {
1668          this.OnFinishWhenChildJobsFinishedChanging(value);
1669          this.SendPropertyChanging();
1670          this._FinishWhenChildJobsFinished = value;
1671          this.SendPropertyChanged("FinishWhenChildJobsFinished");
1672          this.OnFinishWhenChildJobsFinishedChanged();
1673        }
1674      }
1675    }
1676   
1677    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_AssignedResource", Storage="_AssignedResources", ThisKey="JobId", OtherKey="JobId")]
1678    public EntitySet<AssignedResource> AssignedResources
1679    {
1680      get
1681      {
1682        return this._AssignedResources;
1683      }
1684      set
1685      {
1686        this._AssignedResources.Assign(value);
1687      }
1688    }
1689   
1690    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_RequiredPlugin", Storage="_RequiredPlugins", ThisKey="JobId", OtherKey="JobId")]
1691    public EntitySet<RequiredPlugin> RequiredPlugins
1692    {
1693      get
1694      {
1695        return this._RequiredPlugins;
1696      }
1697      set
1698      {
1699        this._RequiredPlugins.Assign(value);
1700      }
1701    }
1702   
1703    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_Job", Storage="_Jobs", ThisKey="JobId", OtherKey="ParentJobId")]
1704    public EntitySet<Job> ChildJobs
1705    {
1706      get
1707      {
1708        return this._Jobs;
1709      }
1710      set
1711      {
1712        this._Jobs.Assign(value);
1713      }
1714    }
1715   
1716    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_JobData", Storage="_JobData", ThisKey="JobId", OtherKey="JobId", IsUnique=true, IsForeignKey=false)]
1717    public JobData JobData
1718    {
1719      get
1720      {
1721        return this._JobData.Entity;
1722      }
1723      set
1724      {
1725        JobData previousValue = this._JobData.Entity;
1726        if (((previousValue != value)
1727              || (this._JobData.HasLoadedOrAssignedValue == false)))
1728        {
1729          this.SendPropertyChanging();
1730          if ((previousValue != null))
1731          {
1732            this._JobData.Entity = null;
1733            previousValue.Job = null;
1734          }
1735          this._JobData.Entity = value;
1736          if ((value != null))
1737          {
1738            value.Job = this;
1739          }
1740          this.SendPropertyChanged("JobData");
1741        }
1742      }
1743    }
1744   
1745    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_StateLog", Storage="_StateLogs", ThisKey="JobId", OtherKey="JobId")]
1746    public EntitySet<StateLog> StateLogs
1747    {
1748      get
1749      {
1750        return this._StateLogs;
1751      }
1752      set
1753      {
1754        this._StateLogs.Assign(value);
1755      }
1756    }
1757   
1758    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_Job", Storage="_Job1", ThisKey="ParentJobId", OtherKey="JobId", IsForeignKey=true)]
1759    public Job ParentJob
1760    {
1761      get
1762      {
1763        return this._Job1.Entity;
1764      }
1765      set
1766      {
1767        Job previousValue = this._Job1.Entity;
1768        if (((previousValue != value)
1769              || (this._Job1.HasLoadedOrAssignedValue == false)))
1770        {
1771          this.SendPropertyChanging();
1772          if ((previousValue != null))
1773          {
1774            this._Job1.Entity = null;
1775            previousValue.ChildJobs.Remove(this);
1776          }
1777          this._Job1.Entity = value;
1778          if ((value != null))
1779          {
1780            value.ChildJobs.Add(this);
1781            this._ParentJobId = value.JobId;
1782          }
1783          else
1784          {
1785            this._ParentJobId = default(Nullable<System.Guid>);
1786          }
1787          this.SendPropertyChanged("ParentJob");
1788        }
1789      }
1790    }
1791   
1792    public event PropertyChangingEventHandler PropertyChanging;
1793   
1794    public event PropertyChangedEventHandler PropertyChanged;
1795   
1796    protected virtual void SendPropertyChanging()
1797    {
1798      if ((this.PropertyChanging != null))
1799      {
1800        this.PropertyChanging(this, emptyChangingEventArgs);
1801      }
1802    }
1803   
1804    protected virtual void SendPropertyChanged(String propertyName)
1805    {
1806      if ((this.PropertyChanged != null))
1807      {
1808        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
1809      }
1810    }
1811   
1812    private void attach_AssignedResources(AssignedResource entity)
1813    {
1814      this.SendPropertyChanging();
1815      entity.Job = this;
1816    }
1817   
1818    private void detach_AssignedResources(AssignedResource entity)
1819    {
1820      this.SendPropertyChanging();
1821      entity.Job = null;
1822    }
1823   
1824    private void attach_RequiredPlugins(RequiredPlugin entity)
1825    {
1826      this.SendPropertyChanging();
1827      entity.Job = this;
1828    }
1829   
1830    private void detach_RequiredPlugins(RequiredPlugin entity)
1831    {
1832      this.SendPropertyChanging();
1833      entity.Job = null;
1834    }
1835   
1836    private void attach_Jobs(Job entity)
1837    {
1838      this.SendPropertyChanging();
1839      entity.ParentJob = this;
1840    }
1841   
1842    private void detach_Jobs(Job entity)
1843    {
1844      this.SendPropertyChanging();
1845      entity.ParentJob = null;
1846    }
1847   
1848    private void attach_StateLogs(StateLog entity)
1849    {
1850      this.SendPropertyChanging();
1851      entity.Job = this;
1852    }
1853   
1854    private void detach_StateLogs(StateLog entity)
1855    {
1856      this.SendPropertyChanging();
1857      entity.Job = null;
1858    }
1859  }
1860 
1861  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.UptimeCalendar")]
1862  public partial class UptimeCalendar : INotifyPropertyChanging, INotifyPropertyChanged
1863  {
1864   
1865    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
1866   
1867    private System.Guid _UptimeCalendarId;
1868   
1869    private System.Guid _ResourceId;
1870   
1871    private System.DateTime _StartDate;
1872   
1873    private System.DateTime _EndDate;
1874   
1875    private bool _AllDayEvent;
1876   
1877    private bool _Recurring;
1878   
1879    private System.Guid _RecurringId;
1880   
1881    private EntityRef<Resource> _Resource;
1882   
1883    #region Extensibility Method Definitions
1884    partial void OnLoaded();
1885    partial void OnValidate(System.Data.Linq.ChangeAction action);
1886    partial void OnCreated();
1887    partial void OnUptimeCalendarIdChanging(System.Guid value);
1888    partial void OnUptimeCalendarIdChanged();
1889    partial void OnResourceIdChanging(System.Guid value);
1890    partial void OnResourceIdChanged();
1891    partial void OnStartDateChanging(System.DateTime value);
1892    partial void OnStartDateChanged();
1893    partial void OnEndDateChanging(System.DateTime value);
1894    partial void OnEndDateChanged();
1895    partial void OnAllDayEventChanging(bool value);
1896    partial void OnAllDayEventChanged();
1897    partial void OnRecurringChanging(bool value);
1898    partial void OnRecurringChanged();
1899    partial void OnRecurringIdChanging(System.Guid value);
1900    partial void OnRecurringIdChanged();
1901    #endregion
1902   
1903    public UptimeCalendar()
1904    {
1905      this._Resource = default(EntityRef<Resource>);
1906      OnCreated();
1907    }
1908   
1909    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UptimeCalendarId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier", IsPrimaryKey=true, IsDbGenerated=true)]
1910    public System.Guid UptimeCalendarId
1911    {
1912      get
1913      {
1914        return this._UptimeCalendarId;
1915      }
1916      set
1917      {
1918        if ((this._UptimeCalendarId != value))
1919        {
1920          this.OnUptimeCalendarIdChanging(value);
1921          this.SendPropertyChanging();
1922          this._UptimeCalendarId = value;
1923          this.SendPropertyChanged("UptimeCalendarId");
1924          this.OnUptimeCalendarIdChanged();
1925        }
1926      }
1927    }
1928   
1929    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceId", DbType="UniqueIdentifier")]
1930    public System.Guid ResourceId
1931    {
1932      get
1933      {
1934        return this._ResourceId;
1935      }
1936      set
1937      {
1938        if ((this._ResourceId != value))
1939        {
1940          if (this._Resource.HasLoadedOrAssignedValue)
1941          {
1942            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
1943          }
1944          this.OnResourceIdChanging(value);
1945          this.SendPropertyChanging();
1946          this._ResourceId = value;
1947          this.SendPropertyChanged("ResourceId");
1948          this.OnResourceIdChanged();
1949        }
1950      }
1951    }
1952   
1953    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StartDate", DbType="DateTime")]
1954    public System.DateTime StartDate
1955    {
1956      get
1957      {
1958        return this._StartDate;
1959      }
1960      set
1961      {
1962        if ((this._StartDate != value))
1963        {
1964          this.OnStartDateChanging(value);
1965          this.SendPropertyChanging();
1966          this._StartDate = value;
1967          this.SendPropertyChanged("StartDate");
1968          this.OnStartDateChanged();
1969        }
1970      }
1971    }
1972   
1973    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_EndDate", DbType="DateTime")]
1974    public System.DateTime EndDate
1975    {
1976      get
1977      {
1978        return this._EndDate;
1979      }
1980      set
1981      {
1982        if ((this._EndDate != value))
1983        {
1984          this.OnEndDateChanging(value);
1985          this.SendPropertyChanging();
1986          this._EndDate = value;
1987          this.SendPropertyChanged("EndDate");
1988          this.OnEndDateChanged();
1989        }
1990      }
1991    }
1992   
1993    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_AllDayEvent", DbType="Bit")]
1994    public bool AllDayEvent
1995    {
1996      get
1997      {
1998        return this._AllDayEvent;
1999      }
2000      set
2001      {
2002        if ((this._AllDayEvent != value))
2003        {
2004          this.OnAllDayEventChanging(value);
2005          this.SendPropertyChanging();
2006          this._AllDayEvent = value;
2007          this.SendPropertyChanged("AllDayEvent");
2008          this.OnAllDayEventChanged();
2009        }
2010      }
2011    }
2012   
2013    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Recurring", DbType="Bit")]
2014    public bool Recurring
2015    {
2016      get
2017      {
2018        return this._Recurring;
2019      }
2020      set
2021      {
2022        if ((this._Recurring != value))
2023        {
2024          this.OnRecurringChanging(value);
2025          this.SendPropertyChanging();
2026          this._Recurring = value;
2027          this.SendPropertyChanged("Recurring");
2028          this.OnRecurringChanged();
2029        }
2030      }
2031    }
2032   
2033    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_RecurringId", DbType="UniqueIdentifier")]
2034    public System.Guid RecurringId
2035    {
2036      get
2037      {
2038        return this._RecurringId;
2039      }
2040      set
2041      {
2042        if ((this._RecurringId != value))
2043        {
2044          this.OnRecurringIdChanging(value);
2045          this.SendPropertyChanging();
2046          this._RecurringId = value;
2047          this.SendPropertyChanged("RecurringId");
2048          this.OnRecurringIdChanged();
2049        }
2050      }
2051    }
2052   
2053    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_UptimeCalendar", Storage="_Resource", ThisKey="ResourceId", OtherKey="ResourceId", IsForeignKey=true, DeleteRule="CASCADE")]
2054    public Resource Resource
2055    {
2056      get
2057      {
2058        return this._Resource.Entity;
2059      }
2060      set
2061      {
2062        Resource previousValue = this._Resource.Entity;
2063        if (((previousValue != value)
2064              || (this._Resource.HasLoadedOrAssignedValue == false)))
2065        {
2066          this.SendPropertyChanging();
2067          if ((previousValue != null))
2068          {
2069            this._Resource.Entity = null;
2070            previousValue.UptimeCalendars.Remove(this);
2071          }
2072          this._Resource.Entity = value;
2073          if ((value != null))
2074          {
2075            value.UptimeCalendars.Add(this);
2076            this._ResourceId = value.ResourceId;
2077          }
2078          else
2079          {
2080            this._ResourceId = default(System.Guid);
2081          }
2082          this.SendPropertyChanged("Resource");
2083        }
2084      }
2085    }
2086   
2087    public event PropertyChangingEventHandler PropertyChanging;
2088   
2089    public event PropertyChangedEventHandler PropertyChanged;
2090   
2091    protected virtual void SendPropertyChanging()
2092    {
2093      if ((this.PropertyChanging != null))
2094      {
2095        this.PropertyChanging(this, emptyChangingEventArgs);
2096      }
2097    }
2098   
2099    protected virtual void SendPropertyChanged(String propertyName)
2100    {
2101      if ((this.PropertyChanged != null))
2102      {
2103        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2104      }
2105    }
2106  }
2107 
2108  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.HiveExperiment")]
2109  public partial class HiveExperiment : INotifyPropertyChanging, INotifyPropertyChanged
2110  {
2111   
2112    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2113   
2114    private System.Guid _HiveExperimentId;
2115   
2116    private string _Name;
2117   
2118    private string _Description;
2119   
2120    private string _ResourceIds;
2121   
2122    private System.Guid _UserId;
2123   
2124    private System.Guid _RootJobId;
2125   
2126    private System.DateTime _DateCreated;
2127   
2128    private System.Nullable<System.DateTime> _LastAccessed;
2129   
2130    private bool _IsHiveEngine;
2131   
2132    private EntitySet<HiveExperimentPermission> _HiveExperimentPermissions;
2133   
2134    private EntityRef<Job> _Job;
2135   
2136    #region Extensibility Method Definitions
2137    partial void OnLoaded();
2138    partial void OnValidate(System.Data.Linq.ChangeAction action);
2139    partial void OnCreated();
2140    partial void OnHiveExperimentIdChanging(System.Guid value);
2141    partial void OnHiveExperimentIdChanged();
2142    partial void OnNameChanging(string value);
2143    partial void OnNameChanged();
2144    partial void OnDescriptionChanging(string value);
2145    partial void OnDescriptionChanged();
2146    partial void OnResourceIdsChanging(string value);
2147    partial void OnResourceIdsChanged();
2148    partial void OnOwnerUserIdChanging(System.Guid value);
2149    partial void OnOwnerUserIdChanged();
2150    partial void OnRootJobIdChanging(System.Guid value);
2151    partial void OnRootJobIdChanged();
2152    partial void OnDateCreatedChanging(System.DateTime value);
2153    partial void OnDateCreatedChanged();
2154    partial void OnLastAccessedChanging(System.Nullable<System.DateTime> value);
2155    partial void OnLastAccessedChanged();
2156    partial void OnIsHiveEngineChanging(bool value);
2157    partial void OnIsHiveEngineChanged();
2158    #endregion
2159   
2160    public HiveExperiment()
2161    {
2162      this._HiveExperimentPermissions = new EntitySet<HiveExperimentPermission>(new Action<HiveExperimentPermission>(this.attach_HiveExperimentPermissions), new Action<HiveExperimentPermission>(this.detach_HiveExperimentPermissions));
2163      this._Job = default(EntityRef<Job>);
2164      OnCreated();
2165    }
2166   
2167    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_HiveExperimentId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
2168    public System.Guid HiveExperimentId
2169    {
2170      get
2171      {
2172        return this._HiveExperimentId;
2173      }
2174      set
2175      {
2176        if ((this._HiveExperimentId != value))
2177        {
2178          this.OnHiveExperimentIdChanging(value);
2179          this.SendPropertyChanging();
2180          this._HiveExperimentId = value;
2181          this.SendPropertyChanged("HiveExperimentId");
2182          this.OnHiveExperimentIdChanged();
2183        }
2184      }
2185    }
2186   
2187    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="VarChar(MAX)", CanBeNull=false)]
2188    public string Name
2189    {
2190      get
2191      {
2192        return this._Name;
2193      }
2194      set
2195      {
2196        if ((this._Name != value))
2197        {
2198          this.OnNameChanging(value);
2199          this.SendPropertyChanging();
2200          this._Name = value;
2201          this.SendPropertyChanged("Name");
2202          this.OnNameChanged();
2203        }
2204      }
2205    }
2206   
2207    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Description", DbType="VarChar(MAX)")]
2208    public string Description
2209    {
2210      get
2211      {
2212        return this._Description;
2213      }
2214      set
2215      {
2216        if ((this._Description != value))
2217        {
2218          this.OnDescriptionChanging(value);
2219          this.SendPropertyChanging();
2220          this._Description = value;
2221          this.SendPropertyChanged("Description");
2222          this.OnDescriptionChanged();
2223        }
2224      }
2225    }
2226   
2227    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ResourceIds", DbType="VarChar(MAX)")]
2228    public string ResourceIds
2229    {
2230      get
2231      {
2232        return this._ResourceIds;
2233      }
2234      set
2235      {
2236        if ((this._ResourceIds != value))
2237        {
2238          this.OnResourceIdsChanging(value);
2239          this.SendPropertyChanging();
2240          this._ResourceIds = value;
2241          this.SendPropertyChanged("ResourceIds");
2242          this.OnResourceIdsChanged();
2243        }
2244      }
2245    }
2246   
2247    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier")]
2248    public System.Guid OwnerUserId
2249    {
2250      get
2251      {
2252        return this._UserId;
2253      }
2254      set
2255      {
2256        if ((this._UserId != value))
2257        {
2258          this.OnOwnerUserIdChanging(value);
2259          this.SendPropertyChanging();
2260          this._UserId = value;
2261          this.SendPropertyChanged("OwnerUserId");
2262          this.OnOwnerUserIdChanged();
2263        }
2264      }
2265    }
2266   
2267    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_RootJobId", DbType="UniqueIdentifier")]
2268    public System.Guid RootJobId
2269    {
2270      get
2271      {
2272        return this._RootJobId;
2273      }
2274      set
2275      {
2276        if ((this._RootJobId != value))
2277        {
2278          if (this._Job.HasLoadedOrAssignedValue)
2279          {
2280            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2281          }
2282          this.OnRootJobIdChanging(value);
2283          this.SendPropertyChanging();
2284          this._RootJobId = value;
2285          this.SendPropertyChanged("RootJobId");
2286          this.OnRootJobIdChanged();
2287        }
2288      }
2289    }
2290   
2291    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateCreated", DbType="DateTime")]
2292    public System.DateTime DateCreated
2293    {
2294      get
2295      {
2296        return this._DateCreated;
2297      }
2298      set
2299      {
2300        if ((this._DateCreated != value))
2301        {
2302          this.OnDateCreatedChanging(value);
2303          this.SendPropertyChanging();
2304          this._DateCreated = value;
2305          this.SendPropertyChanged("DateCreated");
2306          this.OnDateCreatedChanged();
2307        }
2308      }
2309    }
2310   
2311    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastAccessed", DbType="DateTime")]
2312    public System.Nullable<System.DateTime> LastAccessed
2313    {
2314      get
2315      {
2316        return this._LastAccessed;
2317      }
2318      set
2319      {
2320        if ((this._LastAccessed != value))
2321        {
2322          this.OnLastAccessedChanging(value);
2323          this.SendPropertyChanging();
2324          this._LastAccessed = value;
2325          this.SendPropertyChanged("LastAccessed");
2326          this.OnLastAccessedChanged();
2327        }
2328      }
2329    }
2330   
2331    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_IsHiveEngine", DbType="Bit")]
2332    public bool IsHiveEngine
2333    {
2334      get
2335      {
2336        return this._IsHiveEngine;
2337      }
2338      set
2339      {
2340        if ((this._IsHiveEngine != value))
2341        {
2342          this.OnIsHiveEngineChanging(value);
2343          this.SendPropertyChanging();
2344          this._IsHiveEngine = value;
2345          this.SendPropertyChanged("IsHiveEngine");
2346          this.OnIsHiveEngineChanged();
2347        }
2348      }
2349    }
2350   
2351    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="HiveExperiment_HiveExperimentPermission", Storage="_HiveExperimentPermissions", ThisKey="HiveExperimentId", OtherKey="HiveExperimentId")]
2352    public EntitySet<HiveExperimentPermission> HiveExperimentPermissions
2353    {
2354      get
2355      {
2356        return this._HiveExperimentPermissions;
2357      }
2358      set
2359      {
2360        this._HiveExperimentPermissions.Assign(value);
2361      }
2362    }
2363   
2364    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_HiveExperiment", Storage="_Job", ThisKey="RootJobId", OtherKey="JobId", IsForeignKey=true, DeleteRule="CASCADE")]
2365    public Job RootJob
2366    {
2367      get
2368      {
2369        return this._Job.Entity;
2370      }
2371      set
2372      {
2373        if ((this._Job.Entity != value))
2374        {
2375          this.SendPropertyChanging();
2376          this._Job.Entity = value;
2377          this.SendPropertyChanged("RootJob");
2378        }
2379      }
2380    }
2381   
2382    public event PropertyChangingEventHandler PropertyChanging;
2383   
2384    public event PropertyChangedEventHandler PropertyChanged;
2385   
2386    protected virtual void SendPropertyChanging()
2387    {
2388      if ((this.PropertyChanging != null))
2389      {
2390        this.PropertyChanging(this, emptyChangingEventArgs);
2391      }
2392    }
2393   
2394    protected virtual void SendPropertyChanged(String propertyName)
2395    {
2396      if ((this.PropertyChanged != null))
2397      {
2398        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2399      }
2400    }
2401   
2402    private void attach_HiveExperimentPermissions(HiveExperimentPermission entity)
2403    {
2404      this.SendPropertyChanging();
2405      entity.HiveExperiment = this;
2406    }
2407   
2408    private void detach_HiveExperimentPermissions(HiveExperimentPermission entity)
2409    {
2410      this.SendPropertyChanging();
2411      entity.HiveExperiment = null;
2412    }
2413  }
2414 
2415  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.JobData")]
2416  public partial class JobData : INotifyPropertyChanging, INotifyPropertyChanged
2417  {
2418   
2419    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2420   
2421    private System.Guid _JobId;
2422   
2423    private System.Data.Linq.Binary _Data;
2424   
2425    private System.DateTime _LastUpdate;
2426   
2427    private EntityRef<Job> _Job;
2428   
2429    #region Extensibility Method Definitions
2430    partial void OnLoaded();
2431    partial void OnValidate(System.Data.Linq.ChangeAction action);
2432    partial void OnCreated();
2433    partial void OnJobIdChanging(System.Guid value);
2434    partial void OnJobIdChanged();
2435    partial void OnDataChanging(System.Data.Linq.Binary value);
2436    partial void OnDataChanged();
2437    partial void OnLastUpdateChanging(System.DateTime value);
2438    partial void OnLastUpdateChanged();
2439    #endregion
2440   
2441    public JobData()
2442    {
2443      this._Job = default(EntityRef<Job>);
2444      OnCreated();
2445    }
2446   
2447    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
2448    public System.Guid JobId
2449    {
2450      get
2451      {
2452        return this._JobId;
2453      }
2454      set
2455      {
2456        if ((this._JobId != value))
2457        {
2458          if (this._Job.HasLoadedOrAssignedValue)
2459          {
2460            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2461          }
2462          this.OnJobIdChanging(value);
2463          this.SendPropertyChanging();
2464          this._JobId = value;
2465          this.SendPropertyChanged("JobId");
2466          this.OnJobIdChanged();
2467        }
2468      }
2469    }
2470   
2471    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Data", DbType="VarBinary(MAX)", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
2472    public System.Data.Linq.Binary Data
2473    {
2474      get
2475      {
2476        return this._Data;
2477      }
2478      set
2479      {
2480        if ((this._Data != value))
2481        {
2482          this.OnDataChanging(value);
2483          this.SendPropertyChanging();
2484          this._Data = value;
2485          this.SendPropertyChanged("Data");
2486          this.OnDataChanged();
2487        }
2488      }
2489    }
2490   
2491    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastUpdate", DbType="DateTime")]
2492    public System.DateTime LastUpdate
2493    {
2494      get
2495      {
2496        return this._LastUpdate;
2497      }
2498      set
2499      {
2500        if ((this._LastUpdate != value))
2501        {
2502          this.OnLastUpdateChanging(value);
2503          this.SendPropertyChanging();
2504          this._LastUpdate = value;
2505          this.SendPropertyChanged("LastUpdate");
2506          this.OnLastUpdateChanged();
2507        }
2508      }
2509    }
2510   
2511    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_JobData", Storage="_Job", ThisKey="JobId", OtherKey="JobId", IsForeignKey=true)]
2512    public Job Job
2513    {
2514      get
2515      {
2516        return this._Job.Entity;
2517      }
2518      set
2519      {
2520        Job previousValue = this._Job.Entity;
2521        if (((previousValue != value)
2522              || (this._Job.HasLoadedOrAssignedValue == false)))
2523        {
2524          this.SendPropertyChanging();
2525          if ((previousValue != null))
2526          {
2527            this._Job.Entity = null;
2528            previousValue.JobData = null;
2529          }
2530          this._Job.Entity = value;
2531          if ((value != null))
2532          {
2533            value.JobData = this;
2534            this._JobId = value.JobId;
2535          }
2536          else
2537          {
2538            this._JobId = default(System.Guid);
2539          }
2540          this.SendPropertyChanged("Job");
2541        }
2542      }
2543    }
2544   
2545    public event PropertyChangingEventHandler PropertyChanging;
2546   
2547    public event PropertyChangedEventHandler PropertyChanged;
2548   
2549    protected virtual void SendPropertyChanging()
2550    {
2551      if ((this.PropertyChanging != null))
2552      {
2553        this.PropertyChanging(this, emptyChangingEventArgs);
2554      }
2555    }
2556   
2557    protected virtual void SendPropertyChanged(String propertyName)
2558    {
2559      if ((this.PropertyChanged != null))
2560      {
2561        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2562      }
2563    }
2564  }
2565 
2566  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.PluginData")]
2567  public partial class PluginData : INotifyPropertyChanging, INotifyPropertyChanged
2568  {
2569   
2570    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2571   
2572    private System.Guid _PluginDataId;
2573   
2574    private System.Guid _PluginId;
2575   
2576    private System.Data.Linq.Binary _Data;
2577   
2578    private string _FileName;
2579   
2580    private EntityRef<Plugin> _Plugin;
2581   
2582    #region Extensibility Method Definitions
2583    partial void OnLoaded();
2584    partial void OnValidate(System.Data.Linq.ChangeAction action);
2585    partial void OnCreated();
2586    partial void OnPluginDataIdChanging(System.Guid value);
2587    partial void OnPluginDataIdChanged();
2588    partial void OnPluginIdChanging(System.Guid value);
2589    partial void OnPluginIdChanged();
2590    partial void OnDataChanging(System.Data.Linq.Binary value);
2591    partial void OnDataChanged();
2592    partial void OnFileNameChanging(string value);
2593    partial void OnFileNameChanged();
2594    #endregion
2595   
2596    public PluginData()
2597    {
2598      this._Plugin = default(EntityRef<Plugin>);
2599      OnCreated();
2600    }
2601   
2602    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginDataId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
2603    public System.Guid PluginDataId
2604    {
2605      get
2606      {
2607        return this._PluginDataId;
2608      }
2609      set
2610      {
2611        if ((this._PluginDataId != value))
2612        {
2613          this.OnPluginDataIdChanging(value);
2614          this.SendPropertyChanging();
2615          this._PluginDataId = value;
2616          this.SendPropertyChanged("PluginDataId");
2617          this.OnPluginDataIdChanged();
2618        }
2619      }
2620    }
2621   
2622    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginId", DbType="UniqueIdentifier NOT NULL")]
2623    public System.Guid PluginId
2624    {
2625      get
2626      {
2627        return this._PluginId;
2628      }
2629      set
2630      {
2631        if ((this._PluginId != value))
2632        {
2633          if (this._Plugin.HasLoadedOrAssignedValue)
2634          {
2635            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2636          }
2637          this.OnPluginIdChanging(value);
2638          this.SendPropertyChanging();
2639          this._PluginId = value;
2640          this.SendPropertyChanged("PluginId");
2641          this.OnPluginIdChanged();
2642        }
2643      }
2644    }
2645   
2646    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Data", DbType="VarBinary(MAX) NOT NULL", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
2647    public System.Data.Linq.Binary Data
2648    {
2649      get
2650      {
2651        return this._Data;
2652      }
2653      set
2654      {
2655        if ((this._Data != value))
2656        {
2657          this.OnDataChanging(value);
2658          this.SendPropertyChanging();
2659          this._Data = value;
2660          this.SendPropertyChanged("Data");
2661          this.OnDataChanged();
2662        }
2663      }
2664    }
2665   
2666    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_FileName", DbType="VarChar(MAX)", CanBeNull=false)]
2667    public string FileName
2668    {
2669      get
2670      {
2671        return this._FileName;
2672      }
2673      set
2674      {
2675        if ((this._FileName != value))
2676        {
2677          this.OnFileNameChanging(value);
2678          this.SendPropertyChanging();
2679          this._FileName = value;
2680          this.SendPropertyChanged("FileName");
2681          this.OnFileNameChanged();
2682        }
2683      }
2684    }
2685   
2686    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_PluginData", Storage="_Plugin", ThisKey="PluginId", OtherKey="PluginId", IsForeignKey=true)]
2687    public Plugin Plugin
2688    {
2689      get
2690      {
2691        return this._Plugin.Entity;
2692      }
2693      set
2694      {
2695        Plugin previousValue = this._Plugin.Entity;
2696        if (((previousValue != value)
2697              || (this._Plugin.HasLoadedOrAssignedValue == false)))
2698        {
2699          this.SendPropertyChanging();
2700          if ((previousValue != null))
2701          {
2702            this._Plugin.Entity = null;
2703            previousValue.PluginData.Remove(this);
2704          }
2705          this._Plugin.Entity = value;
2706          if ((value != null))
2707          {
2708            value.PluginData.Add(this);
2709            this._PluginId = value.PluginId;
2710          }
2711          else
2712          {
2713            this._PluginId = default(System.Guid);
2714          }
2715          this.SendPropertyChanged("Plugin");
2716        }
2717      }
2718    }
2719   
2720    public event PropertyChangingEventHandler PropertyChanging;
2721   
2722    public event PropertyChangedEventHandler PropertyChanged;
2723   
2724    protected virtual void SendPropertyChanging()
2725    {
2726      if ((this.PropertyChanging != null))
2727      {
2728        this.PropertyChanging(this, emptyChangingEventArgs);
2729      }
2730    }
2731   
2732    protected virtual void SendPropertyChanged(String propertyName)
2733    {
2734      if ((this.PropertyChanged != null))
2735      {
2736        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
2737      }
2738    }
2739  }
2740 
2741  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.StateLog")]
2742  public partial class StateLog : INotifyPropertyChanging, INotifyPropertyChanged
2743  {
2744   
2745    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
2746   
2747    private System.Guid _StateLogId;
2748   
2749    private global::HeuristicLab.Services.Hive.Common.DataTransfer.JobState _State;
2750   
2751    private System.DateTime _DateTime;
2752   
2753    private System.Guid _JobId;
2754   
2755    private System.Nullable<System.Guid> _UserId;
2756   
2757    private System.Nullable<System.Guid> _SlaveId;
2758   
2759    private string _Exception;
2760   
2761    private EntityRef<Job> _Job;
2762   
2763    private EntityRef<Resource> _Resource;
2764   
2765    #region Extensibility Method Definitions
2766    partial void OnLoaded();
2767    partial void OnValidate(System.Data.Linq.ChangeAction action);
2768    partial void OnCreated();
2769    partial void OnStateLogIdChanging(System.Guid value);
2770    partial void OnStateLogIdChanged();
2771    partial void OnStateChanging(global::HeuristicLab.Services.Hive.Common.DataTransfer.JobState value);
2772    partial void OnStateChanged();
2773    partial void OnDateTimeChanging(System.DateTime value);
2774    partial void OnDateTimeChanged();
2775    partial void OnJobIdChanging(System.Guid value);
2776    partial void OnJobIdChanged();
2777    partial void OnUserIdChanging(System.Nullable<System.Guid> value);
2778    partial void OnUserIdChanged();
2779    partial void OnSlaveIdChanging(System.Nullable<System.Guid> value);
2780    partial void OnSlaveIdChanged();
2781    partial void OnExceptionChanging(string value);
2782    partial void OnExceptionChanged();
2783    #endregion
2784   
2785    public StateLog()
2786    {
2787      this._Job = default(EntityRef<Job>);
2788      this._Resource = default(EntityRef<Resource>);
2789      OnCreated();
2790    }
2791   
2792    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_StateLogId", AutoSync=AutoSync.OnInsert, DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true, IsDbGenerated=true)]
2793    public System.Guid StateLogId
2794    {
2795      get
2796      {
2797        return this._StateLogId;
2798      }
2799      set
2800      {
2801        if ((this._StateLogId != value))
2802        {
2803          this.OnStateLogIdChanging(value);
2804          this.SendPropertyChanging();
2805          this._StateLogId = value;
2806          this.SendPropertyChanged("StateLogId");
2807          this.OnStateLogIdChanged();
2808        }
2809      }
2810    }
2811   
2812    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_State", DbType="VarChar(30) NOT NULL", CanBeNull=false)]
2813    public global::HeuristicLab.Services.Hive.Common.DataTransfer.JobState State
2814    {
2815      get
2816      {
2817        return this._State;
2818      }
2819      set
2820      {
2821        if ((this._State != value))
2822        {
2823          this.OnStateChanging(value);
2824          this.SendPropertyChanging();
2825          this._State = value;
2826          this.SendPropertyChanged("State");
2827          this.OnStateChanged();
2828        }
2829      }
2830    }
2831   
2832    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DateTime", DbType="DateTime NOT NULL")]
2833    public System.DateTime DateTime
2834    {
2835      get
2836      {
2837        return this._DateTime;
2838      }
2839      set
2840      {
2841        if ((this._DateTime != value))
2842        {
2843          this.OnDateTimeChanging(value);
2844          this.SendPropertyChanging();
2845          this._DateTime = value;
2846          this.SendPropertyChanged("DateTime");
2847          this.OnDateTimeChanged();
2848        }
2849      }
2850    }
2851   
2852    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_JobId", DbType="UniqueIdentifier NOT NULL")]
2853    public System.Guid JobId
2854    {
2855      get
2856      {
2857        return this._JobId;
2858      }
2859      set
2860      {
2861        if ((this._JobId != value))
2862        {
2863          if (this._Job.HasLoadedOrAssignedValue)
2864          {
2865            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2866          }
2867          this.OnJobIdChanging(value);
2868          this.SendPropertyChanging();
2869          this._JobId = value;
2870          this.SendPropertyChanged("JobId");
2871          this.OnJobIdChanged();
2872        }
2873      }
2874    }
2875   
2876    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_UserId", DbType="UniqueIdentifier")]
2877    public System.Nullable<System.Guid> UserId
2878    {
2879      get
2880      {
2881        return this._UserId;
2882      }
2883      set
2884      {
2885        if ((this._UserId != value))
2886        {
2887          this.OnUserIdChanging(value);
2888          this.SendPropertyChanging();
2889          this._UserId = value;
2890          this.SendPropertyChanged("UserId");
2891          this.OnUserIdChanged();
2892        }
2893      }
2894    }
2895   
2896    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_SlaveId", DbType="UniqueIdentifier")]
2897    public System.Nullable<System.Guid> SlaveId
2898    {
2899      get
2900      {
2901        return this._SlaveId;
2902      }
2903      set
2904      {
2905        if ((this._SlaveId != value))
2906        {
2907          if (this._Resource.HasLoadedOrAssignedValue)
2908          {
2909            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
2910          }
2911          this.OnSlaveIdChanging(value);
2912          this.SendPropertyChanging();
2913          this._SlaveId = value;
2914          this.SendPropertyChanged("SlaveId");
2915          this.OnSlaveIdChanged();
2916        }
2917      }
2918    }
2919   
2920    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Exception", DbType="VarChar(MAX)", CanBeNull=false)]
2921    public string Exception
2922    {
2923      get
2924      {
2925        return this._Exception;
2926      }
2927      set
2928      {
2929        if ((this._Exception != value))
2930        {
2931          this.OnExceptionChanging(value);
2932          this.SendPropertyChanging();
2933          this._Exception = value;
2934          this.SendPropertyChanged("Exception");
2935          this.OnExceptionChanged();
2936        }
2937      }
2938    }
2939   
2940    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Job_StateLog", Storage="_Job", ThisKey="JobId", OtherKey="JobId", IsForeignKey=true)]
2941    public Job Job
2942    {
2943      get
2944      {
2945        return this._Job.Entity;
2946      }
2947      set
2948      {
2949        Job previousValue = this._Job.Entity;
2950        if (((previousValue != value)
2951              || (this._Job.HasLoadedOrAssignedValue == false)))
2952        {
2953          this.SendPropertyChanging();
2954          if ((previousValue != null))
2955          {
2956            this._Job.Entity = null;
2957            previousValue.StateLogs.Remove(this);
2958          }
2959          this._Job.Entity = value;
2960          if ((value != null))
2961          {
2962            value.StateLogs.Add(this);
2963            this._JobId = value.JobId;
2964          }
2965          else
2966          {
2967            this._JobId = default(System.Guid);
2968          }
2969          this.SendPropertyChanged("Job");
2970        }
2971      }
2972    }
2973   
2974    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Resource_StateLog", Storage="_Resource", ThisKey="SlaveId", OtherKey="ResourceId", IsForeignKey=true)]
2975    public Resource Resource
2976    {
2977      get
2978      {
2979        return this._Resource.Entity;
2980      }
2981      set
2982      {
2983        Resource previousValue = this._Resource.Entity;
2984        if (((previousValue != value)
2985              || (this._Resource.HasLoadedOrAssignedValue == false)))
2986        {
2987          this.SendPropertyChanging();
2988          if ((previousValue != null))
2989          {
2990            this._Resource.Entity = null;
2991            previousValue.StateLogs.Remove(this);
2992          }
2993          this._Resource.Entity = value;
2994          if ((value != null))
2995          {
2996            value.StateLogs.Add(this);
2997            this._SlaveId = value.ResourceId;
2998          }
2999          else
3000          {
3001            this._SlaveId = default(Nullable<System.Guid>);
3002          }
3003          this.SendPropertyChanged("Resource");
3004        }
3005      }
3006    }
3007   
3008    public event PropertyChangingEventHandler PropertyChanging;
3009   
3010    public event PropertyChangedEventHandler PropertyChanged;
3011   
3012    protected virtual void SendPropertyChanging()
3013    {
3014      if ((this.PropertyChanging != null))
3015      {
3016        this.PropertyChanging(this, emptyChangingEventArgs);
3017      }
3018    }
3019   
3020    protected virtual void SendPropertyChanged(String propertyName)
3021    {
3022      if ((this.PropertyChanged != null))
3023      {
3024        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3025      }
3026    }
3027  }
3028 
3029  [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.HiveExperimentPermission")]
3030  public partial class HiveExperimentPermission : INotifyPropertyChanging, INotifyPropertyChanged
3031  {
3032   
3033    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3034   
3035    private System.Guid _HiveExperimentId;
3036   
3037    private System.Guid _GrantedUserId;
3038   
3039    private System.Guid _GrantedByUserId;
3040   
3041    private global::HeuristicLab.Services.Hive.Common.DataTransfer.Permission _Permission;
3042   
3043    private EntityRef<HiveExperiment> _HiveExperiment;
3044   
3045    #region Extensibility Method Definitions
3046    partial void OnLoaded();
3047    partial void OnValidate(System.Data.Linq.ChangeAction action);
3048    partial void OnCreated();
3049    partial void OnHiveExperimentIdChanging(System.Guid value);
3050    partial void OnHiveExperimentIdChanged();
3051    partial void OnGrantedUserIdChanging(System.Guid value);
3052    partial void OnGrantedUserIdChanged();
3053    partial void OnGrantedByUserIdChanging(System.Guid value);
3054    partial void OnGrantedByUserIdChanged();
3055    partial void OnPermissionChanging(global::HeuristicLab.Services.Hive.Common.DataTransfer.Permission value);
3056    partial void OnPermissionChanged();
3057    #endregion
3058   
3059    public HiveExperimentPermission()
3060    {
3061      this._HiveExperiment = default(EntityRef<HiveExperiment>);
3062      OnCreated();
3063    }
3064   
3065    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_HiveExperimentId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
3066    public System.Guid HiveExperimentId
3067    {
3068      get
3069      {
3070        return this._HiveExperimentId;
3071      }
3072      set
3073      {
3074        if ((this._HiveExperimentId != value))
3075        {
3076          if (this._HiveExperiment.HasLoadedOrAssignedValue)
3077          {
3078            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
3079          }
3080          this.OnHiveExperimentIdChanging(value);
3081          this.SendPropertyChanging();
3082          this._HiveExperimentId = value;
3083          this.SendPropertyChanged("HiveExperimentId");
3084          this.OnHiveExperimentIdChanged();
3085        }
3086      }
3087    }
3088   
3089    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GrantedUserId", DbType="UniqueIdentifier NOT NULL", IsPrimaryKey=true)]
3090    public System.Guid GrantedUserId
3091    {
3092      get
3093      {
3094        return this._GrantedUserId;
3095      }
3096      set
3097      {
3098        if ((this._GrantedUserId != value))
3099        {
3100          this.OnGrantedUserIdChanging(value);
3101          this.SendPropertyChanging();
3102          this._GrantedUserId = value;
3103          this.SendPropertyChanged("GrantedUserId");
3104          this.OnGrantedUserIdChanged();
3105        }
3106      }
3107    }
3108   
3109    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_GrantedByUserId", DbType="UniqueIdentifier NOT NULL")]
3110    public System.Guid GrantedByUserId
3111    {
3112      get
3113      {
3114        return this._GrantedByUserId;
3115      }
3116      set
3117      {
3118        if ((this._GrantedByUserId != value))
3119        {
3120          this.OnGrantedByUserIdChanging(value);
3121          this.SendPropertyChanging();
3122          this._GrantedByUserId = value;
3123          this.SendPropertyChanged("GrantedByUserId");
3124          this.OnGrantedByUserIdChanged();
3125        }
3126      }
3127    }
3128   
3129    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Permission", DbType="VarChar(15) NOT NULL", CanBeNull=false)]
3130    public global::HeuristicLab.Services.Hive.Common.DataTransfer.Permission Permission
3131    {
3132      get
3133      {
3134        return this._Permission;
3135      }
3136      set
3137      {
3138        if ((this._Permission != value))
3139        {
3140          this.OnPermissionChanging(value);
3141          this.SendPropertyChanging();
3142          this._Permission = value;
3143          this.SendPropertyChanged("Permission");
3144          this.OnPermissionChanged();
3145        }
3146      }
3147    }
3148   
3149    [global::System.Data.Linq.Mapping.AssociationAttribute(Name="HiveExperiment_HiveExperimentPermission", Storage="_HiveExperiment", ThisKey="HiveExperimentId", OtherKey="HiveExperimentId", IsForeignKey=true)]
3150    public HiveExperiment HiveExperiment
3151    {
3152      get
3153      {
3154        return this._HiveExperiment.Entity;
3155      }
3156      set
3157      {
3158        HiveExperiment previousValue = this._HiveExperiment.Entity;
3159        if (((previousValue != value)
3160              || (this._HiveExperiment.HasLoadedOrAssignedValue == false)))
3161        {
3162          this.SendPropertyChanging();
3163          if ((previousValue != null))
3164          {
3165            this._HiveExperiment.Entity = null;
3166            previousValue.HiveExperimentPermissions.Remove(this);
3167          }
3168          this._HiveExperiment.Entity = value;
3169          if ((value != null))
3170          {
3171            value.HiveExperimentPermissions.Add(this);
3172            this._HiveExperimentId = value.HiveExperimentId;
3173          }
3174          else
3175          {
3176            this._HiveExperimentId = default(System.Guid);
3177          }
3178          this.SendPropertyChanged("HiveExperiment");
3179        }
3180      }
3181    }
3182   
3183    public event PropertyChangingEventHandler PropertyChanging;
3184   
3185    public event PropertyChangedEventHandler PropertyChanged;
3186   
3187    protected virtual void SendPropertyChanging()
3188    {
3189      if ((this.PropertyChanging != null))
3190      {
3191        this.PropertyChanging(this, emptyChangingEventArgs);
3192      }
3193    }
3194   
3195    protected virtual void SendPropertyChanged(String propertyName)
3196    {
3197      if ((this.PropertyChanged != null))
3198      {
3199        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3200      }
3201    }
3202  }
3203 
3204  [global::System.Data.Linq.Mapping.TableAttribute(Name="")]
3205  public partial class Lifecycle : INotifyPropertyChanging, INotifyPropertyChanged
3206  {
3207   
3208    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
3209   
3210    private int _LifecycleId;
3211   
3212    private System.DateTime _LastCleanup;
3213   
3214    #region Extensibility Method Definitions
3215    partial void OnLoaded();
3216    partial void OnValidate(System.Data.Linq.ChangeAction action);
3217    partial void OnCreated();
3218    partial void OnLifecycleIdChanging(int value);
3219    partial void OnLifecycleIdChanged();
3220    partial void OnLastCleanupChanging(System.DateTime value);
3221    partial void OnLastCleanupChanged();
3222    #endregion
3223   
3224    public Lifecycle()
3225    {
3226      OnCreated();
3227    }
3228   
3229    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LifecycleId", DbType="Int", IsPrimaryKey=true)]
3230    public int LifecycleId
3231    {
3232      get
3233      {
3234        return this._LifecycleId;
3235      }
3236      set
3237      {
3238        if ((this._LifecycleId != value))
3239        {
3240          this.OnLifecycleIdChanging(value);
3241          this.SendPropertyChanging();
3242          this._LifecycleId = value;
3243          this.SendPropertyChanged("LifecycleId");
3244          this.OnLifecycleIdChanged();
3245        }
3246      }
3247    }
3248   
3249    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_LastCleanup", DbType="DateTime")]
3250    public System.DateTime LastCleanup
3251    {
3252      get
3253      {
3254        return this._LastCleanup;
3255      }
3256      set
3257      {
3258        if ((this._LastCleanup != value))
3259        {
3260          this.OnLastCleanupChanging(value);
3261          this.SendPropertyChanging();
3262          this._LastCleanup = value;
3263          this.SendPropertyChanged("LastCleanup");
3264          this.OnLastCleanupChanged();
3265        }
3266      }
3267    }
3268   
3269    public event PropertyChangingEventHandler PropertyChanging;
3270   
3271    public event PropertyChangedEventHandler PropertyChanged;
3272   
3273    protected virtual void SendPropertyChanging()
3274    {
3275      if ((this.PropertyChanging != null))
3276      {
3277        this.PropertyChanging(this, emptyChangingEventArgs);
3278      }
3279    }
3280   
3281    protected virtual void SendPropertyChanged(String propertyName)
3282    {
3283      if ((this.PropertyChanged != null))
3284      {
3285        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
3286      }
3287    }
3288  }
3289}
3290#pragma warning restore 1591
Note: See TracBrowser for help on using the repository browser.