How to make in Object Pascal “class of interface” (or “interface of interface”) type?

I think what you are looking for is this: procedure Dummy; var Intf : ISomeInterface; begin if Assigned(gHardCodedPointer) and Supports(gHardCodedPointer,ISomeInterface,Intf) then Intf. SomeMethod end If it's not, I have no clue about what you are trying to achieve there.

I think what you are looking for is this: procedure Dummy; var Intf : ISomeInterface; begin if Assigned(gHardCodedPointer) and Supports(gHardCodedPointer,ISomeInterface,Intf) then Intf. SomeMethod end; If it's not, I have no clue about what you are trying to achieve there...

1. I think "SomeOne" was looking for a way to enforce at compile time that the class implements the given interface, but that's not possible. It needs to be checked at run time, and using Supports is indeed the way to do it.

– Rob Kennedy Aug 17 '10 at 14:45 After taking a 2nd look at his post, what he might be looking for is a way to call a method by name (Like through RTTI). A RTTI solution might be closer to what he needs than an Interface solution. – Ken Bourassa Aug 17 '10 at 17:02.

But, assuming there is a good reason for that, this might help. As you have found out, you can't do class of on an interface. What's more you can't use a variable value to cast anything to anything else.

Casting is hardwired telling the compiler that you know the reference you are casting is of a specific type. Trying to do that with a var such as your ASomeClassToWorkWith parameter is going to produce errors as it goes against the very nature of casting. Code below is not something I'd recommend, but it compiles and I think it does what you want.

What it does is use a "dummy" ancestor and employs polymorfism to get the compiler to call the method on the correct type. If you do not mark SomeMethod as virtual, you will get the dummy ancestor's message on both button clicks. The Instance function in the interface is there to show you a means of getting to the implementing instance of an interface without using RTTI.

Just be aware of the caveat of this when using interface delegation: you may not get the instance you are expecting. Type TForm1 = class(TForm) TSomethingBtn: TButton; TMyClassBtn: TButton; procedure FormCreate(Sender: TObject); procedure TSomethingBtnClick(Sender: TObject); procedure TMyClassBtnClick(Sender: TObject); private { Private declarations } FSomething: TObject; FMyClass: TObject; public { Public declarations } end; var Form1: TForm1; implementation {$R *. Dfm} type TSomething = class; // forward; TSomethingClass = class of TSomething; ISomeInterface = interface procedure SomeMethod; function Instance: TSomething; end; TSomething = class(TInterfacedObject, ISomeInterface) procedure SomeMethod; virtual; function Instance: TSomething; end; var gHardCodedPointer: Pointer; // no matter procedure Dummy(aSomething: TSomething); begin // actually, type of ASomeClassToWorkWith is unknown (at least TObject), but it // must implement SomeMethod, so I can make something like this: aSomething.

SomeMethod; end; type TMyClass = class(TInterfacedObject, ISomeInterface) procedure SomeMethod; virtual; function Instance: TSomething; end; procedure TForm1. FormCreate(Sender: TObject); begin FSomething := TSomething. Create; FMyClass := TMyClass.

Create; end; { TMyClass } function TMyClass. Instance: TSomething; begin Result := TSomething(Self); end; procedure TMyClass. SomeMethod; begin ShowMessage('This comes from TMyClass'); end; { TSomething } function TSomething.

Instance: TSomething; begin Result := Self; end; procedure TSomething. SomeMethod; begin ShowMessage('This comes from the "dummy" ancestor TSomething'); end; procedure TForm1. TMyClassBtnClick(Sender: TObject); begin // Presume this has been set elsewhere gHardCodedPointer := FMyClass; Dummy(TSomething(gHardCodedPointer)); end; procedure TForm1.

TSomethingBtnClick(Sender: TObject); begin // Presume this has been set elsewhere gHardCodedPointer := FSomething; Dummy(TSomething(gHardCodedPointer)); end.

Even if you could, you couldn't typecast the interface with a interface-var anyway. Same as with classes when you typecast a pointer to a metaclass, you'll get something of type metaclass (class of), not something of the type that is in metaclass. With classes you solve this by typecast to the lowest common class in the hierachy.

You can do the same with interfaces. ... If they inherit from eachother.

I think you have to use the interface, not the class: procedure Dummy(ASomeClassToWorkWith: ISomeInterface); begin // actually, type of ASomeClassToWorkWith is unknown (at least TObject), but it // must implement SomeMethod, so I can make something like this: ASomeClassToWorkWith. SomeMethod; end; You just have to think amout reference counting If you realy want the object instance you could change the interface like this: type ISomeInterface = interface procedure SomeMethod; function ImplementedInObject: TObject; end; procedure Dummy(ASomeInterfaceToWorkWith: ISomeInterface); var ASomeObjectToWorkWith: TObject; begin ASomeInterfaceToWorkWith. SomeMethod; ASomeObjectToWorkWith := ASomeInterfaceToWorkWith.

ImplementedInObject; // Do what is needed with object end; ... type TMyClass = class(TInterfacedObject, ISomeInterface) function ImplementedInObject: TObject; end; function TMyClass. ImplementedInObject: TObject; begin Result := Self; end.

No, in that case I must pass to Dummy an object reference (but I need a class of this object). – SomeOne Aug 17 '10 at 7:26 Added example for returning the Object implementing the interface.(if you only need the class then change then returntype from TObject to TClass) – BennyBechDk Aug 17 '10 at 12:13.

It seems I see what you want to do. You just have to use what MS and partners implemented in the core of interfaces, use guids. Below is the example, but you should definitely use your own guid with CTRL+SHIFT+G in IDE ... type ITestInterface = interface '{2EA2580F-E5E5-4F3D-AF90-2BBCD65B917B}' procedure DoSomething; end; TTestObject = class(TInterfacedObject, ITestInterface) procedure DoSomething; end; TTestObject2 = class(TInterfacedObject, ITestInterface) procedure DoSomething; end; ... procedure TestMethod(Obj: TInterfacedObject); var Intf: ITestInterface; begin if (Obj as IUnknown).

QueryInterface(ITestInterface, Intf) = S_OK then Intf. DoSomething; end; { TTestObject } procedure TTestObject. DoSomething; begin MessageDlg('This is TTestObject showing something', mtInformation, mbOk, 0) end; { TTestObject2 } procedure TTestObject2.

DoSomething; begin MessageDlg('This is TTestObject2 showing something', mtInformation, mbOk, 0) end; procedure TForm2. Button1Click(Sender: TObject); var Obj1, Obj2: TInterfacedObject; begin Obj1:=TTestObject. Create; Obj2:=TTestObject2.

Create; TestMethod(Obj1); TestMethod(Obj2); end.

The difference when calling code via interface variable or via variable pointing to an instance of a class that implements methods of the same interface is that different virtual method tables (VMT) are used, i.e. In a VMTs of an interface there will be only interface methods (plus AddRef, Release and QI, of course), in a VMT of a class there will be all virtual methods of that class. That means that your code ASomeClassToWorkWith(gHardCodedPointer).

SomeMethod; will be compiled to call TSomeClassWhichImplementsSomeInterface. SomeMethod directly instead of virtual method in VMT of ISomeInterface through interface pointer. Even more, since interfaces cannot declare class methods and class attributes, an interface type is not a object (while class is an object), therefore "class of interface" does not make any sence.

You can add intermediate abstract class and declare you "class of interface" as class of the intermediate class: type TInterfacedObjectWithISomeInterface = class(TInterfacedObject, ISomeInterface) procedure SomeMethod; virtual; abstract; end; TSomeClassWhichImplementsSomeInterface = class of TInterfacedObjectWithISomeInterface; procedure Dummy(ASomeClassToWorkWith: TSomeClassWhichImplementsSomeInterface); ... type TMyClass = class(TInterfacedObjectWithISomeInterface) procedure SomeMethod; override; end.

You can declare metaclasses, but you cannot define them in terms of what interfaces the base class implements. Interface implementation can only be checked at run time. You can pass your Dummy function a metaclass, but you cannot use that metaclass to type-cast your plain pointer to a more specific type.

Type-casting is a compile-time operation, but the actual value of the metaclass parameter isn't known until run time. The best you can do is type-cast it to the metaclass's base class. Then you can call all the methods that are defined in that base class.

But it seems you don't actually care what the base class is, as long as the class implements your interface. In that case, you can ignore the metaclass parameter. Type-cast your pointer to be a TObject (or, better yet, declare gHardCodedPointer to be a TObject in the first place), and then use the Supports function to get the interface reference.

Var SupportsInterface: Boolean; Some: ISomeInterface; begin SupportsInterface := Supports(TObject(gHardCodedPointer), ISomeInterface, Some); Assert(SupportsInterface, 'Programmer stored bad class instance in gHardCodedPointer'); Some. SomeMethod; end; If you really care about the metaclass parameter, you can add some enforcement for it, too. You can check whether the given class implements your interface, and you can check whether the object in gHardCodedPointer is an instance of that class: Assert(ASomeClassToWorkWith.

GetInterfaceEntry(ISomeInterface) nil); Assert(TObject(gHardCodedPointer). InheritsFrom(ASomeClassToWorkWith)); But notice that you don't need to check either of those results to be able to call SomeMethod on gHardCodedPointer. They don't really matter.By the way, the only hard-coded pointer value you can hope to have in Delphi is nil.

All other pointer values are addresses that are very hard to predict at compile time because the compiler, the linker, and the loader all determine where everything really goes in memory. I suggest you come up with some other name for that variable that more accurately describes what it really holds.

I cant really gove you an answer,but what I can give you is a way to a solution, that is you have to find the anglde that you relate to or peaks your interest. A good paper is one that people get drawn into because it reaches them ln some way.As for me WW11 to me, I think of the holocaust and the effect it had on the survivors, their families and those who stood by and did nothing until it was too late.