Windows编程

开发平台：

Delphi

JwaAdsTLB.pas：源码内容

procedure TAccessControlEntry.Set_ObjectType(const retval: WideString);
begin
DefaultInterface.Set_ObjectType(retval);
end;
function TAccessControlEntry.Get_InheritedObjectType: WideString;
begin
Result := DefaultInterface.Get_InheritedObjectType;
end;
procedure TAccessControlEntry.Set_InheritedObjectType(const retval: WideString);
begin
DefaultInterface.Set_InheritedObjectType(retval);
end;
function TAccessControlEntry.Get_Trustee: WideString;
begin
Result := DefaultInterface.Get_Trustee;
end;
procedure TAccessControlEntry.Set_Trustee(const retval: WideString);
begin
DefaultInterface.Set_Trustee(retval);
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TAccessControlEntryProperties.Create(AServer: TAccessControlEntry);
begin
inherited Create;
FServer := AServer;
end;
function TAccessControlEntryProperties.GetDefaultInterface: IADsAccessControlEntry;
begin
Result := FServer.DefaultInterface;
end;
function TAccessControlEntryProperties.Get_AccessMask: Integer;
begin
Result := DefaultInterface.Get_AccessMask;
end;
procedure TAccessControlEntryProperties.Set_AccessMask(retval: Integer);
begin
DefaultInterface.Set_AccessMask(retval);
end;
function TAccessControlEntryProperties.Get_AceType: Integer;
begin
Result := DefaultInterface.Get_AceType;
end;
procedure TAccessControlEntryProperties.Set_AceType(retval: Integer);
begin
DefaultInterface.Set_AceType(retval);
end;
function TAccessControlEntryProperties.Get_AceFlags: Integer;
begin
Result := DefaultInterface.Get_AceFlags;
end;
procedure TAccessControlEntryProperties.Set_AceFlags(retval: Integer);
begin
DefaultInterface.Set_AceFlags(retval);
end;
function TAccessControlEntryProperties.Get_Flags: Integer;
begin
Result := DefaultInterface.Get_Flags;
end;
procedure TAccessControlEntryProperties.Set_Flags(retval: Integer);
begin
DefaultInterface.Set_Flags(retval);
end;
function TAccessControlEntryProperties.Get_ObjectType: WideString;
begin
Result := DefaultInterface.Get_ObjectType;
end;
procedure TAccessControlEntryProperties.Set_ObjectType(const retval: WideString);
begin
DefaultInterface.Set_ObjectType(retval);
end;
function TAccessControlEntryProperties.Get_InheritedObjectType: WideString;
begin
Result := DefaultInterface.Get_InheritedObjectType;
end;
procedure TAccessControlEntryProperties.Set_InheritedObjectType(const retval: WideString);
begin
DefaultInterface.Set_InheritedObjectType(retval);
end;
function TAccessControlEntryProperties.Get_Trustee: WideString;
begin
Result := DefaultInterface.Get_Trustee;
end;
procedure TAccessControlEntryProperties.Set_Trustee(const retval: WideString);
begin
DefaultInterface.Set_Trustee(retval);
end;
{$ENDIF}
class function CoAccessControlList.Create: IADsAccessControlList;
begin
Result := CreateComObject(CLASS_AccessControlList) as IADsAccessControlList;
end;
class function CoAccessControlList.CreateRemote(const MachineName: string): IADsAccessControlList;
begin
Result := CreateRemoteComObject(MachineName, CLASS_AccessControlList) as IADsAccessControlList;
end;
procedure TAccessControlList.InitServerData;
const
CServerData: TServerData = (
ClassID: '{B85EA052-9BDD-11D0-852C-00C04FD8D503}';
IntfIID: '{B7EE91CC-9BDD-11D0-852C-00C04FD8D503}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TAccessControlList.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsAccessControlList;
end;
end;
procedure TAccessControlList.ConnectTo(svrIntf: IADsAccessControlList);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TAccessControlList.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TAccessControlList.GetDefaultInterface: IADsAccessControlList;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TAccessControlList.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TAccessControlListProperties.Create(Self);
{$ENDIF}
end;
destructor TAccessControlList.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TAccessControlList.GetServerProperties: TAccessControlListProperties;
begin
Result := FProps;
end;
{$ENDIF}
function TAccessControlList.Get_AclRevision: Integer;
begin
Result := DefaultInterface.Get_AclRevision;
end;
procedure TAccessControlList.Set_AclRevision(retval: Integer);
begin
DefaultInterface.Set_AclRevision(retval);
end;
function TAccessControlList.Get_AceCount: Integer;
begin
Result := DefaultInterface.Get_AceCount;
end;
procedure TAccessControlList.Set_AceCount(retval: Integer);
begin
DefaultInterface.Set_AceCount(retval);
end;
procedure TAccessControlList.AddAce(const pAccessControlEntry: IDispatch);
begin
DefaultInterface.AddAce(pAccessControlEntry);
end;
procedure TAccessControlList.RemoveAce(const pAccessControlEntry: IDispatch);
begin
DefaultInterface.RemoveAce(pAccessControlEntry);
end;
function TAccessControlList.CopyAccessList: IDispatch;
begin
Result := DefaultInterface.CopyAccessList;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TAccessControlListProperties.Create(AServer: TAccessControlList);
begin
inherited Create;
FServer := AServer;
end;
function TAccessControlListProperties.GetDefaultInterface: IADsAccessControlList;
begin
Result := FServer.DefaultInterface;
end;
function TAccessControlListProperties.Get_AclRevision: Integer;
begin
Result := DefaultInterface.Get_AclRevision;
end;
procedure TAccessControlListProperties.Set_AclRevision(retval: Integer);
begin
DefaultInterface.Set_AclRevision(retval);
end;
function TAccessControlListProperties.Get_AceCount: Integer;
begin
Result := DefaultInterface.Get_AceCount;
end;
procedure TAccessControlListProperties.Set_AceCount(retval: Integer);
begin
DefaultInterface.Set_AceCount(retval);
end;
{$ENDIF}
class function CoSecurityDescriptor.Create: IADsSecurityDescriptor;
begin
Result := CreateComObject(CLASS_SecurityDescriptor) as IADsSecurityDescriptor;
end;
class function CoSecurityDescriptor.CreateRemote(const MachineName: string): IADsSecurityDescriptor;
begin
Result := CreateRemoteComObject(MachineName, CLASS_SecurityDescriptor) as IADsSecurityDescriptor;
end;
procedure TSecurityDescriptor.InitServerData;
const
CServerData: TServerData = (
ClassID: '{B958F73C-9BDD-11D0-852C-00C04FD8D503}';
IntfIID: '{B8C787CA-9BDD-11D0-852C-00C04FD8D503}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TSecurityDescriptor.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsSecurityDescriptor;
end;
end;
procedure TSecurityDescriptor.ConnectTo(svrIntf: IADsSecurityDescriptor);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TSecurityDescriptor.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TSecurityDescriptor.GetDefaultInterface: IADsSecurityDescriptor;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TSecurityDescriptor.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TSecurityDescriptorProperties.Create(Self);
{$ENDIF}
end;
destructor TSecurityDescriptor.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TSecurityDescriptor.GetServerProperties: TSecurityDescriptorProperties;
begin
Result := FProps;
end;
{$ENDIF}
function TSecurityDescriptor.Get_Revision: Integer;
begin
Result := DefaultInterface.Get_Revision;
end;
procedure TSecurityDescriptor.Set_Revision(retval: Integer);
begin
DefaultInterface.Set_Revision(retval);
end;
function TSecurityDescriptor.Get_Control: Integer;
begin
Result := DefaultInterface.Get_Control;
end;
procedure TSecurityDescriptor.Set_Control(retval: Integer);
begin
DefaultInterface.Set_Control(retval);
end;
function TSecurityDescriptor.Get_Owner: WideString;
begin
Result := DefaultInterface.Get_Owner;
end;
procedure TSecurityDescriptor.Set_Owner(const retval: WideString);
begin
DefaultInterface.Set_Owner(retval);
end;
function TSecurityDescriptor.Get_OwnerDefaulted: WordBool;
begin
Result := DefaultInterface.Get_OwnerDefaulted;
end;
procedure TSecurityDescriptor.Set_OwnerDefaulted(retval: WordBool);
begin
DefaultInterface.Set_OwnerDefaulted(retval);
end;
function TSecurityDescriptor.Get_Group: WideString;
begin
Result := DefaultInterface.Get_Group;
end;
procedure TSecurityDescriptor.Set_Group(const retval: WideString);
begin
DefaultInterface.Set_Group(retval);
end;
function TSecurityDescriptor.Get_GroupDefaulted: WordBool;
begin
Result := DefaultInterface.Get_GroupDefaulted;
end;
procedure TSecurityDescriptor.Set_GroupDefaulted(retval: WordBool);
begin
DefaultInterface.Set_GroupDefaulted(retval);
end;
function TSecurityDescriptor.Get_DiscretionaryAcl: IDispatch;
begin
Result := DefaultInterface.Get_DiscretionaryAcl;
end;
procedure TSecurityDescriptor.Set_DiscretionaryAcl(const retval: IDispatch);
begin
DefaultInterface.Set_DiscretionaryAcl(retval);
end;
function TSecurityDescriptor.Get_DaclDefaulted: WordBool;
begin
Result := DefaultInterface.Get_DaclDefaulted;
end;
procedure TSecurityDescriptor.Set_DaclDefaulted(retval: WordBool);
begin
DefaultInterface.Set_DaclDefaulted(retval);
end;
function TSecurityDescriptor.Get_SystemAcl: IDispatch;
begin
Result := DefaultInterface.Get_SystemAcl;
end;
procedure TSecurityDescriptor.Set_SystemAcl(const retval: IDispatch);
begin
DefaultInterface.Set_SystemAcl(retval);
end;
function TSecurityDescriptor.Get_SaclDefaulted: WordBool;
begin
Result := DefaultInterface.Get_SaclDefaulted;
end;
procedure TSecurityDescriptor.Set_SaclDefaulted(retval: WordBool);
begin
DefaultInterface.Set_SaclDefaulted(retval);
end;
function TSecurityDescriptor.CopySecurityDescriptor: IDispatch;
begin
Result := DefaultInterface.CopySecurityDescriptor;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TSecurityDescriptorProperties.Create(AServer: TSecurityDescriptor);
begin
inherited Create;
FServer := AServer;
end;
function TSecurityDescriptorProperties.GetDefaultInterface: IADsSecurityDescriptor;
begin
Result := FServer.DefaultInterface;
end;
function TSecurityDescriptorProperties.Get_Revision: Integer;
begin
Result := DefaultInterface.Get_Revision;
end;
procedure TSecurityDescriptorProperties.Set_Revision(retval: Integer);
begin
DefaultInterface.Set_Revision(retval);
end;
function TSecurityDescriptorProperties.Get_Control: Integer;
begin
Result := DefaultInterface.Get_Control;
end;
procedure TSecurityDescriptorProperties.Set_Control(retval: Integer);
begin
DefaultInterface.Set_Control(retval);
end;
function TSecurityDescriptorProperties.Get_Owner: WideString;
begin
Result := DefaultInterface.Get_Owner;
end;
procedure TSecurityDescriptorProperties.Set_Owner(const retval: WideString);
begin
DefaultInterface.Set_Owner(retval);
end;
function TSecurityDescriptorProperties.Get_OwnerDefaulted: WordBool;
begin
Result := DefaultInterface.Get_OwnerDefaulted;
end;
procedure TSecurityDescriptorProperties.Set_OwnerDefaulted(retval: WordBool);
begin
DefaultInterface.Set_OwnerDefaulted(retval);
end;
function TSecurityDescriptorProperties.Get_Group: WideString;
begin
Result := DefaultInterface.Get_Group;
end;
procedure TSecurityDescriptorProperties.Set_Group(const retval: WideString);
begin
DefaultInterface.Set_Group(retval);
end;
function TSecurityDescriptorProperties.Get_GroupDefaulted: WordBool;
begin
Result := DefaultInterface.Get_GroupDefaulted;
end;
procedure TSecurityDescriptorProperties.Set_GroupDefaulted(retval: WordBool);
begin
DefaultInterface.Set_GroupDefaulted(retval);
end;
function TSecurityDescriptorProperties.Get_DiscretionaryAcl: IDispatch;
begin
Result := DefaultInterface.Get_DiscretionaryAcl;
end;
procedure TSecurityDescriptorProperties.Set_DiscretionaryAcl(const retval: IDispatch);
begin
DefaultInterface.Set_DiscretionaryAcl(retval);
end;
function TSecurityDescriptorProperties.Get_DaclDefaulted: WordBool;
begin
Result := DefaultInterface.Get_DaclDefaulted;
end;
procedure TSecurityDescriptorProperties.Set_DaclDefaulted(retval: WordBool);
begin
DefaultInterface.Set_DaclDefaulted(retval);
end;
function TSecurityDescriptorProperties.Get_SystemAcl: IDispatch;
begin
Result := DefaultInterface.Get_SystemAcl;
end;
procedure TSecurityDescriptorProperties.Set_SystemAcl(const retval: IDispatch);
begin
DefaultInterface.Set_SystemAcl(retval);
end;
function TSecurityDescriptorProperties.Get_SaclDefaulted: WordBool;
begin
Result := DefaultInterface.Get_SaclDefaulted;
end;
procedure TSecurityDescriptorProperties.Set_SaclDefaulted(retval: WordBool);
begin
DefaultInterface.Set_SaclDefaulted(retval);
end;
{$ENDIF}
class function CoLargeInteger.Create: IADsLargeInteger;
begin
Result := CreateComObject(CLASS_LargeInteger) as IADsLargeInteger;
end;
class function CoLargeInteger.CreateRemote(const MachineName: string): IADsLargeInteger;
begin
Result := CreateRemoteComObject(MachineName, CLASS_LargeInteger) as IADsLargeInteger;
end;
procedure TLargeInteger.InitServerData;
const
CServerData: TServerData = (
ClassID: '{927971F5-0939-11D1-8BE1-00C04FD8D503}';
IntfIID: '{9068270B-0939-11D1-8BE1-00C04FD8D503}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TLargeInteger.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsLargeInteger;
end;
end;
procedure TLargeInteger.ConnectTo(svrIntf: IADsLargeInteger);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TLargeInteger.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TLargeInteger.GetDefaultInterface: IADsLargeInteger;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TLargeInteger.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TLargeIntegerProperties.Create(Self);
{$ENDIF}
end;
destructor TLargeInteger.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TLargeInteger.GetServerProperties: TLargeIntegerProperties;
begin
Result := FProps;
end;
{$ENDIF}
function TLargeInteger.Get_HighPart: Integer;
begin
Result := DefaultInterface.Get_HighPart;
end;
procedure TLargeInteger.Set_HighPart(retval: Integer);
begin
DefaultInterface.Set_HighPart(retval);
end;
function TLargeInteger.Get_LowPart: Integer;
begin
Result := DefaultInterface.Get_LowPart;
end;
procedure TLargeInteger.Set_LowPart(retval: Integer);
begin
DefaultInterface.Set_LowPart(retval);
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TLargeIntegerProperties.Create(AServer: TLargeInteger);
begin
inherited Create;
FServer := AServer;
end;
function TLargeIntegerProperties.GetDefaultInterface: IADsLargeInteger;
begin
Result := FServer.DefaultInterface;
end;
function TLargeIntegerProperties.Get_HighPart: Integer;
begin
Result := DefaultInterface.Get_HighPart;
end;
procedure TLargeIntegerProperties.Set_HighPart(retval: Integer);
begin
DefaultInterface.Set_HighPart(retval);
end;
function TLargeIntegerProperties.Get_LowPart: Integer;
begin
Result := DefaultInterface.Get_LowPart;
end;
procedure TLargeIntegerProperties.Set_LowPart(retval: Integer);
begin
DefaultInterface.Set_LowPart(retval);
end;
{$ENDIF}
class function CoNameTranslate.Create: IADsNameTranslate;
begin
Result := CreateComObject(CLASS_NameTranslate) as IADsNameTranslate;
end;
class function CoNameTranslate.CreateRemote(const MachineName: string): IADsNameTranslate;
begin
Result := CreateRemoteComObject(MachineName, CLASS_NameTranslate) as IADsNameTranslate;
end;
procedure TNameTranslate.InitServerData;
const
CServerData: TServerData = (
ClassID: '{274FAE1F-3626-11D1-A3A4-00C04FB950DC}';
IntfIID: '{B1B272A3-3625-11D1-A3A4-00C04FB950DC}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TNameTranslate.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsNameTranslate;
end;
end;
procedure TNameTranslate.ConnectTo(svrIntf: IADsNameTranslate);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TNameTranslate.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TNameTranslate.GetDefaultInterface: IADsNameTranslate;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TNameTranslate.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TNameTranslateProperties.Create(Self);
{$ENDIF}
end;
destructor TNameTranslate.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TNameTranslate.GetServerProperties: TNameTranslateProperties;
begin
Result := FProps;
end;
{$ENDIF}
procedure TNameTranslate.Set_ChaseReferral(Param1: Integer);
begin
DefaultInterface.Set_ChaseReferral(Param1);
end;
procedure TNameTranslate.Init(lnSetType: Integer; const bstrADsPath: WideString);
begin
DefaultInterface.Init(lnSetType, bstrADsPath);
end;
procedure TNameTranslate.InitEx(lnSetType: Integer; const bstrADsPath: WideString;
const bstrUserID: WideString; const bstrDomain: WideString;
const bstrPassword: WideString);
begin
DefaultInterface.InitEx(lnSetType, bstrADsPath, bstrUserID, bstrDomain, bstrPassword);
end;
procedure TNameTranslate.Set_(lnSetType: Integer; const bstrADsPath: WideString);
begin
DefaultInterface.Set_(lnSetType, bstrADsPath);
end;
function TNameTranslate.Get(lnFormatType: Integer): WideString;
begin
Result := DefaultInterface.Get(lnFormatType);
end;
procedure TNameTranslate.SetEx(lnFormatType: Integer; pVar: OleVariant);
begin
DefaultInterface.SetEx(lnFormatType, pVar);
end;
function TNameTranslate.GetEx(lnFormatType: Integer): OleVariant;
begin
Result := DefaultInterface.GetEx(lnFormatType);
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TNameTranslateProperties.Create(AServer: TNameTranslate);
begin
inherited Create;
FServer := AServer;
end;
function TNameTranslateProperties.GetDefaultInterface: IADsNameTranslate;
begin
Result := FServer.DefaultInterface;
end;
procedure TNameTranslateProperties.Set_ChaseReferral(Param1: Integer);
begin
DefaultInterface.Set_ChaseReferral(Param1);
end;
{$ENDIF}
class function CoCaseIgnoreList.Create: IADsCaseIgnoreList;
begin
Result := CreateComObject(CLASS_CaseIgnoreList) as IADsCaseIgnoreList;
end;
class function CoCaseIgnoreList.CreateRemote(const MachineName: string): IADsCaseIgnoreList;
begin
Result := CreateRemoteComObject(MachineName, CLASS_CaseIgnoreList) as IADsCaseIgnoreList;
end;
procedure TCaseIgnoreList.InitServerData;
const
CServerData: TServerData = (
ClassID: '{15F88A55-4680-11D1-A3B4-00C04FB950DC}';
IntfIID: '{7B66B533-4680-11D1-A3B4-00C04FB950DC}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TCaseIgnoreList.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsCaseIgnoreList;
end;
end;
procedure TCaseIgnoreList.ConnectTo(svrIntf: IADsCaseIgnoreList);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TCaseIgnoreList.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TCaseIgnoreList.GetDefaultInterface: IADsCaseIgnoreList;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TCaseIgnoreList.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TCaseIgnoreListProperties.Create(Self);
{$ENDIF}
end;
destructor TCaseIgnoreList.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TCaseIgnoreList.GetServerProperties: TCaseIgnoreListProperties;
begin
Result := FProps;
end;
{$ENDIF}
function TCaseIgnoreList.Get_CaseIgnoreList: OleVariant;
begin
Result := DefaultInterface.Get_CaseIgnoreList;
end;
procedure TCaseIgnoreList.Set_CaseIgnoreList(retval: OleVariant);
begin
DefaultInterface.Set_CaseIgnoreList(retval);
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TCaseIgnoreListProperties.Create(AServer: TCaseIgnoreList);
begin
inherited Create;
FServer := AServer;
end;
function TCaseIgnoreListProperties.GetDefaultInterface: IADsCaseIgnoreList;
begin
Result := FServer.DefaultInterface;
end;
function TCaseIgnoreListProperties.Get_CaseIgnoreList: OleVariant;
begin
Result := DefaultInterface.Get_CaseIgnoreList;
end;
procedure TCaseIgnoreListProperties.Set_CaseIgnoreList(retval: OleVariant);
begin
DefaultInterface.Set_CaseIgnoreList(retval);
end;
{$ENDIF}
class function CoFaxNumber.Create: IADsFaxNumber;
begin
Result := CreateComObject(CLASS_FaxNumber) as IADsFaxNumber;
end;
class function CoFaxNumber.CreateRemote(const MachineName: string): IADsFaxNumber;
begin
Result := CreateRemoteComObject(MachineName, CLASS_FaxNumber) as IADsFaxNumber;
end;
procedure TFaxNumber.InitServerData;
const
CServerData: TServerData = (
ClassID: '{A5062215-4681-11D1-A3B4-00C04FB950DC}';
IntfIID: '{A910DEA9-4680-11D1-A3B4-00C04FB950DC}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TFaxNumber.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsFaxNumber;
end;
end;
procedure TFaxNumber.ConnectTo(svrIntf: IADsFaxNumber);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TFaxNumber.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TFaxNumber.GetDefaultInterface: IADsFaxNumber;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TFaxNumber.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TFaxNumberProperties.Create(Self);
{$ENDIF}
end;
destructor TFaxNumber.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TFaxNumber.GetServerProperties: TFaxNumberProperties;
begin
Result := FProps;
end;
{$ENDIF}
function TFaxNumber.Get_TelephoneNumber: WideString;
begin
Result := DefaultInterface.Get_TelephoneNumber;
end;
procedure TFaxNumber.Set_TelephoneNumber(const retval: WideString);
begin
DefaultInterface.Set_TelephoneNumber(retval);
end;
function TFaxNumber.Get_Parameters: OleVariant;
begin
Result := DefaultInterface.Get_Parameters;
end;
procedure TFaxNumber.Set_Parameters(retval: OleVariant);
begin
DefaultInterface.Set_Parameters(retval);
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TFaxNumberProperties.Create(AServer: TFaxNumber);
begin
inherited Create;
FServer := AServer;
end;
function TFaxNumberProperties.GetDefaultInterface: IADsFaxNumber;
begin
Result := FServer.DefaultInterface;
end;
function TFaxNumberProperties.Get_TelephoneNumber: WideString;
begin
Result := DefaultInterface.Get_TelephoneNumber;
end;
procedure TFaxNumberProperties.Set_TelephoneNumber(const retval: WideString);
begin
DefaultInterface.Set_TelephoneNumber(retval);
end;
function TFaxNumberProperties.Get_Parameters: OleVariant;
begin
Result := DefaultInterface.Get_Parameters;
end;
procedure TFaxNumberProperties.Set_Parameters(retval: OleVariant);
begin
DefaultInterface.Set_Parameters(retval);
end;
{$ENDIF}
class function CoNetAddress.Create: IADsNetAddress;
begin
Result := CreateComObject(CLASS_NetAddress) as IADsNetAddress;
end;
class function CoNetAddress.CreateRemote(const MachineName: string): IADsNetAddress;
begin
Result := CreateRemoteComObject(MachineName, CLASS_NetAddress) as IADsNetAddress;
end;
procedure TNetAddress.InitServerData;
const
CServerData: TServerData = (
ClassID: '{B0B71247-4080-11D1-A3AC-00C04FB950DC}';
IntfIID: '{B21A50A9-4080-11D1-A3AC-00C04FB950DC}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TNetAddress.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsNetAddress;
end;
end;
procedure TNetAddress.ConnectTo(svrIntf: IADsNetAddress);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TNetAddress.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TNetAddress.GetDefaultInterface: IADsNetAddress;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TNetAddress.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TNetAddressProperties.Create(Self);
{$ENDIF}
end;
destructor TNetAddress.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TNetAddress.GetServerProperties: TNetAddressProperties;
begin
Result := FProps;
end;
{$ENDIF}
function TNetAddress.Get_AddressType: Integer;
begin
Result := DefaultInterface.Get_AddressType;
end;
procedure TNetAddress.Set_AddressType(retval: Integer);
begin
DefaultInterface.Set_AddressType(retval);
end;
function TNetAddress.Get_Address: OleVariant;
begin
Result := DefaultInterface.Get_Address;
end;
procedure TNetAddress.Set_Address(retval: OleVariant);
begin
DefaultInterface.Set_Address(retval);
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TNetAddressProperties.Create(AServer: TNetAddress);
begin
inherited Create;
FServer := AServer;
end;
function TNetAddressProperties.GetDefaultInterface: IADsNetAddress;
begin
Result := FServer.DefaultInterface;
end;
function TNetAddressProperties.Get_AddressType: Integer;
begin
Result := DefaultInterface.Get_AddressType;
end;
procedure TNetAddressProperties.Set_AddressType(retval: Integer);
begin
DefaultInterface.Set_AddressType(retval);
end;
function TNetAddressProperties.Get_Address: OleVariant;
begin
Result := DefaultInterface.Get_Address;
end;
procedure TNetAddressProperties.Set_Address(retval: OleVariant);
begin
DefaultInterface.Set_Address(retval);
end;
{$ENDIF}
class function CoOctetList.Create: IADsOctetList;
begin
Result := CreateComObject(CLASS_OctetList) as IADsOctetList;
end;
class function CoOctetList.CreateRemote(const MachineName: string): IADsOctetList;
begin
Result := CreateRemoteComObject(MachineName, CLASS_OctetList) as IADsOctetList;
end;
procedure TOctetList.InitServerData;
const
CServerData: TServerData = (
ClassID: '{1241400F-4680-11D1-A3B4-00C04FB950DC}';
IntfIID: '{7B28B80F-4680-11D1-A3B4-00C04FB950DC}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TOctetList.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsOctetList;
end;
end;
procedure TOctetList.ConnectTo(svrIntf: IADsOctetList);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TOctetList.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TOctetList.GetDefaultInterface: IADsOctetList;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TOctetList.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TOctetListProperties.Create(Self);
{$ENDIF}
end;
destructor TOctetList.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TOctetList.GetServerProperties: TOctetListProperties;
begin
Result := FProps;
end;
{$ENDIF}
function TOctetList.Get_OctetList: OleVariant;
begin
Result := DefaultInterface.Get_OctetList;
end;
procedure TOctetList.Set_OctetList(retval: OleVariant);
begin
DefaultInterface.Set_OctetList(retval);
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TOctetListProperties.Create(AServer: TOctetList);
begin
inherited Create;
FServer := AServer;
end;
function TOctetListProperties.GetDefaultInterface: IADsOctetList;
begin
Result := FServer.DefaultInterface;
end;
function TOctetListProperties.Get_OctetList: OleVariant;
begin
Result := DefaultInterface.Get_OctetList;
end;
procedure TOctetListProperties.Set_OctetList(retval: OleVariant);
begin
DefaultInterface.Set_OctetList(retval);
end;
{$ENDIF}
class function CoEmail.Create: IADsEmail;
begin
Result := CreateComObject(CLASS_Email) as IADsEmail;
end;
class function CoEmail.CreateRemote(const MachineName: string): IADsEmail;
begin
Result := CreateRemoteComObject(MachineName, CLASS_Email) as IADsEmail;
end;
procedure TEmail.InitServerData;
const
CServerData: TServerData = (
ClassID: '{8F92A857-478E-11D1-A3B4-00C04FB950DC}';
IntfIID: '{97AF011A-478E-11D1-A3B4-00C04FB950DC}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TEmail.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsEmail;
end;
end;
procedure TEmail.ConnectTo(svrIntf: IADsEmail);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TEmail.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TEmail.GetDefaultInterface: IADsEmail;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TEmail.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TEmailProperties.Create(Self);
{$ENDIF}
end;
destructor TEmail.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TEmail.GetServerProperties: TEmailProperties;
begin
Result := FProps;
end;
{$ENDIF}
function TEmail.Get_Type_: Integer;
begin
Result := DefaultInterface.Get_Type_;
end;
procedure TEmail.Set_Type_(retval: Integer);
begin
DefaultInterface.Set_Type_(retval);
end;
function TEmail.Get_Address: WideString;
begin
Result := DefaultInterface.Get_Address;
end;
procedure TEmail.Set_Address(const retval: WideString);
begin
DefaultInterface.Set_Address(retval);
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TEmailProperties.Create(AServer: TEmail);
begin
inherited Create;
FServer := AServer;
end;
function TEmailProperties.GetDefaultInterface: IADsEmail;
begin
Result := FServer.DefaultInterface;
end;
function TEmailProperties.Get_Type_: Integer;
begin
Result := DefaultInterface.Get_Type_;
end;
procedure TEmailProperties.Set_Type_(retval: Integer);
begin
DefaultInterface.Set_Type_(retval);
end;
function TEmailProperties.Get_Address: WideString;
begin
Result := DefaultInterface.Get_Address;
end;
procedure TEmailProperties.Set_Address(const retval: WideString);
begin
DefaultInterface.Set_Address(retval);
end;
{$ENDIF}
class function CoPath.Create: IADsPath;
begin
Result := CreateComObject(CLASS_Path) as IADsPath;
end;
class function CoPath.CreateRemote(const MachineName: string): IADsPath;
begin
Result := CreateRemoteComObject(MachineName, CLASS_Path) as IADsPath;
end;
procedure TPath.InitServerData;
const
CServerData: TServerData = (
ClassID: '{B2538919-4080-11D1-A3AC-00C04FB950DC}';
IntfIID: '{B287FCD5-4080-11D1-A3AC-00C04FB950DC}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TPath.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsPath;
end;
end;
procedure TPath.ConnectTo(svrIntf: IADsPath);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TPath.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TPath.GetDefaultInterface: IADsPath;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TPath.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TPathProperties.Create(Self);
{$ENDIF}
end;
destructor TPath.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TPath.GetServerProperties: TPathProperties;
begin
Result := FProps;
end;
{$ENDIF}
function TPath.Get_Type_: Integer;
begin
Result := DefaultInterface.Get_Type_;
end;
procedure TPath.Set_Type_(retval: Integer);
begin
DefaultInterface.Set_Type_(retval);
end;
function TPath.Get_VolumeName: WideString;
begin
Result := DefaultInterface.Get_VolumeName;
end;
procedure TPath.Set_VolumeName(const retval: WideString);
begin
DefaultInterface.Set_VolumeName(retval);
end;
function TPath.Get_Path: WideString;
begin
Result := DefaultInterface.Get_Path;
end;
procedure TPath.Set_Path(const retval: WideString);
begin
DefaultInterface.Set_Path(retval);
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TPathProperties.Create(AServer: TPath);
begin
inherited Create;
FServer := AServer;
end;
function TPathProperties.GetDefaultInterface: IADsPath;
begin
Result := FServer.DefaultInterface;
end;
function TPathProperties.Get_Type_: Integer;
begin
Result := DefaultInterface.Get_Type_;
end;
procedure TPathProperties.Set_Type_(retval: Integer);
begin
DefaultInterface.Set_Type_(retval);
end;
function TPathProperties.Get_VolumeName: WideString;
begin
Result := DefaultInterface.Get_VolumeName;
end;
procedure TPathProperties.Set_VolumeName(const retval: WideString);
begin
DefaultInterface.Set_VolumeName(retval);
end;
function TPathProperties.Get_Path: WideString;
begin
Result := DefaultInterface.Get_Path;
end;
procedure TPathProperties.Set_Path(const retval: WideString);
begin
DefaultInterface.Set_Path(retval);
end;
{$ENDIF}
class function CoReplicaPointer.Create: IADsReplicaPointer;
begin
Result := CreateComObject(CLASS_ReplicaPointer) as IADsReplicaPointer;
end;
class function CoReplicaPointer.CreateRemote(const MachineName: string): IADsReplicaPointer;
begin
Result := CreateRemoteComObject(MachineName, CLASS_ReplicaPointer) as IADsReplicaPointer;
end;
procedure TReplicaPointer.InitServerData;
const
CServerData: TServerData = (
ClassID: '{F5D1BADF-4080-11D1-A3AC-00C04FB950DC}';
IntfIID: '{F60FB803-4080-11D1-A3AC-00C04FB950DC}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TReplicaPointer.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsReplicaPointer;
end;
end;
procedure TReplicaPointer.ConnectTo(svrIntf: IADsReplicaPointer);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TReplicaPointer.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TReplicaPointer.GetDefaultInterface: IADsReplicaPointer;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TReplicaPointer.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TReplicaPointerProperties.Create(Self);
{$ENDIF}
end;
destructor TReplicaPointer.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TReplicaPointer.GetServerProperties: TReplicaPointerProperties;
begin
Result := FProps;
end;
{$ENDIF}
function TReplicaPointer.Get_ServerName: WideString;
begin
Result := DefaultInterface.Get_ServerName;
end;
procedure TReplicaPointer.Set_ServerName(const retval: WideString);
begin
DefaultInterface.Set_ServerName(retval);
end;
function TReplicaPointer.Get_ReplicaType: Integer;
begin
Result := DefaultInterface.Get_ReplicaType;
end;
procedure TReplicaPointer.Set_ReplicaType(retval: Integer);
begin
DefaultInterface.Set_ReplicaType(retval);
end;
function TReplicaPointer.Get_ReplicaNumber: Integer;
begin
Result := DefaultInterface.Get_ReplicaNumber;
end;
procedure TReplicaPointer.Set_ReplicaNumber(retval: Integer);
begin
DefaultInterface.Set_ReplicaNumber(retval);
end;
function TReplicaPointer.Get_Count: Integer;
begin
Result := DefaultInterface.Get_Count;
end;
procedure TReplicaPointer.Set_Count(retval: Integer);
begin
DefaultInterface.Set_Count(retval);
end;
function TReplicaPointer.Get_ReplicaAddressHints: OleVariant;
begin
Result := DefaultInterface.Get_ReplicaAddressHints;
end;
procedure TReplicaPointer.Set_ReplicaAddressHints(retval: OleVariant);
begin
DefaultInterface.Set_ReplicaAddressHints(retval);
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TReplicaPointerProperties.Create(AServer: TReplicaPointer);
begin
inherited Create;
FServer := AServer;
end;
function TReplicaPointerProperties.GetDefaultInterface: IADsReplicaPointer;
begin
Result := FServer.DefaultInterface;
end;
function TReplicaPointerProperties.Get_ServerName: WideString;
begin
Result := DefaultInterface.Get_ServerName;
end;
procedure TReplicaPointerProperties.Set_ServerName(const retval: WideString);
begin
DefaultInterface.Set_ServerName(retval);
end;
function TReplicaPointerProperties.Get_ReplicaType: Integer;
begin
Result := DefaultInterface.Get_ReplicaType;
end;
procedure TReplicaPointerProperties.Set_ReplicaType(retval: Integer);
begin
DefaultInterface.Set_ReplicaType(retval);
end;
function TReplicaPointerProperties.Get_ReplicaNumber: Integer;
begin
Result := DefaultInterface.Get_ReplicaNumber;
end;
procedure TReplicaPointerProperties.Set_ReplicaNumber(retval: Integer);
begin
DefaultInterface.Set_ReplicaNumber(retval);
end;
function TReplicaPointerProperties.Get_Count: Integer;
begin
Result := DefaultInterface.Get_Count;
end;
procedure TReplicaPointerProperties.Set_Count(retval: Integer);
begin
DefaultInterface.Set_Count(retval);
end;
function TReplicaPointerProperties.Get_ReplicaAddressHints: OleVariant;
begin
Result := DefaultInterface.Get_ReplicaAddressHints;
end;
procedure TReplicaPointerProperties.Set_ReplicaAddressHints(retval: OleVariant);
begin
DefaultInterface.Set_ReplicaAddressHints(retval);
end;
{$ENDIF}
class function CoAcl.Create: IADsAcl;
begin
Result := CreateComObject(CLASS_Acl) as IADsAcl;
end;
class function CoAcl.CreateRemote(const MachineName: string): IADsAcl;
begin
Result := CreateRemoteComObject(MachineName, CLASS_Acl) as IADsAcl;
end;
procedure TAcl.InitServerData;
const
CServerData: TServerData = (
ClassID: '{7AF1EFB6-0869-11D1-A377-00C04FB950DC}';
IntfIID: '{8452D3AB-0869-11D1-A377-00C04FB950DC}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TAcl.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsAcl;
end;
end;
procedure TAcl.ConnectTo(svrIntf: IADsAcl);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TAcl.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TAcl.GetDefaultInterface: IADsAcl;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TAcl.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TAclProperties.Create(Self);
{$ENDIF}
end;
destructor TAcl.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TAcl.GetServerProperties: TAclProperties;
begin
Result := FProps;
end;
{$ENDIF}
function TAcl.Get_ProtectedAttrName: WideString;
begin
Result := DefaultInterface.Get_ProtectedAttrName;
end;
procedure TAcl.Set_ProtectedAttrName(const retval: WideString);
begin
DefaultInterface.Set_ProtectedAttrName(retval);
end;
function TAcl.Get_SubjectName: WideString;
begin
Result := DefaultInterface.Get_SubjectName;
end;
procedure TAcl.Set_SubjectName(const retval: WideString);
begin
DefaultInterface.Set_SubjectName(retval);
end;
function TAcl.Get_Privileges: Integer;
begin
Result := DefaultInterface.Get_Privileges;
end;
procedure TAcl.Set_Privileges(retval: Integer);
begin
DefaultInterface.Set_Privileges(retval);
end;
function TAcl.CopyAcl: IDispatch;
begin
Result := DefaultInterface.CopyAcl;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TAclProperties.Create(AServer: TAcl);
begin
inherited Create;
FServer := AServer;
end;
function TAclProperties.GetDefaultInterface: IADsAcl;
begin
Result := FServer.DefaultInterface;
end;
function TAclProperties.Get_ProtectedAttrName: WideString;
begin
Result := DefaultInterface.Get_ProtectedAttrName;
end;
procedure TAclProperties.Set_ProtectedAttrName(const retval: WideString);
begin
DefaultInterface.Set_ProtectedAttrName(retval);
end;
function TAclProperties.Get_SubjectName: WideString;
begin
Result := DefaultInterface.Get_SubjectName;
end;
procedure TAclProperties.Set_SubjectName(const retval: WideString);
begin
DefaultInterface.Set_SubjectName(retval);
end;
function TAclProperties.Get_Privileges: Integer;
begin
Result := DefaultInterface.Get_Privileges;
end;
procedure TAclProperties.Set_Privileges(retval: Integer);
begin
DefaultInterface.Set_Privileges(retval);
end;
{$ENDIF}
class function CoTimestamp.Create: IADsTimestamp;
begin
Result := CreateComObject(CLASS_Timestamp) as IADsTimestamp;
end;
class function CoTimestamp.CreateRemote(const MachineName: string): IADsTimestamp;
begin
Result := CreateRemoteComObject(MachineName, CLASS_Timestamp) as IADsTimestamp;
end;
procedure TTimestamp.InitServerData;
const
CServerData: TServerData = (
ClassID: '{B2BED2EB-4080-11D1-A3AC-00C04FB950DC}';
IntfIID: '{B2F5A901-4080-11D1-A3AC-00C04FB950DC}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TTimestamp.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsTimestamp;
end;
end;
procedure TTimestamp.ConnectTo(svrIntf: IADsTimestamp);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TTimestamp.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TTimestamp.GetDefaultInterface: IADsTimestamp;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TTimestamp.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TTimestampProperties.Create(Self);
{$ENDIF}
end;
destructor TTimestamp.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TTimestamp.GetServerProperties: TTimestampProperties;
begin
Result := FProps;
end;
{$ENDIF}
function TTimestamp.Get_WholeSeconds: Integer;
begin
Result := DefaultInterface.Get_WholeSeconds;
end;
procedure TTimestamp.Set_WholeSeconds(retval: Integer);
begin
DefaultInterface.Set_WholeSeconds(retval);
end;
function TTimestamp.Get_EventID: Integer;
begin
Result := DefaultInterface.Get_EventID;
end;
procedure TTimestamp.Set_EventID(retval: Integer);
begin
DefaultInterface.Set_EventID(retval);
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TTimestampProperties.Create(AServer: TTimestamp);
begin
inherited Create;
FServer := AServer;
end;
function TTimestampProperties.GetDefaultInterface: IADsTimestamp;
begin
Result := FServer.DefaultInterface;
end;
function TTimestampProperties.Get_WholeSeconds: Integer;
begin
Result := DefaultInterface.Get_WholeSeconds;
end;
procedure TTimestampProperties.Set_WholeSeconds(retval: Integer);
begin
DefaultInterface.Set_WholeSeconds(retval);
end;
function TTimestampProperties.Get_EventID: Integer;
begin
Result := DefaultInterface.Get_EventID;
end;
procedure TTimestampProperties.Set_EventID(retval: Integer);
begin
DefaultInterface.Set_EventID(retval);
end;
{$ENDIF}
class function CoPostalAddress.Create: IADsPostalAddress;
begin
Result := CreateComObject(CLASS_PostalAddress) as IADsPostalAddress;
end;
class function CoPostalAddress.CreateRemote(const MachineName: string): IADsPostalAddress;
begin
Result := CreateRemoteComObject(MachineName, CLASS_PostalAddress) as IADsPostalAddress;
end;
procedure TPostalAddress.InitServerData;
const
CServerData: TServerData = (
ClassID: '{0A75AFCD-4680-11D1-A3B4-00C04FB950DC}';
IntfIID: '{7ADECF29-4680-11D1-A3B4-00C04FB950DC}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TPostalAddress.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsPostalAddress;
end;
end;
procedure TPostalAddress.ConnectTo(svrIntf: IADsPostalAddress);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TPostalAddress.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TPostalAddress.GetDefaultInterface: IADsPostalAddress;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TPostalAddress.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TPostalAddressProperties.Create(Self);
{$ENDIF}
end;
destructor TPostalAddress.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TPostalAddress.GetServerProperties: TPostalAddressProperties;
begin
Result := FProps;
end;
{$ENDIF}
function TPostalAddress.Get_PostalAddress: OleVariant;
begin
Result := DefaultInterface.Get_PostalAddress;
end;
procedure TPostalAddress.Set_PostalAddress(retval: OleVariant);
begin
DefaultInterface.Set_PostalAddress(retval);
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TPostalAddressProperties.Create(AServer: TPostalAddress);
begin
inherited Create;
FServer := AServer;
end;
function TPostalAddressProperties.GetDefaultInterface: IADsPostalAddress;
begin
Result := FServer.DefaultInterface;
end;
function TPostalAddressProperties.Get_PostalAddress: OleVariant;
begin
Result := DefaultInterface.Get_PostalAddress;
end;
procedure TPostalAddressProperties.Set_PostalAddress(retval: OleVariant);
begin
DefaultInterface.Set_PostalAddress(retval);
end;
{$ENDIF}
class function CoBackLink.Create: IADsBackLink;
begin
Result := CreateComObject(CLASS_BackLink) as IADsBackLink;
end;
class function CoBackLink.CreateRemote(const MachineName: string): IADsBackLink;
begin
Result := CreateRemoteComObject(MachineName, CLASS_BackLink) as IADsBackLink;
end;
procedure TBackLink.InitServerData;
const
CServerData: TServerData = (
ClassID: '{FCBF906F-4080-11D1-A3AC-00C04FB950DC}';
IntfIID: '{FD1302BD-4080-11D1-A3AC-00C04FB950DC}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TBackLink.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsBackLink;
end;
end;
procedure TBackLink.ConnectTo(svrIntf: IADsBackLink);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TBackLink.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TBackLink.GetDefaultInterface: IADsBackLink;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TBackLink.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TBackLinkProperties.Create(Self);
{$ENDIF}
end;
destructor TBackLink.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TBackLink.GetServerProperties: TBackLinkProperties;
begin
Result := FProps;
end;
{$ENDIF}
function TBackLink.Get_RemoteID: Integer;
begin
Result := DefaultInterface.Get_RemoteID;
end;
procedure TBackLink.Set_RemoteID(retval: Integer);
begin
DefaultInterface.Set_RemoteID(retval);
end;
function TBackLink.Get_ObjectName: WideString;
begin
Result := DefaultInterface.Get_ObjectName;
end;
procedure TBackLink.Set_ObjectName(const retval: WideString);
begin
DefaultInterface.Set_ObjectName(retval);
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TBackLinkProperties.Create(AServer: TBackLink);
begin
inherited Create;
FServer := AServer;
end;
function TBackLinkProperties.GetDefaultInterface: IADsBackLink;
begin
Result := FServer.DefaultInterface;
end;
function TBackLinkProperties.Get_RemoteID: Integer;
begin
Result := DefaultInterface.Get_RemoteID;
end;
procedure TBackLinkProperties.Set_RemoteID(retval: Integer);
begin
DefaultInterface.Set_RemoteID(retval);
end;
function TBackLinkProperties.Get_ObjectName: WideString;
begin
Result := DefaultInterface.Get_ObjectName;
end;
procedure TBackLinkProperties.Set_ObjectName(const retval: WideString);
begin
DefaultInterface.Set_ObjectName(retval);
end;
{$ENDIF}
class function CoTypedName.Create: IADsTypedName;
begin
Result := CreateComObject(CLASS_TypedName) as IADsTypedName;
end;
class function CoTypedName.CreateRemote(const MachineName: string): IADsTypedName;
begin
Result := CreateRemoteComObject(MachineName, CLASS_TypedName) as IADsTypedName;
end;
procedure TTypedName.InitServerData;
const
CServerData: TServerData = (
ClassID: '{B33143CB-4080-11D1-A3AC-00C04FB950DC}';
IntfIID: '{B371A349-4080-11D1-A3AC-00C04FB950DC}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TTypedName.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsTypedName;
end;
end;
procedure TTypedName.ConnectTo(svrIntf: IADsTypedName);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TTypedName.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TTypedName.GetDefaultInterface: IADsTypedName;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TTypedName.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TTypedNameProperties.Create(Self);
{$ENDIF}
end;
destructor TTypedName.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TTypedName.GetServerProperties: TTypedNameProperties;
begin
Result := FProps;
end;
{$ENDIF}
function TTypedName.Get_ObjectName: WideString;
begin
Result := DefaultInterface.Get_ObjectName;
end;
procedure TTypedName.Set_ObjectName(const retval: WideString);
begin
DefaultInterface.Set_ObjectName(retval);
end;
function TTypedName.Get_Level: Integer;
begin
Result := DefaultInterface.Get_Level;
end;
procedure TTypedName.Set_Level(retval: Integer);
begin
DefaultInterface.Set_Level(retval);
end;
function TTypedName.Get_Interval: Integer;
begin
Result := DefaultInterface.Get_Interval;
end;
procedure TTypedName.Set_Interval(retval: Integer);
begin
DefaultInterface.Set_Interval(retval);
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TTypedNameProperties.Create(AServer: TTypedName);
begin
inherited Create;
FServer := AServer;
end;
function TTypedNameProperties.GetDefaultInterface: IADsTypedName;
begin
Result := FServer.DefaultInterface;
end;
function TTypedNameProperties.Get_ObjectName: WideString;
begin
Result := DefaultInterface.Get_ObjectName;
end;
procedure TTypedNameProperties.Set_ObjectName(const retval: WideString);
begin
DefaultInterface.Set_ObjectName(retval);
end;
function TTypedNameProperties.Get_Level: Integer;
begin
Result := DefaultInterface.Get_Level;
end;
procedure TTypedNameProperties.Set_Level(retval: Integer);
begin
DefaultInterface.Set_Level(retval);
end;
function TTypedNameProperties.Get_Interval: Integer;
begin
Result := DefaultInterface.Get_Interval;
end;
procedure TTypedNameProperties.Set_Interval(retval: Integer);
begin
DefaultInterface.Set_Interval(retval);
end;
{$ENDIF}
class function CoHold.Create: IADsHold;
begin
Result := CreateComObject(CLASS_Hold) as IADsHold;
end;
class function CoHold.CreateRemote(const MachineName: string): IADsHold;
begin
Result := CreateRemoteComObject(MachineName, CLASS_Hold) as IADsHold;
end;
procedure THold.InitServerData;
const
CServerData: TServerData = (
ClassID: '{B3AD3E13-4080-11D1-A3AC-00C04FB950DC}';
IntfIID: '{B3EB3B37-4080-11D1-A3AC-00C04FB950DC}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure THold.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsHold;
end;
end;
procedure THold.ConnectTo(svrIntf: IADsHold);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure THold.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function THold.GetDefaultInterface: IADsHold;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor THold.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := THoldProperties.Create(Self);
{$ENDIF}
end;
destructor THold.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function THold.GetServerProperties: THoldProperties;
begin
Result := FProps;
end;
{$ENDIF}
function THold.Get_ObjectName: WideString;
begin
Result := DefaultInterface.Get_ObjectName;
end;
procedure THold.Set_ObjectName(const retval: WideString);
begin
DefaultInterface.Set_ObjectName(retval);
end;
function THold.Get_Amount: Integer;
begin
Result := DefaultInterface.Get_Amount;
end;
procedure THold.Set_Amount(retval: Integer);
begin
DefaultInterface.Set_Amount(retval);
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor THoldProperties.Create(AServer: THold);
begin
inherited Create;
FServer := AServer;
end;
function THoldProperties.GetDefaultInterface: IADsHold;
begin
Result := FServer.DefaultInterface;
end;
function THoldProperties.Get_ObjectName: WideString;
begin
Result := DefaultInterface.Get_ObjectName;
end;
procedure THoldProperties.Set_ObjectName(const retval: WideString);
begin
DefaultInterface.Set_ObjectName(retval);
end;
function THoldProperties.Get_Amount: Integer;
begin
Result := DefaultInterface.Get_Amount;
end;
procedure THoldProperties.Set_Amount(retval: Integer);
begin
DefaultInterface.Set_Amount(retval);
end;
{$ENDIF}
class function CoPathname.Create: IADsPathname;
begin
Result := CreateComObject(CLASS_Pathname) as IADsPathname;
end;
class function CoPathname.CreateRemote(const MachineName: string): IADsPathname;
begin
Result := CreateRemoteComObject(MachineName, CLASS_Pathname) as IADsPathname;
end;
procedure TPathname.InitServerData;
const
CServerData: TServerData = (
ClassID: '{080D0D78-F421-11D0-A36E-00C04FB950DC}';
IntfIID: '{D592AED4-F420-11D0-A36E-00C04FB950DC}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TPathname.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsPathname;
end;
end;
procedure TPathname.ConnectTo(svrIntf: IADsPathname);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TPathname.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TPathname.GetDefaultInterface: IADsPathname;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TPathname.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TPathnameProperties.Create(Self);
{$ENDIF}
end;
destructor TPathname.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TPathname.GetServerProperties: TPathnameProperties;
begin
Result := FProps;
end;
{$ENDIF}
function TPathname.Get_EscapedMode: Integer;
begin
Result := DefaultInterface.Get_EscapedMode;
end;
procedure TPathname.Set_EscapedMode(retval: Integer);
begin
DefaultInterface.Set_EscapedMode(retval);
end;
procedure TPathname.Set_(const bstrADsPath: WideString; lnSetType: Integer);
begin
DefaultInterface.Set_(bstrADsPath, lnSetType);
end;
procedure TPathname.SetDisplayType(lnDisplayType: Integer);
begin
DefaultInterface.SetDisplayType(lnDisplayType);
end;
function TPathname.Retrieve(lnFormatType: Integer): WideString;
begin
Result := DefaultInterface.Retrieve(lnFormatType);
end;
function TPathname.GetNumElements: Integer;
begin
Result := DefaultInterface.GetNumElements;
end;
function TPathname.GetElement(lnElementIndex: Integer): WideString;
begin
Result := DefaultInterface.GetElement(lnElementIndex);
end;
procedure TPathname.AddLeafElement(const bstrLeafElement: WideString);
begin
DefaultInterface.AddLeafElement(bstrLeafElement);
end;
procedure TPathname.RemoveLeafElement;
begin
DefaultInterface.RemoveLeafElement;
end;
function TPathname.CopyPath: IDispatch;
begin
Result := DefaultInterface.CopyPath;
end;
function TPathname.GetEscapedElement(lnReserved: Integer; const bstrInStr: WideString): WideString;
begin
Result := DefaultInterface.GetEscapedElement(lnReserved, bstrInStr);
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TPathnameProperties.Create(AServer: TPathname);
begin
inherited Create;
FServer := AServer;
end;
function TPathnameProperties.GetDefaultInterface: IADsPathname;
begin
Result := FServer.DefaultInterface;
end;
function TPathnameProperties.Get_EscapedMode: Integer;
begin
Result := DefaultInterface.Get_EscapedMode;
end;
procedure TPathnameProperties.Set_EscapedMode(retval: Integer);
begin
DefaultInterface.Set_EscapedMode(retval);
end;
{$ENDIF}
class function CoADSystemInfo.Create: IADsADSystemInfo;
begin
Result := CreateComObject(CLASS_ADSystemInfo) as IADsADSystemInfo;
end;
class function CoADSystemInfo.CreateRemote(const MachineName: string): IADsADSystemInfo;
begin
Result := CreateRemoteComObject(MachineName, CLASS_ADSystemInfo) as IADsADSystemInfo;
end;
procedure TADSystemInfo.InitServerData;
const
CServerData: TServerData = (
ClassID: '{50B6327F-AFD1-11D2-9CB9-0000F87A369E}';
IntfIID: '{5BB11929-AFD1-11D2-9CB9-0000F87A369E}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TADSystemInfo.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsADSystemInfo;
end;
end;
procedure TADSystemInfo.ConnectTo(svrIntf: IADsADSystemInfo);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TADSystemInfo.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TADSystemInfo.GetDefaultInterface: IADsADSystemInfo;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TADSystemInfo.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TADSystemInfoProperties.Create(Self);
{$ENDIF}
end;
destructor TADSystemInfo.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TADSystemInfo.GetServerProperties: TADSystemInfoProperties;
begin
Result := FProps;
end;
{$ENDIF}
function TADSystemInfo.Get_UserName: WideString;
begin
Result := DefaultInterface.Get_UserName;
end;
function TADSystemInfo.Get_ComputerName: WideString;
begin
Result := DefaultInterface.Get_ComputerName;
end;
function TADSystemInfo.Get_SiteName: WideString;
begin
Result := DefaultInterface.Get_SiteName;
end;
function TADSystemInfo.Get_DomainShortName: WideString;
begin
Result := DefaultInterface.Get_DomainShortName;
end;
function TADSystemInfo.Get_DomainDNSName: WideString;
begin
Result := DefaultInterface.Get_DomainDNSName;
end;
function TADSystemInfo.Get_ForestDNSName: WideString;
begin
Result := DefaultInterface.Get_ForestDNSName;
end;
function TADSystemInfo.Get_PDCRoleOwner: WideString;
begin
Result := DefaultInterface.Get_PDCRoleOwner;
end;
function TADSystemInfo.Get_SchemaRoleOwner: WideString;
begin
Result := DefaultInterface.Get_SchemaRoleOwner;
end;
function TADSystemInfo.Get_IsNativeMode: WordBool;
begin
Result := DefaultInterface.Get_IsNativeMode;
end;
function TADSystemInfo.GetAnyDCName: WideString;
begin
Result := DefaultInterface.GetAnyDCName;
end;
function TADSystemInfo.GetDCSiteName(const szServer: WideString): WideString;
begin
Result := DefaultInterface.GetDCSiteName(szServer);
end;
procedure TADSystemInfo.RefreshSchemaCache;
begin
DefaultInterface.RefreshSchemaCache;
end;
function TADSystemInfo.GetTrees: OleVariant;
begin
Result := DefaultInterface.GetTrees;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TADSystemInfoProperties.Create(AServer: TADSystemInfo);
begin
inherited Create;
FServer := AServer;
end;
function TADSystemInfoProperties.GetDefaultInterface: IADsADSystemInfo;
begin
Result := FServer.DefaultInterface;
end;
function TADSystemInfoProperties.Get_UserName: WideString;
begin
Result := DefaultInterface.Get_UserName;
end;
function TADSystemInfoProperties.Get_ComputerName: WideString;
begin
Result := DefaultInterface.Get_ComputerName;
end;
function TADSystemInfoProperties.Get_SiteName: WideString;
begin
Result := DefaultInterface.Get_SiteName;
end;
function TADSystemInfoProperties.Get_DomainShortName: WideString;
begin
Result := DefaultInterface.Get_DomainShortName;
end;
function TADSystemInfoProperties.Get_DomainDNSName: WideString;
begin
Result := DefaultInterface.Get_DomainDNSName;
end;
function TADSystemInfoProperties.Get_ForestDNSName: WideString;
begin
Result := DefaultInterface.Get_ForestDNSName;
end;
function TADSystemInfoProperties.Get_PDCRoleOwner: WideString;
begin
Result := DefaultInterface.Get_PDCRoleOwner;
end;
function TADSystemInfoProperties.Get_SchemaRoleOwner: WideString;
begin
Result := DefaultInterface.Get_SchemaRoleOwner;
end;
function TADSystemInfoProperties.Get_IsNativeMode: WordBool;
begin
Result := DefaultInterface.Get_IsNativeMode;
end;
{$ENDIF}
class function CoWinNTSystemInfo.Create: IADsWinNTSystemInfo;
begin
Result := CreateComObject(CLASS_WinNTSystemInfo) as IADsWinNTSystemInfo;
end;
class function CoWinNTSystemInfo.CreateRemote(const MachineName: string): IADsWinNTSystemInfo;
begin
Result := CreateRemoteComObject(MachineName, CLASS_WinNTSystemInfo) as IADsWinNTSystemInfo;
end;
procedure TWinNTSystemInfo.InitServerData;
const
CServerData: TServerData = (
ClassID: '{66182EC4-AFD1-11D2-9CB9-0000F87A369E}';
IntfIID: '{6C6D65DC-AFD1-11D2-9CB9-0000F87A369E}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TWinNTSystemInfo.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsWinNTSystemInfo;
end;
end;
procedure TWinNTSystemInfo.ConnectTo(svrIntf: IADsWinNTSystemInfo);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TWinNTSystemInfo.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TWinNTSystemInfo.GetDefaultInterface: IADsWinNTSystemInfo;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TWinNTSystemInfo.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TWinNTSystemInfoProperties.Create(Self);
{$ENDIF}
end;
destructor TWinNTSystemInfo.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TWinNTSystemInfo.GetServerProperties: TWinNTSystemInfoProperties;
begin
Result := FProps;
end;
{$ENDIF}
function TWinNTSystemInfo.Get_UserName: WideString;
begin
Result := DefaultInterface.Get_UserName;
end;
function TWinNTSystemInfo.Get_ComputerName: WideString;
begin
Result := DefaultInterface.Get_ComputerName;
end;
function TWinNTSystemInfo.Get_DomainName: WideString;
begin
Result := DefaultInterface.Get_DomainName;
end;
function TWinNTSystemInfo.Get_PDC: WideString;
begin
Result := DefaultInterface.Get_PDC;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TWinNTSystemInfoProperties.Create(AServer: TWinNTSystemInfo);
begin
inherited Create;
FServer := AServer;
end;
function TWinNTSystemInfoProperties.GetDefaultInterface: IADsWinNTSystemInfo;
begin
Result := FServer.DefaultInterface;
end;
function TWinNTSystemInfoProperties.Get_UserName: WideString;
begin
Result := DefaultInterface.Get_UserName;
end;
function TWinNTSystemInfoProperties.Get_ComputerName: WideString;
begin
Result := DefaultInterface.Get_ComputerName;
end;
function TWinNTSystemInfoProperties.Get_DomainName: WideString;
begin
Result := DefaultInterface.Get_DomainName;
end;
function TWinNTSystemInfoProperties.Get_PDC: WideString;
begin
Result := DefaultInterface.Get_PDC;
end;
{$ENDIF}
class function CoDNWithBinary.Create: IADsDNWithBinary;
begin
Result := CreateComObject(CLASS_DNWithBinary) as IADsDNWithBinary;
end;
class function CoDNWithBinary.CreateRemote(const MachineName: string): IADsDNWithBinary;
begin
Result := CreateRemoteComObject(MachineName, CLASS_DNWithBinary) as IADsDNWithBinary;
end;
procedure TDNWithBinary.InitServerData;
const
CServerData: TServerData = (
ClassID: '{7E99C0A3-F935-11D2-BA96-00C04FB6D0D1}';
IntfIID: '{7E99C0A2-F935-11D2-BA96-00C04FB6D0D1}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TDNWithBinary.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsDNWithBinary;
end;
end;
procedure TDNWithBinary.ConnectTo(svrIntf: IADsDNWithBinary);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TDNWithBinary.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TDNWithBinary.GetDefaultInterface: IADsDNWithBinary;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TDNWithBinary.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TDNWithBinaryProperties.Create(Self);
{$ENDIF}
end;
destructor TDNWithBinary.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TDNWithBinary.GetServerProperties: TDNWithBinaryProperties;
begin
Result := FProps;
end;
{$ENDIF}
function TDNWithBinary.Get_BinaryValue: OleVariant;
begin
Result := DefaultInterface.Get_BinaryValue;
end;
procedure TDNWithBinary.Set_BinaryValue(retval: OleVariant);
begin
DefaultInterface.Set_BinaryValue(retval);
end;
function TDNWithBinary.Get_DNString: WideString;
begin
Result := DefaultInterface.Get_DNString;
end;
procedure TDNWithBinary.Set_DNString(const retval: WideString);
begin
DefaultInterface.Set_DNString(retval);
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TDNWithBinaryProperties.Create(AServer: TDNWithBinary);
begin
inherited Create;
FServer := AServer;
end;
function TDNWithBinaryProperties.GetDefaultInterface: IADsDNWithBinary;
begin
Result := FServer.DefaultInterface;
end;
function TDNWithBinaryProperties.Get_BinaryValue: OleVariant;
begin
Result := DefaultInterface.Get_BinaryValue;
end;
procedure TDNWithBinaryProperties.Set_BinaryValue(retval: OleVariant);
begin
DefaultInterface.Set_BinaryValue(retval);
end;
function TDNWithBinaryProperties.Get_DNString: WideString;
begin
Result := DefaultInterface.Get_DNString;
end;
procedure TDNWithBinaryProperties.Set_DNString(const retval: WideString);
begin
DefaultInterface.Set_DNString(retval);
end;
{$ENDIF}
class function CoDNWithString.Create: IADsDNWithString;
begin
Result := CreateComObject(CLASS_DNWithString) as IADsDNWithString;
end;
class function CoDNWithString.CreateRemote(const MachineName: string): IADsDNWithString;
begin
Result := CreateRemoteComObject(MachineName, CLASS_DNWithString) as IADsDNWithString;
end;
procedure TDNWithString.InitServerData;
const
CServerData: TServerData = (
ClassID: '{334857CC-F934-11D2-BA96-00C04FB6D0D1}';
IntfIID: '{370DF02E-F934-11D2-BA96-00C04FB6D0D1}';
EventIID: '';
LicenseKey: nil;
Version: 500);
begin
ServerData := @CServerData;
end;
procedure TDNWithString.Connect;
var
punk: IUnknown;
begin
if FIntf = nil then
begin
punk := GetServer;
Fintf:= punk as IADsDNWithString;
end;
end;
procedure TDNWithString.ConnectTo(svrIntf: IADsDNWithString);
begin
Disconnect;
FIntf := svrIntf;
end;
procedure TDNWithString.DisConnect;
begin
if Fintf <> nil then
begin
FIntf := nil;
end;
end;
function TDNWithString.GetDefaultInterface: IADsDNWithString;
begin
if FIntf = nil then
Connect;
Assert(FIntf <> nil, 'DefaultInterface is NULL. Component is not connected to Server. You must call ''Connect'' or ''ConnectTo'' before this operation');
Result := FIntf;
end;
constructor TDNWithString.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps := TDNWithStringProperties.Create(Self);
{$ENDIF}
end;
destructor TDNWithString.Destroy;
begin
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
FProps.Free;
{$ENDIF}
inherited Destroy;
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
function TDNWithString.GetServerProperties: TDNWithStringProperties;
begin
Result := FProps;
end;
{$ENDIF}
function TDNWithString.Get_StringValue: WideString;
begin
Result := DefaultInterface.Get_StringValue;
end;
procedure TDNWithString.Set_StringValue(const retval: WideString);
begin
DefaultInterface.Set_StringValue(retval);
end;
function TDNWithString.Get_DNString: WideString;
begin
Result := DefaultInterface.Get_DNString;
end;
procedure TDNWithString.Set_DNString(const retval: WideString);
begin
DefaultInterface.Set_DNString(retval);
end;
{$IFDEF LIVE_SERVER_AT_DESIGN_TIME}
constructor TDNWithStringProperties.Create(AServer: TDNWithString);
begin
inherited Create;
FServer := AServer;
end;
function TDNWithStringProperties.GetDefaultInterface: IADsDNWithString;
begin
Result := FServer.DefaultInterface;
end;
function TDNWithStringProperties.Get_StringValue: WideString;
begin
Result := DefaultInterface.Get_StringValue;
end;
procedure TDNWithStringProperties.Set_StringValue(const retval: WideString);
begin
DefaultInterface.Set_StringValue(retval);
end;
function TDNWithStringProperties.Get_DNString: WideString;
begin
Result := DefaultInterface.Get_DNString;
end;
procedure TDNWithStringProperties.Set_DNString(const retval: WideString);
begin
DefaultInterface.Set_DNString(retval);
end;
{$ENDIF}
procedure Register;
begin
RegisterComponents('ActiveX',[TPropertyEntry, TPropertyValue, TAccessControlEntry, TAccessControlList,
TSecurityDescriptor, TLargeInteger, TNameTranslate, TCaseIgnoreList, TFaxNumber,
TNetAddress, TOctetList, TEmail, TPath, TReplicaPointer,
TAcl, TTimestamp, TPostalAddress, TBackLink, TTypedName,
THold, TPathname, TADSystemInfo, TWinNTSystemInfo, TDNWithBinary,
TDNWithString]);
end;
end.