Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
07/22/10 00:44:01 (14 years ago)
Author:
swagner
Message:

Sorted usings and removed unused usings in entire solution (#1094)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.Services.Deployment.DataAccess/3.3/PluginStoreClasses.designer.cs

    r4065 r4068  
    1010//------------------------------------------------------------------------------
    1111
    12 namespace HeuristicLab.Services.Deployment.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.PluginStore")]
    26   public partial class PluginStoreClassesDataContext : System.Data.Linq.DataContext
    27   {
    28    
    29     private static System.Data.Linq.Mapping.MappingSource mappingSource = new AttributeMappingSource();
    30    
     12namespace HeuristicLab.Services.Deployment.DataAccess {
     13  using System;
     14  using System.ComponentModel;
     15  using System.Data.Linq;
     16  using System.Data.Linq.Mapping;
     17
     18
     19  [global::System.Data.Linq.Mapping.DatabaseAttribute(Name = "HeuristicLab.PluginStore")]
     20  public partial class PluginStoreClassesDataContext : System.Data.Linq.DataContext {
     21
     22    private static System.Data.Linq.Mapping.MappingSource mappingSource = new AttributeMappingSource();
     23
    3124    #region Extensibility Method Definitions
    3225    partial void OnCreated();
    … …  
    4740    partial void DeleteProduct(Product instance);
    4841    #endregion
    49    
    50     public PluginStoreClassesDataContext() :
    51         base(global::HeuristicLab.Services.Deployment.DataAccess.Properties.Settings.Default.HeuristicLab_PluginStoreConnectionString, mappingSource)
    52     {
    53       OnCreated();
    54     }
    55    
    56     public PluginStoreClassesDataContext(string connection) :
    57         base(connection, mappingSource)
    58     {
    59       OnCreated();
    60     }
    61    
    62     public PluginStoreClassesDataContext(System.Data.IDbConnection connection) :
    63         base(connection, mappingSource)
    64     {
    65       OnCreated();
    66     }
    67    
    68     public PluginStoreClassesDataContext(string connection, System.Data.Linq.Mapping.MappingSource mappingSource) :
    69         base(connection, mappingSource)
    70     {
    71       OnCreated();
    72     }
    73    
    74     public PluginStoreClassesDataContext(System.Data.IDbConnection connection, System.Data.Linq.Mapping.MappingSource mappingSource) :
    75         base(connection, mappingSource)
    76     {
    77       OnCreated();
    78     }
    79    
    80     public System.Data.Linq.Table<Dependency> Dependencies
    81     {
    82       get
    83       {
    84         return this.GetTable<Dependency>();
    85       }
    86     }
    87    
    88     public System.Data.Linq.Table<ProductPlugin> ProductPlugins
    89     {
    90       get
    91       {
    92         return this.GetTable<ProductPlugin>();
    93       }
    94     }
    95    
    96     public System.Data.Linq.Table<Plugin> Plugins
    97     {
    98       get
    99       {
    100         return this.GetTable<Plugin>();
    101       }
    102     }
    103    
    104     public System.Data.Linq.Table<PluginPackage> PluginPackages
    105     {
    106       get
    107       {
    108         return this.GetTable<PluginPackage>();
    109       }
    110     }
    111    
    112     public System.Data.Linq.Table<Product> Products
    113     {
    114       get
    115       {
    116         return this.GetTable<Product>();
    117       }
    118     }
    119   }
    120  
    121   [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Dependencies")]
    122   public partial class Dependency : INotifyPropertyChanging, INotifyPropertyChanged
    123   {
    124    
    125     private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    126    
    127     private long _PluginId;
    128    
    129     private long _DependencyId;
    130    
     42
     43    public PluginStoreClassesDataContext() :
     44      base(global::HeuristicLab.Services.Deployment.DataAccess.Properties.Settings.Default.HeuristicLab_PluginStoreConnectionString, mappingSource) {
     45      OnCreated();
     46    }
     47
     48    public PluginStoreClassesDataContext(string connection) :
     49      base(connection, mappingSource) {
     50      OnCreated();
     51    }
     52
     53    public PluginStoreClassesDataContext(System.Data.IDbConnection connection) :
     54      base(connection, mappingSource) {
     55      OnCreated();
     56    }
     57
     58    public PluginStoreClassesDataContext(string connection, System.Data.Linq.Mapping.MappingSource mappingSource) :
     59      base(connection, mappingSource) {
     60      OnCreated();
     61    }
     62
     63    public PluginStoreClassesDataContext(System.Data.IDbConnection connection, System.Data.Linq.Mapping.MappingSource mappingSource) :
     64      base(connection, mappingSource) {
     65      OnCreated();
     66    }
     67
     68    public System.Data.Linq.Table<Dependency> Dependencies {
     69      get {
     70        return this.GetTable<Dependency>();
     71      }
     72    }
     73
     74    public System.Data.Linq.Table<ProductPlugin> ProductPlugins {
     75      get {
     76        return this.GetTable<ProductPlugin>();
     77      }
     78    }
     79
     80    public System.Data.Linq.Table<Plugin> Plugins {
     81      get {
     82        return this.GetTable<Plugin>();
     83      }
     84    }
     85
     86    public System.Data.Linq.Table<PluginPackage> PluginPackages {
     87      get {
     88        return this.GetTable<PluginPackage>();
     89      }
     90    }
     91
     92    public System.Data.Linq.Table<Product> Products {
     93      get {
     94        return this.GetTable<Product>();
     95      }
     96    }
     97  }
     98
     99  [global::System.Data.Linq.Mapping.TableAttribute(Name = "dbo.Dependencies")]
     100  public partial class Dependency : INotifyPropertyChanging, INotifyPropertyChanged {
     101
     102    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
     103
     104    private long _PluginId;
     105
     106    private long _DependencyId;
     107
    131108    #region Extensibility Method Definitions
    132109    partial void OnLoaded();
    … …  
    138115    partial void OnDependencyIdChanged();
    139116    #endregion
    140    
    141     public Dependency()
    142     {
    143       OnCreated();
    144     }
    145    
    146     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginId", DbType="BigInt NOT NULL", IsPrimaryKey=true)]
    147     public long PluginId
    148     {
    149       get
    150       {
    151         return this._PluginId;
    152       }
    153       set
    154       {
    155         if ((this._PluginId != value))
    156         {
    157           this.OnPluginIdChanging(value);
    158           this.SendPropertyChanging();
    159           this._PluginId = value;
    160           this.SendPropertyChanged("PluginId");
    161           this.OnPluginIdChanged();
    162         }
    163       }
    164     }
    165    
    166     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_DependencyId", DbType="BigInt NOT NULL", IsPrimaryKey=true)]
    167     public long DependencyId
    168     {
    169       get
    170       {
    171         return this._DependencyId;
    172       }
    173       set
    174       {
    175         if ((this._DependencyId != value))
    176         {
    177           this.OnDependencyIdChanging(value);
    178           this.SendPropertyChanging();
    179           this._DependencyId = value;
    180           this.SendPropertyChanged("DependencyId");
    181           this.OnDependencyIdChanged();
    182         }
    183       }
    184     }
    185    
    186     public event PropertyChangingEventHandler PropertyChanging;
    187    
    188     public event PropertyChangedEventHandler PropertyChanged;
    189    
    190     protected virtual void SendPropertyChanging()
    191     {
    192       if ((this.PropertyChanging != null))
    193       {
    194         this.PropertyChanging(this, emptyChangingEventArgs);
    195       }
    196     }
    197    
    198     protected virtual void SendPropertyChanged(String propertyName)
    199     {
    200       if ((this.PropertyChanged != null))
    201       {
    202         this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    203       }
    204     }
    205   }
    206  
    207   [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.ProductPlugin")]
    208   public partial class ProductPlugin : INotifyPropertyChanging, INotifyPropertyChanged
    209   {
    210    
    211     private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    212    
    213     private long _ProductId;
    214    
    215     private long _PluginId;
    216    
     117
     118    public Dependency() {
     119      OnCreated();
     120    }
     121
     122    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_PluginId", DbType = "BigInt NOT NULL", IsPrimaryKey = true)]
     123    public long PluginId {
     124      get {
     125        return this._PluginId;
     126      }
     127      set {
     128        if ((this._PluginId != value)) {
     129          this.OnPluginIdChanging(value);
     130          this.SendPropertyChanging();
     131          this._PluginId = value;
     132          this.SendPropertyChanged("PluginId");
     133          this.OnPluginIdChanged();
     134        }
     135      }
     136    }
     137
     138    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_DependencyId", DbType = "BigInt NOT NULL", IsPrimaryKey = true)]
     139    public long DependencyId {
     140      get {
     141        return this._DependencyId;
     142      }
     143      set {
     144        if ((this._DependencyId != value)) {
     145          this.OnDependencyIdChanging(value);
     146          this.SendPropertyChanging();
     147          this._DependencyId = value;
     148          this.SendPropertyChanged("DependencyId");
     149          this.OnDependencyIdChanged();
     150        }
     151      }
     152    }
     153
     154    public event PropertyChangingEventHandler PropertyChanging;
     155
     156    public event PropertyChangedEventHandler PropertyChanged;
     157
     158    protected virtual void SendPropertyChanging() {
     159      if ((this.PropertyChanging != null)) {
     160        this.PropertyChanging(this, emptyChangingEventArgs);
     161      }
     162    }
     163
     164    protected virtual void SendPropertyChanged(String propertyName) {
     165      if ((this.PropertyChanged != null)) {
     166        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
     167      }
     168    }
     169  }
     170
     171  [global::System.Data.Linq.Mapping.TableAttribute(Name = "dbo.ProductPlugin")]
     172  public partial class ProductPlugin : INotifyPropertyChanging, INotifyPropertyChanged {
     173
     174    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
     175
     176    private long _ProductId;
     177
     178    private long _PluginId;
     179
    217180    #region Extensibility Method Definitions
    218181    partial void OnLoaded();
    … …  
    224187    partial void OnPluginIdChanged();
    225188    #endregion
    226    
    227     public ProductPlugin()
    228     {
    229       OnCreated();
    230     }
    231    
    232     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ProductId", DbType="BigInt NOT NULL", IsPrimaryKey=true)]
    233     public long ProductId
    234     {
    235       get
    236       {
    237         return this._ProductId;
    238       }
    239       set
    240       {
    241         if ((this._ProductId != value))
    242         {
    243           this.OnProductIdChanging(value);
    244           this.SendPropertyChanging();
    245           this._ProductId = value;
    246           this.SendPropertyChanged("ProductId");
    247           this.OnProductIdChanged();
    248         }
    249       }
    250     }
    251    
    252     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginId", DbType="BigInt NOT NULL", IsPrimaryKey=true)]
    253     public long PluginId
    254     {
    255       get
    256       {
    257         return this._PluginId;
    258       }
    259       set
    260       {
    261         if ((this._PluginId != value))
    262         {
    263           this.OnPluginIdChanging(value);
    264           this.SendPropertyChanging();
    265           this._PluginId = value;
    266           this.SendPropertyChanged("PluginId");
    267           this.OnPluginIdChanged();
    268         }
    269       }
    270     }
    271    
    272     public event PropertyChangingEventHandler PropertyChanging;
    273    
    274     public event PropertyChangedEventHandler PropertyChanged;
    275    
    276     protected virtual void SendPropertyChanging()
    277     {
    278       if ((this.PropertyChanging != null))
    279       {
    280         this.PropertyChanging(this, emptyChangingEventArgs);
    281       }
    282     }
    283    
    284     protected virtual void SendPropertyChanged(String propertyName)
    285     {
    286       if ((this.PropertyChanged != null))
    287       {
    288         this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    289       }
    290     }
    291   }
    292  
    293   [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Plugin")]
    294   public partial class Plugin : INotifyPropertyChanging, INotifyPropertyChanged
    295   {
    296    
    297     private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    298    
    299     private long _Id;
    300    
    301     private string _Name;
    302    
    303     private string _Version;
    304    
    305     private string _ContactName;
    306    
    307     private string _ContactEmail;
    308    
    309     private string _License;
    310    
    311     private EntityRef<PluginPackage> _PluginPackage;
    312    
     189
     190    public ProductPlugin() {
     191      OnCreated();
     192    }
     193
     194    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_ProductId", DbType = "BigInt NOT NULL", IsPrimaryKey = true)]
     195    public long ProductId {
     196      get {
     197        return this._ProductId;
     198      }
     199      set {
     200        if ((this._ProductId != value)) {
     201          this.OnProductIdChanging(value);
     202          this.SendPropertyChanging();
     203          this._ProductId = value;
     204          this.SendPropertyChanged("ProductId");
     205          this.OnProductIdChanged();
     206        }
     207      }
     208    }
     209
     210    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_PluginId", DbType = "BigInt NOT NULL", IsPrimaryKey = true)]
     211    public long PluginId {
     212      get {
     213        return this._PluginId;
     214      }
     215      set {
     216        if ((this._PluginId != value)) {
     217          this.OnPluginIdChanging(value);
     218          this.SendPropertyChanging();
     219          this._PluginId = value;
     220          this.SendPropertyChanged("PluginId");
     221          this.OnPluginIdChanged();
     222        }
     223      }
     224    }
     225
     226    public event PropertyChangingEventHandler PropertyChanging;
     227
     228    public event PropertyChangedEventHandler PropertyChanged;
     229
     230    protected virtual void SendPropertyChanging() {
     231      if ((this.PropertyChanging != null)) {
     232        this.PropertyChanging(this, emptyChangingEventArgs);
     233      }
     234    }
     235
     236    protected virtual void SendPropertyChanged(String propertyName) {
     237      if ((this.PropertyChanged != null)) {
     238        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
     239      }
     240    }
     241  }
     242
     243  [global::System.Data.Linq.Mapping.TableAttribute(Name = "dbo.Plugin")]
     244  public partial class Plugin : INotifyPropertyChanging, INotifyPropertyChanged {
     245
     246    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
     247
     248    private long _Id;
     249
     250    private string _Name;
     251
     252    private string _Version;
     253
     254    private string _ContactName;
     255
     256    private string _ContactEmail;
     257
     258    private string _License;
     259
     260    private EntityRef<PluginPackage> _PluginPackage;
     261
    313262    #region Extensibility Method Definitions
    314263    partial void OnLoaded();
    … …  
    328277    partial void OnLicenseChanged();
    329278    #endregion
    330    
    331     public Plugin()
    332     {
    333       this._PluginPackage = default(EntityRef<PluginPackage>);
    334       OnCreated();
    335     }
    336    
    337     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true)]
    338     public long Id
    339     {
    340       get
    341       {
    342         return this._Id;
    343       }
    344       set
    345       {
    346         if ((this._Id != value))
    347         {
    348           this.OnIdChanging(value);
    349           this.SendPropertyChanging();
    350           this._Id = value;
    351           this.SendPropertyChanged("Id");
    352           this.OnIdChanged();
    353         }
    354       }
    355     }
    356    
    357     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(300) NOT NULL", CanBeNull=false)]
    358     public string Name
    359     {
    360       get
    361       {
    362         return this._Name;
    363       }
    364       set
    365       {
    366         if ((this._Name != value))
    367         {
    368           this.OnNameChanging(value);
    369           this.SendPropertyChanging();
    370           this._Name = value;
    371           this.SendPropertyChanged("Name");
    372           this.OnNameChanged();
    373         }
    374       }
    375     }
    376    
    377     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Version", DbType="NVarChar(50) NOT NULL", CanBeNull=false)]
    378     public string Version
    379     {
    380       get
    381       {
    382         return this._Version;
    383       }
    384       set
    385       {
    386         if ((this._Version != value))
    387         {
    388           this.OnVersionChanging(value);
    389           this.SendPropertyChanging();
    390           this._Version = value;
    391           this.SendPropertyChanged("Version");
    392           this.OnVersionChanged();
    393         }
    394       }
    395     }
    396    
    397     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ContactName", DbType="Text", UpdateCheck=UpdateCheck.Never)]
    398     public string ContactName
    399     {
    400       get
    401       {
    402         return this._ContactName;
    403       }
    404       set
    405       {
    406         if ((this._ContactName != value))
    407         {
    408           this.OnContactNameChanging(value);
    409           this.SendPropertyChanging();
    410           this._ContactName = value;
    411           this.SendPropertyChanged("ContactName");
    412           this.OnContactNameChanged();
    413         }
    414       }
    415     }
    416    
    417     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_ContactEmail", DbType="Text", UpdateCheck=UpdateCheck.Never)]
    418     public string ContactEmail
    419     {
    420       get
    421       {
    422         return this._ContactEmail;
    423       }
    424       set
    425       {
    426         if ((this._ContactEmail != value))
    427         {
    428           this.OnContactEmailChanging(value);
    429           this.SendPropertyChanging();
    430           this._ContactEmail = value;
    431           this.SendPropertyChanged("ContactEmail");
    432           this.OnContactEmailChanged();
    433         }
    434       }
    435     }
    436    
    437     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_License", DbType="Text", UpdateCheck=UpdateCheck.Never)]
    438     public string License
    439     {
    440       get
    441       {
    442         return this._License;
    443       }
    444       set
    445       {
    446         if ((this._License != value))
    447         {
    448           this.OnLicenseChanging(value);
    449           this.SendPropertyChanging();
    450           this._License = value;
    451           this.SendPropertyChanged("License");
    452           this.OnLicenseChanged();
    453         }
    454       }
    455     }
    456    
    457     [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_PluginPackage", Storage="_PluginPackage", ThisKey="Id", OtherKey="PluginId", IsUnique=true, IsForeignKey=false)]
    458     public PluginPackage PluginPackage
    459     {
    460       get
    461       {
    462         return this._PluginPackage.Entity;
    463       }
    464       set
    465       {
    466         PluginPackage previousValue = this._PluginPackage.Entity;
    467         if (((previousValue != value)
    468               || (this._PluginPackage.HasLoadedOrAssignedValue == false)))
    469         {
    470           this.SendPropertyChanging();
    471           if ((previousValue != null))
    472           {
    473             this._PluginPackage.Entity = null;
    474             previousValue.Plugin = null;
    475           }
    476           this._PluginPackage.Entity = value;
    477           if ((value != null))
    478           {
    479             value.Plugin = this;
    480           }
    481           this.SendPropertyChanged("PluginPackage");
    482         }
    483       }
    484     }
    485    
    486     public event PropertyChangingEventHandler PropertyChanging;
    487    
    488     public event PropertyChangedEventHandler PropertyChanged;
    489    
    490     protected virtual void SendPropertyChanging()
    491     {
    492       if ((this.PropertyChanging != null))
    493       {
    494         this.PropertyChanging(this, emptyChangingEventArgs);
    495       }
    496     }
    497    
    498     protected virtual void SendPropertyChanged(String propertyName)
    499     {
    500       if ((this.PropertyChanged != null))
    501       {
    502         this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    503       }
    504     }
    505   }
    506  
    507   [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.PluginPackage")]
    508   public partial class PluginPackage : INotifyPropertyChanging, INotifyPropertyChanged
    509   {
    510    
    511     private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    512    
    513     private long _PluginId;
    514    
    515     private System.Data.Linq.Binary _Data;
    516    
    517     private EntityRef<Plugin> _Plugin;
    518    
     279
     280    public Plugin() {
     281      this._PluginPackage = default(EntityRef<PluginPackage>);
     282      OnCreated();
     283    }
     284
     285    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_Id", AutoSync = AutoSync.OnInsert, DbType = "BigInt NOT NULL IDENTITY", IsPrimaryKey = true, IsDbGenerated = true)]
     286    public long Id {
     287      get {
     288        return this._Id;
     289      }
     290      set {
     291        if ((this._Id != value)) {
     292          this.OnIdChanging(value);
     293          this.SendPropertyChanging();
     294          this._Id = value;
     295          this.SendPropertyChanged("Id");
     296          this.OnIdChanged();
     297        }
     298      }
     299    }
     300
     301    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_Name", DbType = "NVarChar(300) NOT NULL", CanBeNull = false)]
     302    public string Name {
     303      get {
     304        return this._Name;
     305      }
     306      set {
     307        if ((this._Name != value)) {
     308          this.OnNameChanging(value);
     309          this.SendPropertyChanging();
     310          this._Name = value;
     311          this.SendPropertyChanged("Name");
     312          this.OnNameChanged();
     313        }
     314      }
     315    }
     316
     317    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_Version", DbType = "NVarChar(50) NOT NULL", CanBeNull = false)]
     318    public string Version {
     319      get {
     320        return this._Version;
     321      }
     322      set {
     323        if ((this._Version != value)) {
     324          this.OnVersionChanging(value);
     325          this.SendPropertyChanging();
     326          this._Version = value;
     327          this.SendPropertyChanged("Version");
     328          this.OnVersionChanged();
     329        }
     330      }
     331    }
     332
     333    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_ContactName", DbType = "Text", UpdateCheck = UpdateCheck.Never)]
     334    public string ContactName {
     335      get {
     336        return this._ContactName;
     337      }
     338      set {
     339        if ((this._ContactName != value)) {
     340          this.OnContactNameChanging(value);
     341          this.SendPropertyChanging();
     342          this._ContactName = value;
     343          this.SendPropertyChanged("ContactName");
     344          this.OnContactNameChanged();
     345        }
     346      }
     347    }
     348
     349    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_ContactEmail", DbType = "Text", UpdateCheck = UpdateCheck.Never)]
     350    public string ContactEmail {
     351      get {
     352        return this._ContactEmail;
     353      }
     354      set {
     355        if ((this._ContactEmail != value)) {
     356          this.OnContactEmailChanging(value);
     357          this.SendPropertyChanging();
     358          this._ContactEmail = value;
     359          this.SendPropertyChanged("ContactEmail");
     360          this.OnContactEmailChanged();
     361        }
     362      }
     363    }
     364
     365    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_License", DbType = "Text", UpdateCheck = UpdateCheck.Never)]
     366    public string License {
     367      get {
     368        return this._License;
     369      }
     370      set {
     371        if ((this._License != value)) {
     372          this.OnLicenseChanging(value);
     373          this.SendPropertyChanging();
     374          this._License = value;
     375          this.SendPropertyChanged("License");
     376          this.OnLicenseChanged();
     377        }
     378      }
     379    }
     380
     381    [global::System.Data.Linq.Mapping.AssociationAttribute(Name = "Plugin_PluginPackage", Storage = "_PluginPackage", ThisKey = "Id", OtherKey = "PluginId", IsUnique = true, IsForeignKey = false)]
     382    public PluginPackage PluginPackage {
     383      get {
     384        return this._PluginPackage.Entity;
     385      }
     386      set {
     387        PluginPackage previousValue = this._PluginPackage.Entity;
     388        if (((previousValue != value)
     389              || (this._PluginPackage.HasLoadedOrAssignedValue == false))) {
     390          this.SendPropertyChanging();
     391          if ((previousValue != null)) {
     392            this._PluginPackage.Entity = null;
     393            previousValue.Plugin = null;
     394          }
     395          this._PluginPackage.Entity = value;
     396          if ((value != null)) {
     397            value.Plugin = this;
     398          }
     399          this.SendPropertyChanged("PluginPackage");
     400        }
     401      }
     402    }
     403
     404    public event PropertyChangingEventHandler PropertyChanging;
     405
     406    public event PropertyChangedEventHandler PropertyChanged;
     407
     408    protected virtual void SendPropertyChanging() {
     409      if ((this.PropertyChanging != null)) {
     410        this.PropertyChanging(this, emptyChangingEventArgs);
     411      }
     412    }
     413
     414    protected virtual void SendPropertyChanged(String propertyName) {
     415      if ((this.PropertyChanged != null)) {
     416        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
     417      }
     418    }
     419  }
     420
     421  [global::System.Data.Linq.Mapping.TableAttribute(Name = "dbo.PluginPackage")]
     422  public partial class PluginPackage : INotifyPropertyChanging, INotifyPropertyChanged {
     423
     424    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
     425
     426    private long _PluginId;
     427
     428    private System.Data.Linq.Binary _Data;
     429
     430    private EntityRef<Plugin> _Plugin;
     431
    519432    #region Extensibility Method Definitions
    520433    partial void OnLoaded();
    … …  
    526439    partial void OnDataChanged();
    527440    #endregion
    528    
    529     public PluginPackage()
    530     {
    531       this._Plugin = default(EntityRef<Plugin>);
    532       OnCreated();
    533     }
    534    
    535     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_PluginId", DbType="BigInt NOT NULL", IsPrimaryKey=true)]
    536     public long PluginId
    537     {
    538       get
    539       {
    540         return this._PluginId;
    541       }
    542       set
    543       {
    544         if ((this._PluginId != value))
    545         {
    546           if (this._Plugin.HasLoadedOrAssignedValue)
    547           {
    548             throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
    549           }
    550           this.OnPluginIdChanging(value);
    551           this.SendPropertyChanging();
    552           this._PluginId = value;
    553           this.SendPropertyChanged("PluginId");
    554           this.OnPluginIdChanged();
    555         }
    556       }
    557     }
    558    
    559     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Data", DbType="Image NOT NULL", CanBeNull=false, UpdateCheck=UpdateCheck.Never)]
    560     public System.Data.Linq.Binary Data
    561     {
    562       get
    563       {
    564         return this._Data;
    565       }
    566       set
    567       {
    568         if ((this._Data != value))
    569         {
    570           this.OnDataChanging(value);
    571           this.SendPropertyChanging();
    572           this._Data = value;
    573           this.SendPropertyChanged("Data");
    574           this.OnDataChanged();
    575         }
    576       }
    577     }
    578    
    579     [global::System.Data.Linq.Mapping.AssociationAttribute(Name="Plugin_PluginPackage", Storage="_Plugin", ThisKey="PluginId", OtherKey="Id", IsForeignKey=true)]
    580     public Plugin Plugin
    581     {
    582       get
    583       {
    584         return this._Plugin.Entity;
    585       }
    586       set
    587       {
    588         Plugin previousValue = this._Plugin.Entity;
    589         if (((previousValue != value)
    590               || (this._Plugin.HasLoadedOrAssignedValue == false)))
    591         {
    592           this.SendPropertyChanging();
    593           if ((previousValue != null))
    594           {
    595             this._Plugin.Entity = null;
    596             previousValue.PluginPackage = null;
    597           }
    598           this._Plugin.Entity = value;
    599           if ((value != null))
    600           {
    601             value.PluginPackage = this;
    602             this._PluginId = value.Id;
    603           }
    604           else
    605           {
    606             this._PluginId = default(long);
    607           }
    608           this.SendPropertyChanged("Plugin");
    609         }
    610       }
    611     }
    612    
    613     public event PropertyChangingEventHandler PropertyChanging;
    614    
    615     public event PropertyChangedEventHandler PropertyChanged;
    616    
    617     protected virtual void SendPropertyChanging()
    618     {
    619       if ((this.PropertyChanging != null))
    620       {
    621         this.PropertyChanging(this, emptyChangingEventArgs);
    622       }
    623     }
    624    
    625     protected virtual void SendPropertyChanged(String propertyName)
    626     {
    627       if ((this.PropertyChanged != null))
    628       {
    629         this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    630       }
    631     }
    632   }
    633  
    634   [global::System.Data.Linq.Mapping.TableAttribute(Name="dbo.Product")]
    635   public partial class Product : INotifyPropertyChanging, INotifyPropertyChanged
    636   {
    637    
    638     private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
    639    
    640     private long _Id;
    641    
    642     private string _Name;
    643    
    644     private string _Version;
    645    
     441
     442    public PluginPackage() {
     443      this._Plugin = default(EntityRef<Plugin>);
     444      OnCreated();
     445    }
     446
     447    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_PluginId", DbType = "BigInt NOT NULL", IsPrimaryKey = true)]
     448    public long PluginId {
     449      get {
     450        return this._PluginId;
     451      }
     452      set {
     453        if ((this._PluginId != value)) {
     454          if (this._Plugin.HasLoadedOrAssignedValue) {
     455            throw new System.Data.Linq.ForeignKeyReferenceAlreadyHasValueException();
     456          }
     457          this.OnPluginIdChanging(value);
     458          this.SendPropertyChanging();
     459          this._PluginId = value;
     460          this.SendPropertyChanged("PluginId");
     461          this.OnPluginIdChanged();
     462        }
     463      }
     464    }
     465
     466    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_Data", DbType = "Image NOT NULL", CanBeNull = false, UpdateCheck = UpdateCheck.Never)]
     467    public System.Data.Linq.Binary Data {
     468      get {
     469        return this._Data;
     470      }
     471      set {
     472        if ((this._Data != value)) {
     473          this.OnDataChanging(value);
     474          this.SendPropertyChanging();
     475          this._Data = value;
     476          this.SendPropertyChanged("Data");
     477          this.OnDataChanged();
     478        }
     479      }
     480    }
     481
     482    [global::System.Data.Linq.Mapping.AssociationAttribute(Name = "Plugin_PluginPackage", Storage = "_Plugin", ThisKey = "PluginId", OtherKey = "Id", IsForeignKey = true)]
     483    public Plugin Plugin {
     484      get {
     485        return this._Plugin.Entity;
     486      }
     487      set {
     488        Plugin previousValue = this._Plugin.Entity;
     489        if (((previousValue != value)
     490              || (this._Plugin.HasLoadedOrAssignedValue == false))) {
     491          this.SendPropertyChanging();
     492          if ((previousValue != null)) {
     493            this._Plugin.Entity = null;
     494            previousValue.PluginPackage = null;
     495          }
     496          this._Plugin.Entity = value;
     497          if ((value != null)) {
     498            value.PluginPackage = this;
     499            this._PluginId = value.Id;
     500          } else {
     501            this._PluginId = default(long);
     502          }
     503          this.SendPropertyChanged("Plugin");
     504        }
     505      }
     506    }
     507
     508    public event PropertyChangingEventHandler PropertyChanging;
     509
     510    public event PropertyChangedEventHandler PropertyChanged;
     511
     512    protected virtual void SendPropertyChanging() {
     513      if ((this.PropertyChanging != null)) {
     514        this.PropertyChanging(this, emptyChangingEventArgs);
     515      }
     516    }
     517
     518    protected virtual void SendPropertyChanged(String propertyName) {
     519      if ((this.PropertyChanged != null)) {
     520        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
     521      }
     522    }
     523  }
     524
     525  [global::System.Data.Linq.Mapping.TableAttribute(Name = "dbo.Product")]
     526  public partial class Product : INotifyPropertyChanging, INotifyPropertyChanged {
     527
     528    private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
     529
     530    private long _Id;
     531
     532    private string _Name;
     533
     534    private string _Version;
     535
    646536    #region Extensibility Method Definitions
    647537    partial void OnLoaded();
    … …  
    655545    partial void OnVersionChanged();
    656546    #endregion
    657    
    658     public Product()
    659     {
    660       OnCreated();
    661     }
    662    
    663     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Id", AutoSync=AutoSync.OnInsert, DbType="BigInt NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true)]
    664     public long Id
    665     {
    666       get
    667       {
    668         return this._Id;
    669       }
    670       set
    671       {
    672         if ((this._Id != value))
    673         {
    674           this.OnIdChanging(value);
    675           this.SendPropertyChanging();
    676           this._Id = value;
    677           this.SendPropertyChanged("Id");
    678           this.OnIdChanged();
    679         }
    680       }
    681     }
    682    
    683     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Name", DbType="NVarChar(300) NOT NULL", CanBeNull=false)]
    684     public string Name
    685     {
    686       get
    687       {
    688         return this._Name;
    689       }
    690       set
    691       {
    692         if ((this._Name != value))
    693         {
    694           this.OnNameChanging(value);
    695           this.SendPropertyChanging();
    696           this._Name = value;
    697           this.SendPropertyChanged("Name");
    698           this.OnNameChanged();
    699         }
    700       }
    701     }
    702    
    703     [global::System.Data.Linq.Mapping.ColumnAttribute(Storage="_Version", DbType="NVarChar(50) NOT NULL", CanBeNull=false)]
    704     public string Version
    705     {
    706       get
    707       {
    708         return this._Version;
    709       }
    710       set
    711       {
    712         if ((this._Version != value))
    713         {
    714           this.OnVersionChanging(value);
    715           this.SendPropertyChanging();
    716           this._Version = value;
    717           this.SendPropertyChanged("Version");
    718           this.OnVersionChanged();
    719         }
    720       }
    721     }
    722    
    723     public event PropertyChangingEventHandler PropertyChanging;
    724    
    725     public event PropertyChangedEventHandler PropertyChanged;
    726    
    727     protected virtual void SendPropertyChanging()
    728     {
    729       if ((this.PropertyChanging != null))
    730       {
    731         this.PropertyChanging(this, emptyChangingEventArgs);
    732       }
    733     }
    734    
    735     protected virtual void SendPropertyChanged(String propertyName)
    736     {
    737       if ((this.PropertyChanged != null))
    738       {
    739         this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    740       }
    741     }
    742   }
     547
     548    public Product() {
     549      OnCreated();
     550    }
     551
     552    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_Id", AutoSync = AutoSync.OnInsert, DbType = "BigInt NOT NULL IDENTITY", IsPrimaryKey = true, IsDbGenerated = true)]
     553    public long Id {
     554      get {
     555        return this._Id;
     556      }
     557      set {
     558        if ((this._Id != value)) {
     559          this.OnIdChanging(value);
     560          this.SendPropertyChanging();
     561          this._Id = value;
     562          this.SendPropertyChanged("Id");
     563          this.OnIdChanged();
     564        }
     565      }
     566    }
     567
     568    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_Name", DbType = "NVarChar(300) NOT NULL", CanBeNull = false)]
     569    public string Name {
     570      get {
     571        return this._Name;
     572      }
     573      set {
     574        if ((this._Name != value)) {
     575          this.OnNameChanging(value);
     576          this.SendPropertyChanging();
     577          this._Name = value;
     578          this.SendPropertyChanged("Name");
     579          this.OnNameChanged();
     580        }
     581      }
     582    }
     583
     584    [global::System.Data.Linq.Mapping.ColumnAttribute(Storage = "_Version", DbType = "NVarChar(50) NOT NULL", CanBeNull = false)]
     585    public string Version {
     586      get {
     587        return this._Version;
     588      }
     589      set {
     590        if ((this._Version != value)) {
     591          this.OnVersionChanging(value);
     592          this.SendPropertyChanging();
     593          this._Version = value;
     594          this.SendPropertyChanged("Version");
     595          this.OnVersionChanged();
     596        }
     597      }
     598    }
     599
     600    public event PropertyChangingEventHandler PropertyChanging;
     601
     602    public event PropertyChangedEventHandler PropertyChanged;
     603
     604    protected virtual void SendPropertyChanging() {
     605      if ((this.PropertyChanging != null)) {
     606        this.PropertyChanging(this, emptyChangingEventArgs);
     607      }
     608    }
     609
     610    protected virtual void SendPropertyChanged(String propertyName) {
     611      if ((this.PropertyChanged != null)) {
     612        this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
     613      }
     614    }
     615  }
    743616}
    744617#pragma warning restore 1591
Note: See TracChangeset for help on using the changeset viewer.