097715 / Исходники / Магазин бытовой техники / BusinessClasses

//Модуль описание классов бизнес-модели
(*****************************************)
(* This file is autogenerated *)
(* Any manual changes will be LOST! *)
(*****************************************)
(* Generated 16.05.2009 16:55:06 *)
(*****************************************)
(* This file should be stored in the *)
(* same directory as the form/datamodule *)
(* with the corresponding model *)
(*****************************************)
(* Copyright notice: *)
(* *)
(*****************************************)

unit BusinessClasses;

{$DEFINE BusinessClasses_unitheader}
{$INCLUDE BusinessClasses_Interface.inc}

{ Includefile for methodimplementations }


const
BoldMemberAssertInvalidObjectType: string = 'Object of singlelink (%s.%s) is of wrong type (is %s, should be %s)';

{ TBusinessClassesRoot }

procedure TBusinessClassesRootList.Add(NewObject: TBusinessClassesRoot);
begin
if Assigned(NewObject) then
AddElement(NewObject);
end;

function TBusinessClassesRootList.IndexOf(anObject: TBusinessClassesRoot): Integer;
begin
result := IndexOfElement(anObject);
end;

function TBusinessClassesRootList.Includes(anObject: TBusinessClassesRoot) : Boolean;
begin
result := IncludesElement(anObject);
end;

function TBusinessClassesRootList.AddNew: TBusinessClassesRoot;
begin
result := TBusinessClassesRoot(InternalAddNew);
end;

procedure TBusinessClassesRootList.Insert(index: Integer; NewObject: TBusinessClassesRoot);
begin
if assigned(NewObject) then
InsertElement(index, NewObject);
end;

function TBusinessClassesRootList.GetBoldObject(index: Integer): TBusinessClassesRoot;
begin
result := TBusinessClassesRoot(GetElement(index));
end;

procedure TBusinessClassesRootList.SetBoldObject(index: Integer; NewObject: TBusinessClassesRoot);
begin;
SetElement(index, NewObject);
end;

{ TAdmin }

function TAdmin._Get_M_Afam: TBAString;
begin
assert(ValidateMember('TAdmin', 'Afam', 0, TBAString));
Result := TBAString(BoldMembers[0]);
end;

function TAdmin._GetAfam: String;
begin
Result := M_Afam.AsString;
end;

procedure TAdmin._SetAfam(const NewValue: String);
begin
M_Afam.AsString := NewValue;
end;

function TAdmin._Get_M_Aname: TBAString;
begin
assert(ValidateMember('TAdmin', 'Aname', 1, TBAString));
Result := TBAString(BoldMembers[1]);
end;

function TAdmin._GetAname: String;
begin
Result := M_Aname.AsString;
end;

procedure TAdmin._SetAname(const NewValue: String);
begin
M_Aname.AsString := NewValue;
end;

function TAdmin._Get_M_Asname: TBAString;
begin
assert(ValidateMember('TAdmin', 'Asname', 2, TBAString));
Result := TBAString(BoldMembers[2]);
end;

function TAdmin._GetAsname: String;
begin
Result := M_Asname.AsString;
end;

procedure TAdmin._SetAsname(const NewValue: String);
begin
M_Asname.AsString := NewValue;
end;

function TAdmin._Get_M_Adr: TBADate;
begin
assert(ValidateMember('TAdmin', 'Adr', 3, TBADate));
Result := TBADate(BoldMembers[3]);
end;

function TAdmin._GetAdr: TDate;
begin
Result := M_Adr.AsDate;
end;

procedure TAdmin._SetAdr(const NewValue: TDate);
begin
M_Adr.AsDate := NewValue;
end;

function TAdmin._Get_M_Zaveduet: TBoldObjectReference;
begin
assert(ValidateMember('TAdmin', 'Zaveduet', 4, TBoldObjectReference));
Result := TBoldObjectReference(BoldMembers[4]);
end;

function TAdmin._GetZaveduet: TOtdel;
begin
assert(not assigned(M_Zaveduet.BoldObject) or (M_Zaveduet.BoldObject is TOtdel), SysUtils.format(BoldMemberAssertInvalidObjectType, [ClassName, 'Zaveduet', M_Zaveduet.BoldObject.ClassName, 'TOtdel']));
Result := TOtdel(M_Zaveduet.BoldObject);
end;

procedure TAdmin._SetZaveduet(const value: TOtdel);
begin
M_Zaveduet.BoldObject := value;
end;

procedure TAdminList.Add(NewObject: TAdmin);
begin
if Assigned(NewObject) then
AddElement(NewObject);
end;

function TAdminList.IndexOf(anObject: TAdmin): Integer;
begin
result := IndexOfElement(anObject);
end;

function TAdminList.Includes(anObject: TAdmin) : Boolean;
begin
result := IncludesElement(anObject);
end;

function TAdminList.AddNew: TAdmin;
begin
result := TAdmin(InternalAddNew);
end;

procedure TAdminList.Insert(index: Integer; NewObject: TAdmin);
begin
if assigned(NewObject) then
InsertElement(index, NewObject);
end;

function TAdminList.GetBoldObject(index: Integer): TAdmin;
begin
result := TAdmin(GetElement(index));
end;

procedure TAdminList.SetBoldObject(index: Integer; NewObject: TAdmin);
begin;
SetElement(index, NewObject);
end;

{ TGroup }

function TGroup._Get_M_Gname: TBAString;
begin
assert(ValidateMember('TGroup', 'Gname', 0, TBAString));
Result := TBAString(BoldMembers[0]);
end;

function TGroup._GetGname: String;
begin
Result := M_Gname.AsString;
end;

procedure TGroup._SetGname(const NewValue: String);
begin
M_Gname.AsString := NewValue;
end;

function TGroup._Get_M_Prinadlezhit: TBoldObjectReference;
begin
assert(ValidateMember('TGroup', 'Prinadlezhit', 1, TBoldObjectReference));
Result := TBoldObjectReference(BoldMembers[1]);
end;

function TGroup._GetPrinadlezhit: TOtdel;
begin
assert(not assigned(M_Prinadlezhit.BoldObject) or (M_Prinadlezhit.BoldObject is TOtdel), SysUtils.format(BoldMemberAssertInvalidObjectType, [ClassName, 'Prinadlezhit', M_Prinadlezhit.BoldObject.ClassName, 'TOtdel']));
Result := TOtdel(M_Prinadlezhit.BoldObject);
end;

procedure TGroup._SetPrinadlezhit(const value: TOtdel);
begin
M_Prinadlezhit.BoldObject := value;
end;

function TGroup._GetSoderzhit: TTov_magList;
begin
assert(ValidateMember('TGroup', 'Soderzhit', 2, TTov_magList));
Result := TTov_magList(BoldMembers[2]);
end;

function TGroup._Get_M_Zakupaetsya: TBoldObjectReference;
begin
assert(ValidateMember('TGroup', 'Zakupaetsya', 3, TBoldObjectReference));
Result := TBoldObjectReference(BoldMembers[3]);
end;

function TGroup._GetZakupaetsya: TBase;
begin
assert(not assigned(M_Zakupaetsya.BoldObject) or (M_Zakupaetsya.BoldObject is TBase), SysUtils.format(BoldMemberAssertInvalidObjectType, [ClassName, 'Zakupaetsya', M_Zakupaetsya.BoldObject.ClassName, 'TBase']));
Result := TBase(M_Zakupaetsya.BoldObject);
end;

procedure TGroup._SetZakupaetsya(const value: TBase);
begin
M_Zakupaetsya.BoldObject := value;
end;

function TGroup._GetBHranit: TTov_baseList;
begin
assert(ValidateMember('TGroup', 'BHranit', 4, TTov_baseList));
Result := TTov_baseList(BoldMembers[4]);
end;

procedure TGroupList.Add(NewObject: TGroup);
begin
if Assigned(NewObject) then
AddElement(NewObject);
end;

function TGroupList.IndexOf(anObject: TGroup): Integer;
begin
result := IndexOfElement(anObject);
end;

function TGroupList.Includes(anObject: TGroup) : Boolean;
begin
result := IncludesElement(anObject);
end;

function TGroupList.AddNew: TGroup;
begin
result := TGroup(InternalAddNew);
end;

procedure TGroupList.Insert(index: Integer; NewObject: TGroup);
begin
if assigned(NewObject) then
InsertElement(index, NewObject);
end;

function TGroupList.GetBoldObject(index: Integer): TGroup;
begin
result := TGroup(GetElement(index));
end;

procedure TGroupList.SetBoldObject(index: Integer; NewObject: TGroup);
begin;
SetElement(index, NewObject);
end;

{ TZakaz }

function TZakaz._Get_M_Zdate: TBADate;
begin
assert(ValidateMember('TZakaz', 'Zdate', 0, TBADate));
Result := TBADate(BoldMembers[0]);
end;

function TZakaz._GetZdate: TDate;
begin
Result := M_Zdate.AsDate;
end;

procedure TZakaz._SetZdate(const NewValue: TDate);
begin
M_Zdate.AsDate := NewValue;
end;

function TZakaz._Get_M_Zname: TBAString;
begin
assert(ValidateMember('TZakaz', 'Zname', 1, TBAString));
Result := TBAString(BoldMembers[1]);
end;

function TZakaz._GetZname: String;
begin
Result := M_Zname.AsString;
end;

procedure TZakaz._SetZname(const NewValue: String);
begin
M_Zname.AsString := NewValue;
end;

function TZakaz._Get_M_Zcount: TBAInteger;
begin
assert(ValidateMember('TZakaz', 'Zcount', 2, TBAInteger));
Result := TBAInteger(BoldMembers[2]);
end;

function TZakaz._GetZcount: Integer;
begin
Result := M_Zcount.AsInteger;
end;

procedure TZakaz._SetZcount(const NewValue: Integer);
begin
M_Zcount.AsInteger := NewValue;
end;

function TZakaz._Get_M_Zprice: TBAFloat;
begin
assert(ValidateMember('TZakaz', 'Zprice', 3, TBAFloat));
Result := TBAFloat(BoldMembers[3]);
end;

function TZakaz._GetZprice: double;
begin
Result := M_Zprice.AsFloat;
end;

procedure TZakaz._SetZprice(const NewValue: double);
begin
M_Zprice.AsFloat := NewValue;
end;

function TZakaz._Get_M_Znumber: TBAInteger;
begin
assert(ValidateMember('TZakaz', 'Znumber', 4, TBAInteger));
Result := TBAInteger(BoldMembers[4]);
end;

function TZakaz._GetZnumber: Integer;
begin
Result := M_Znumber.AsInteger;
end;

procedure TZakaz._SetZnumber(const NewValue: Integer);
begin
M_Znumber.AsInteger := NewValue;
end;

procedure TZakazList.Add(NewObject: TZakaz);
begin
if Assigned(NewObject) then
AddElement(NewObject);
end;

function TZakazList.IndexOf(anObject: TZakaz): Integer;
begin
result := IndexOfElement(anObject);
end;

function TZakazList.Includes(anObject: TZakaz) : Boolean;
begin
result := IncludesElement(anObject);
end;

function TZakazList.AddNew: TZakaz;
begin
result := TZakaz(InternalAddNew);
end;

procedure TZakazList.Insert(index: Integer; NewObject: TZakaz);
begin
if assigned(NewObject) then
InsertElement(index, NewObject);
end;

function TZakazList.GetBoldObject(index: Integer): TZakaz;
begin
result := TZakaz(GetElement(index));
end;

procedure TZakazList.SetBoldObject(index: Integer; NewObject: TZakaz);
begin;
SetElement(index, NewObject);
end;

{ TShop }

function TShop._Get_M_Shname: TBAString;
begin
assert(ValidateMember('TShop', 'Shname', 0, TBAString));
Result := TBAString(BoldMembers[0]);
end;

function TShop._GetShname: String;
begin
Result := M_Shname.AsString;
end;

procedure TShop._SetShname(const NewValue: String);
begin
M_Shname.AsString := NewValue;
end;

function TShop._Get_M_Shclass: TBAString;
begin
assert(ValidateMember('TShop', 'Shclass', 1, TBAString));
Result := TBAString(BoldMembers[1]);
end;

function TShop._GetShclass: String;
begin
Result := M_Shclass.AsString;
end;

procedure TShop._SetShclass(const NewValue: String);
begin
M_Shclass.AsString := NewValue;
end;

function TShop._Get_M_Shnumber: TBAString;
begin
assert(ValidateMember('TShop', 'Shnumber', 2, TBAString));
Result := TBAString(BoldMembers[2]);
end;

function TShop._GetShnumber: String;
begin
Result := M_Shnumber.AsString;
end;

procedure TShop._SetShnumber(const NewValue: String);
begin
M_Shnumber.AsString := NewValue;
end;

function TShop._Get_M_ShAddress: TBAString;
begin
assert(ValidateMember('TShop', 'ShAddress', 3, TBAString));
Result := TBAString(BoldMembers[3]);
end;

function TShop._GetShAddress: String;
begin
Result := M_ShAddress.AsString;
end;

procedure TShop._SetShAddress(const NewValue: String);
begin
M_ShAddress.AsString := NewValue;
end;

function TShop._Get_M_ShINN: TBAString;
begin
assert(ValidateMember('TShop', 'ShINN', 4, TBAString));
Result := TBAString(BoldMembers[4]);
end;

function TShop._GetShINN: String;
begin
Result := M_ShINN.AsString;
end;

procedure TShop._SetShINN(const NewValue: String);
begin
M_ShINN.AsString := NewValue;
end;

function TShop._Get_M_ShPhone: TBAString;
begin
assert(ValidateMember('TShop', 'ShPhone', 5, TBAString));
Result := TBAString(BoldMembers[5]);
end;

function TShop._GetShPhone: String;
begin
Result := M_ShPhone.AsString;
end;

procedure TShop._SetShPhone(const NewValue: String);
begin
M_ShPhone.AsString := NewValue;
end;

function TShop._Get_M_ShMail: TBAString;
begin
assert(ValidateMember('TShop', 'ShMail', 6, TBAString));
Result := TBAString(BoldMembers[6]);
end;

function TShop._GetShMail: String;
begin
Result := M_ShMail.AsString;
end;

procedure TShop._SetShMail(const NewValue: String);
begin
M_ShMail.AsString := NewValue;
end;

function TShop._GetSostoit: TOtdelList;
begin
assert(ValidateMember('TShop', 'Sostoit', 7, TOtdelList));
Result := TOtdelList(BoldMembers[7]);
end;

function TShop._GetImeet: TBaseList;
begin
assert(ValidateMember('TShop', 'Imeet', 8, TBaseList));
Result := TBaseList(BoldMembers[8]);
end;

procedure TShopList.Add(NewObject: TShop);
begin
if Assigned(NewObject) then
AddElement(NewObject);
end;

function TShopList.IndexOf(anObject: TShop): Integer;
begin
result := IndexOfElement(anObject);
end;

function TShopList.Includes(anObject: TShop) : Boolean;
begin
result := IncludesElement(anObject);
end;

function TShopList.AddNew: TShop;
begin
result := TShop(InternalAddNew);
end;

procedure TShopList.Insert(index: Integer; NewObject: TShop);
begin
if assigned(NewObject) then
InsertElement(index, NewObject);
end;

function TShopList.GetBoldObject(index: Integer): TShop;
begin
result := TShop(GetElement(index));
end;

procedure TShopList.SetBoldObject(index: Integer; NewObject: TShop);
begin;
SetElement(index, NewObject);
end;

{ TOtdel }

function TOtdel._Get_M_Oname: TBAString;
begin
assert(ValidateMember('TOtdel', 'Oname', 0, TBAString));
Result := TBAString(BoldMembers[0]);
end;

function TOtdel._GetOname: String;
begin
Result := M_Oname.AsString;
end;

procedure TOtdel._SetOname(const NewValue: String);
begin
M_Oname.AsString := NewValue;
end;

function TOtdel._Get_M_Prinadlezhit: TBoldObjectReference;
begin
assert(ValidateMember('TOtdel', 'Prinadlezhit', 1, TBoldObjectReference));
Result := TBoldObjectReference(BoldMembers[1]);
end;

function TOtdel._GetPrinadlezhit: TShop;
begin
assert(not assigned(M_Prinadlezhit.BoldObject) or (M_Prinadlezhit.BoldObject is TShop), SysUtils.format(BoldMemberAssertInvalidObjectType, [ClassName, 'Prinadlezhit', M_Prinadlezhit.BoldObject.ClassName, 'TShop']));
Result := TShop(M_Prinadlezhit.BoldObject);
end;

procedure TOtdel._SetPrinadlezhit(const value: TShop);
begin
M_Prinadlezhit.BoldObject := value;
end;

function TOtdel._GetVkluchaet: TGroupList;
begin
assert(ValidateMember('TOtdel', 'Vkluchaet', 2, TGroupList));
Result := TGroupList(BoldMembers[2]);
end;

function TOtdel._Get_M_Upravlyaetsya: TBoldObjectReference;
begin
assert(ValidateMember('TOtdel', 'Upravlyaetsya', 3, TBoldObjectReference));
Result := TBoldObjectReference(BoldMembers[3]);
end;

function TOtdel._GetUpravlyaetsya: TAdmin;
begin
assert(not assigned(M_Upravlyaetsya.BoldObject) or (M_Upravlyaetsya.BoldObject is TAdmin), SysUtils.format(BoldMemberAssertInvalidObjectType, [ClassName, 'Upravlyaetsya', M_Upravlyaetsya.BoldObject.ClassName, 'TAdmin']));
Result := TAdmin(M_Upravlyaetsya.BoldObject);
end;

procedure TOtdel._SetUpravlyaetsya(const value: TAdmin);
begin
M_Upravlyaetsya.BoldObject := value;
end;

procedure TOtdelList.Add(NewObject: TOtdel);
begin
if Assigned(NewObject) then
AddElement(NewObject);
end;

function TOtdelList.IndexOf(anObject: TOtdel): Integer;
begin
result := IndexOfElement(anObject);
end;

function TOtdelList.Includes(anObject: TOtdel) : Boolean;
begin
result := IncludesElement(anObject);
end;

function TOtdelList.AddNew: TOtdel;
begin
result := TOtdel(InternalAddNew);
end;

procedure TOtdelList.Insert(index: Integer; NewObject: TOtdel);
begin
if assigned(NewObject) then
InsertElement(index, NewObject);
end;

function TOtdelList.GetBoldObject(index: Integer): TOtdel;
begin
result := TOtdel(GetElement(index));
end;

procedure TOtdelList.SetBoldObject(index: Integer; NewObject: TOtdel);
begin;
SetElement(index, NewObject);
end;

{ TProdazha }

function TProdazha._Get_M_Pdate: TBADate;
begin
assert(ValidateMember('TProdazha', 'Pdate', 0, TBADate));
Result := TBADate(BoldMembers[0]);
end;

function TProdazha._GetPdate: TDate;
begin
Result := M_Pdate.AsDate;
end;

procedure TProdazha._SetPdate(const NewValue: TDate);
begin
M_Pdate.AsDate := NewValue;
end;

function TProdazha._Get_M_PZtov_name: TBAString;
begin
assert(ValidateMember('TProdazha', 'PZtov_name', 1, TBAString));
Result := TBAString(BoldMembers[1]);
end;

function TProdazha._GetPZtov_name: String;
begin
Result := M_PZtov_name.AsString;
end;

procedure TProdazha._SetPZtov_name(const NewValue: String);
begin
M_PZtov_name.AsString := NewValue;
end;

function TProdazha._Get_M_Pcount: TBAInteger;
begin
assert(ValidateMember('TProdazha', 'Pcount', 2, TBAInteger));
Result := TBAInteger(BoldMembers[2]);
end;

function TProdazha._GetPcount: Integer;
begin
Result := M_Pcount.AsInteger;
end;

procedure TProdazha._SetPcount(const NewValue: Integer);
begin
M_Pcount.AsInteger := NewValue;
end;

function TProdazha._Get_M_Pprice: TBAFloat;
begin
assert(ValidateMember('TProdazha', 'Pprice', 3, TBAFloat));
Result := TBAFloat(BoldMembers[3]);
end;

function TProdazha._GetPprice: double;
begin
Result := M_Pprice.AsFloat;
end;

procedure TProdazha._SetPprice(const NewValue: double);
begin
M_Pprice.AsFloat := NewValue;
end;

function TProdazha._Get_M_PRprice: TBAFloat;
begin
assert(ValidateMember('TProdazha', 'PRprice', 4, TBAFloat));
Result := TBAFloat(BoldMembers[4]);
end;

function TProdazha._GetPRprice: double;
begin
Result := M_PRprice.AsFloat;
end;

procedure TProdazha._SetPRprice(const NewValue: double);
begin
M_PRprice.AsFloat := NewValue;
end;

function TProdazha._Get_M_Psumma: TBAFloat;
begin
assert(ValidateMember('TProdazha', 'Psumma', 5, TBAFloat));
Result := TBAFloat(BoldMembers[5]);
end;

function TProdazha._GetPsumma: double;
begin
Result := M_Psumma.AsFloat;
end;

function TProdazha._Get_M_Pnumber: TBAInteger;
begin
assert(ValidateMember('TProdazha', 'Pnumber', 6, TBAInteger));
Result := TBAInteger(BoldMembers[6]);
end;

function TProdazha._GetPnumber: Integer;
begin
Result := M_Pnumber.AsInteger;
end;

procedure TProdazha._SetPnumber(const NewValue: Integer);
begin
M_Pnumber.AsInteger := NewValue;
end;

procedure TProdazhaList.Add(NewObject: TProdazha);
begin
if Assigned(NewObject) then
AddElement(NewObject);
end;

function TProdazhaList.IndexOf(anObject: TProdazha): Integer;
begin
result := IndexOfElement(anObject);
end;

function TProdazhaList.Includes(anObject: TProdazha) : Boolean;
begin
result := IncludesElement(anObject);
end;

function TProdazhaList.AddNew: TProdazha;
begin
result := TProdazha(InternalAddNew);
end;

procedure TProdazhaList.Insert(index: Integer; NewObject: TProdazha);
begin
if assigned(NewObject) then
InsertElement(index, NewObject);
end;

function TProdazhaList.GetBoldObject(index: Integer): TProdazha;
begin
result := TProdazha(GetElement(index));
end;

procedure TProdazhaList.SetBoldObject(index: Integer; NewObject: TProdazha);
begin;
SetElement(index, NewObject);
end;

{ TTovar }

function TTovar._Get_M_Tname: TBAString;
begin
assert(ValidateMember('TTovar', 'Tname', 0, TBAString));
Result := TBAString(BoldMembers[0]);
end;

function TTovar._GetTname: String;
begin
Result := M_Tname.AsString;
end;

procedure TTovar._SetTname(const NewValue: String);
begin
M_Tname.AsString := NewValue;
end;

function TTovar._Get_M_Tprice: TBAFloat;
begin
assert(ValidateMember('TTovar', 'Tprice', 1, TBAFloat));
Result := TBAFloat(BoldMembers[1]);
end;

function TTovar._GetTprice: double;
begin
Result := M_Tprice.AsFloat;
end;

procedure TTovar._SetTprice(const NewValue: double);
begin
M_Tprice.AsFloat := NewValue;
end;

function TTovar._Get_M_Tgarant: TBAByte;
begin
assert(ValidateMember('TTovar', 'Tgarant', 2, TBAByte));
Result := TBAByte(BoldMembers[2]);
end;

function TTovar._GetTgarant: Byte;
begin
Result := M_Tgarant.AsByte;
end;

procedure TTovar._SetTgarant(const NewValue: Byte);
begin
M_Tgarant.AsByte := NewValue;
end;

procedure TTovarList.Add(NewObject: TTovar);
begin
if Assigned(NewObject) then
AddElement(NewObject);
end;

function TTovarList.IndexOf(anObject: TTovar): Integer;
begin
result := IndexOfElement(anObject);
end;

function TTovarList.Includes(anObject: TTovar) : Boolean;
begin
result := IncludesElement(anObject);
end;

function TTovarList.AddNew: TTovar;
begin
result := TTovar(InternalAddNew);
end;

procedure TTovarList.Insert(index: Integer; NewObject: TTovar);
begin
if assigned(NewObject) then
InsertElement(index, NewObject);
end;

function TTovarList.GetBoldObject(index: Integer): TTovar;
begin
result := TTovar(GetElement(index));
end;

procedure TTovarList.SetBoldObject(index: Integer; NewObject: TTovar);
begin;
SetElement(index, NewObject);
end;

{ TBase }

function TBase._Get_M_Bname: TBAString;
begin
assert(ValidateMember('TBase', 'Bname', 0, TBAString));
Result := TBAString(BoldMembers[0]);
end;

function TBase._GetBname: String;
begin
Result := M_Bname.AsString;
end;

procedure TBase._SetBname(const NewValue: String);
begin
M_Bname.AsString := NewValue;
end;

function TBase._Get_M_Baddress: TBAString;
begin
assert(ValidateMember('TBase', 'Baddress', 1, TBAString));
Result := TBAString(BoldMembers[1]);
end;

function TBase._GetBaddress: String;
begin
Result := M_Baddress.AsString;
end;

procedure TBase._SetBaddress(const NewValue: String);
begin
M_Baddress.AsString := NewValue;
end;

function TBase._Get_M_Imeetsya: TBoldObjectReference;
begin
assert(ValidateMember('TBase', 'Imeetsya', 2, TBoldObjectReference));
Result := TBoldObjectReference(BoldMembers[2]);
end;

function TBase._GetImeetsya: TShop;
begin
assert(not assigned(M_Imeetsya.BoldObject) or (M_Imeetsya.BoldObject is TShop), SysUtils.format(BoldMemberAssertInvalidObjectType, [ClassName, 'Imeetsya', M_Imeetsya.BoldObject.ClassName, 'TShop']));
Result := TShop(M_Imeetsya.BoldObject);
end;

procedure TBase._SetImeetsya(const value: TShop);
begin
M_Imeetsya.BoldObject := value;
end;

function TBase._GetSoderzhit: TTov_baseList;
begin
assert(ValidateMember('TBase', 'Soderzhit', 3, TTov_baseList));
Result := TTov_baseList(BoldMembers[3]);
end;

function TBase._GetHranit: TGroupList;
begin
assert(ValidateMember('TBase', 'Hranit', 4, TGroupList));
Result := TGroupList(BoldMembers[4]);
end;

procedure TBaseList.Add(NewObject: TBase);
begin
if Assigned(NewObject) then
AddElement(NewObject);
end;

function TBaseList.IndexOf(anObject: TBase): Integer;
begin
result := IndexOfElement(anObject);
end;

function TBaseList.Includes(anObject: TBase) : Boolean;
begin
result := IncludesElement(anObject);
end;

function TBaseList.AddNew: TBase;
begin
result := TBase(InternalAddNew);
end;

procedure TBaseList.Insert(index: Integer; NewObject: TBase);
begin
if assigned(NewObject) then
InsertElement(index, NewObject);
end;

function TBaseList.GetBoldObject(index: Integer): TBase;
begin
result := TBase(GetElement(index));
end;

procedure TBaseList.SetBoldObject(index: Integer; NewObject: TBase);
begin;
SetElement(index, NewObject);
end;

{ TTov_mag }

function TTov_mag._Get_M_TMcount: TBAInteger;
begin
assert(ValidateMember('TTov_mag', 'TMcount', 3, TBAInteger));
Result := TBAInteger(BoldMembers[3]);
end;

function TTov_mag._GetTMcount: Integer;
begin
Result := M_TMcount.AsInteger;
end;

procedure TTov_mag._SetTMcount(const NewValue: Integer);
begin
M_TMcount.AsInteger := NewValue;
end;

function TTov_mag._Get_M_TMprice: TBAFloat;
begin
assert(ValidateMember('TTov_mag', 'TMprice', 4, TBAFloat));
Result := TBAFloat(BoldMembers[4]);
end;

function TTov_mag._GetTMprice: double;
begin
Result := M_TMprice.AsFloat;
end;

procedure TTov_mag._SetTMprice(const NewValue: double);
begin
M_TMprice.AsFloat := NewValue;
end;

function TTov_mag._Get_M_Prodcount: TBAInteger;
begin
assert(ValidateMember('TTov_mag', 'Prodcount', 5, TBAInteger));
Result := TBAInteger(BoldMembers[5]);
end;

function TTov_mag._GetProdcount: Integer;
begin
Result := M_Prodcount.AsInteger;
end;

procedure TTov_mag._SetProdcount(const NewValue: Integer);
begin
M_Prodcount.AsInteger := NewValue;
end;

function TTov_mag._Get_M_TMsumma: TBAFloat;
begin
assert(ValidateMember('TTov_mag', 'TMsumma', 6, TBAFloat));
Result := TBAFloat(BoldMembers[6]);
end;

function TTov_mag._GetTMsumma: double;
begin
Result := M_TMsumma.AsFloat;
end;

function TTov_mag._Get_M_Prinadlezhit: TBoldObjectReference;
begin
assert(ValidateMember('TTov_mag', 'Prinadlezhit', 7, TBoldObjectReference));
Result := TBoldObjectReference(BoldMembers[7]);
end;

function TTov_mag._GetPrinadlezhit: TGroup;
begin
assert(not assigned(M_Prinadlezhit.BoldObject) or (M_Prinadlezhit.BoldObject is TGroup), SysUtils.format(BoldMemberAssertInvalidObjectType, [ClassName, 'Prinadlezhit', M_Prinadlezhit.BoldObject.ClassName, 'TGroup']));
Result := TGroup(M_Prinadlezhit.BoldObject);
end;

procedure TTov_mag._SetPrinadlezhit(const value: TGroup);
begin
M_Prinadlezhit.BoldObject := value;
end;

procedure TTov_magList.Add(NewObject: TTov_mag);
begin
if Assigned(NewObject) then
AddElement(NewObject);
end;

function TTov_magList.IndexOf(anObject: TTov_mag): Integer;
begin
result := IndexOfElement(anObject);
end;

function TTov_magList.Includes(anObject: TTov_mag) : Boolean;
begin
result := IncludesElement(anObject);
end;

function TTov_magList.AddNew: TTov_mag;
begin
result := TTov_mag(InternalAddNew);
end;

procedure TTov_magList.Insert(index: Integer; NewObject: TTov_mag);
begin
if assigned(NewObject) then
InsertElement(index, NewObject);
end;

function TTov_magList.GetBoldObject(index: Integer): TTov_mag;
begin
result := TTov_mag(GetElement(index));
end;

procedure TTov_magList.SetBoldObject(index: Integer; NewObject: TTov_mag);
begin;
SetElement(index, NewObject);
end;

{ TTov_base }

function TTov_base._Get_M_TBcount: TBAInteger;
begin
assert(ValidateMember('TTov_base', 'TBcount', 3, TBAInteger));
Result := TBAInteger(BoldMembers[3]);
end;

function TTov_base._GetTBcount: Integer;
begin
Result := M_TBcount.AsInteger;
end;

procedure TTov_base._SetTBcount(const NewValue: Integer);
begin
M_TBcount.AsInteger := NewValue;
end;

function TTov_base._Get_M_ZakazCount: TBAInteger;
begin
assert(ValidateMember('TTov_base', 'ZakazCount', 4, TBAInteger));
Result := TBAInteger(BoldMembers[4]);
end;

function TTov_base._GetZakazCount: Integer;
begin
Result := M_ZakazCount.AsInteger;
end;

procedure TTov_base._SetZakazCount(const NewValue: Integer);
begin
M_ZakazCount.AsInteger := NewValue;
end;

function TTov_base._Get_M_Hranitsya: TBoldObjectReference;
begin
assert(ValidateMember('TTov_base', 'Hranitsya', 5, TBoldObjectReference));
Result := TBoldObjectReference(BoldMembers[5]);
end;

function TTov_base._GetHranitsya: TBase;
begin
assert(not assigned(M_Hranitsya.BoldObject) or (M_Hranitsya.BoldObject is TBase), SysUtils.format(BoldMemberAssertInvalidObjectType, [ClassName, 'Hranitsya', M_Hranitsya.BoldObject.ClassName, 'TBase']));
Result := TBase(M_Hranitsya.BoldObject);
end;

procedure TTov_base._SetHranitsya(const value: TBase);
begin
M_Hranitsya.BoldObject := value;
end;

function TTov_base._Get_M_BPrinadlezhit: TBoldObjectReference;
begin
assert(ValidateMember('TTov_base', 'BPrinadlezhit', 6, TBoldObjectReference));
Result := TBoldObjectReference(BoldMembers[6]);
end;

function TTov_base._GetBPrinadlezhit: TGroup;
begin
assert(not assigned(M_BPrinadlezhit.BoldObject) or (M_BPrinadlezhit.BoldObject is TGroup), SysUtils.format(BoldMemberAssertInvalidObjectType, [ClassName, 'BPrinadlezhit', M_BPrinadlezhit.BoldObject.ClassName, 'TGroup']));
Result := TGroup(M_BPrinadlezhit.BoldObject);
end;

procedure TTov_base._SetBPrinadlezhit(const value: TGroup);
begin
M_BPrinadlezhit.BoldObject := value;
end;

procedure TTov_baseList.Add(NewObject: TTov_base);
begin
if Assigned(NewObject) then
AddElement(NewObject);
end;

function TTov_baseList.IndexOf(anObject: TTov_base): Integer;
begin
result := IndexOfElement(anObject);
end;

function TTov_baseList.Includes(anObject: TTov_base) : Boolean;
begin
result := IncludesElement(anObject);
end;

function TTov_baseList.AddNew: TTov_base;
begin
result := TTov_base(InternalAddNew);
end;

procedure TTov_baseList.Insert(index: Integer; NewObject: TTov_base);
begin
if assigned(NewObject) then
InsertElement(index, NewObject);
end;

function TTov_baseList.GetBoldObject(index: Integer): TTov_base;
begin
result := TTov_base(GetElement(index));
end;

procedure TTov_baseList.SetBoldObject(index: Integer; NewObject: TTov_base);
begin;
SetElement(index, NewObject);
end;

function GeneratedCodeCRC: String;
begin
result := '1602220265';
end;

procedure InstallObjectListClasses(BoldObjectListClasses: TBoldGeneratedClassList);
begin
BoldObjectListClasses.AddObjectEntry('BusinessClassesRoot', TBusinessClassesRootList);
BoldObjectListClasses.AddObjectEntry('Admin', TAdminList);
BoldObjectListClasses.AddObjectEntry('Group', TGroupList);
BoldObjectListClasses.AddObjectEntry('Zakaz', TZakazList);
BoldObjectListClasses.AddObjectEntry('Shop', TShopList);
BoldObjectListClasses.AddObjectEntry('Otdel', TOtdelList);
BoldObjectListClasses.AddObjectEntry('Prodazha', TProdazhaList);
BoldObjectListClasses.AddObjectEntry('Tovar', TTovarList);
BoldObjectListClasses.AddObjectEntry('Base', TBaseList);
BoldObjectListClasses.AddObjectEntry('Tov_mag', TTov_magList);
BoldObjectListClasses.AddObjectEntry('Tov_base', TTov_baseList);
end;

procedure InstallBusinessClasses(BoldObjectClasses: TBoldGeneratedClassList);
begin
BoldObjectClasses.AddObjectEntry('BusinessClassesRoot', TBusinessClassesRoot);
BoldObjectClasses.AddObjectEntry('Admin', TAdmin);
BoldObjectClasses.AddObjectEntry('Group', TGroup);
BoldObjectClasses.AddObjectEntry('Zakaz', TZakaz);
BoldObjectClasses.AddObjectEntry('Shop', TShop);
BoldObjectClasses.AddObjectEntry('Otdel', TOtdel);
BoldObjectClasses.AddObjectEntry('Prodazha', TProdazha);
BoldObjectClasses.AddObjectEntry('Tovar', TTovar);
BoldObjectClasses.AddObjectEntry('Base', TBase);
BoldObjectClasses.AddObjectEntry('Tov_mag', TTov_mag);
BoldObjectClasses.AddObjectEntry('Tov_base', TTov_base);
end;

var
CodeDescriptor: TBoldGeneratedCodeDescriptor;

initialization
CodeDescriptor := GeneratedCodes.AddGeneratedCodeDescriptorWithFunc('BusinessClasses', InstallBusinessClasses, InstallObjectListClasses, GeneratedCodeCRC);
finalization
GeneratedCodes.Remove(CodeDescriptor);
end.