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

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

#1233

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