Block (delegate) not understood

Elements Oxygene
1

I try to bring a piece of code from Delph toi Oxygene but I do not understand this error.
(E197) No method “IAttachmentImpl_addRefDispatcher” with matching delegate signature “(IReferenceCounted)” could be found in type “__Global”

Why? :slight_smile:

namespace testNetExternalEngine;

interface

type
	IReferenceCounted_addRefPtr = procedure(this: IReferenceCounted); 
	IReferenceCounted_releasePtr = function(this: IReferenceCounted): Integer; 
	IDisposable_disposePtr = procedure(this: IDisposable);
	IEvents_cancelPtr = procedure(this: IEvents);
 	IEventsImpl_addRefDispatcher = method(this: IEvents);

	VersionedVTable = class
		version: NativeInt;
	end;

	IVersioned = public class
		vTable: VersionedVTable;
		const VERSION = 0;
	end;

	IVersionedImpl = class(IVersioned)
		constructor create;
	end;

	IEvents = class(IReferenceCounted)
		const VERSION = 3;
	end;

	IEventsImpl = abstract class(IEvents)
		constructor create;
		method addRef(); virtual; abstract;
		method release(): Integer;  virtual; abstract;
	end;

    IReferenceCounted = class(IVersioned)
		const VERSION = 2;
		method addRef();
		method release(): Integer;
	end;

	IReferenceCountedImpl = abstract class(IReferenceCounted)
		constructor create;
		method addRef(); virtual; abstract;
		method release(): Integer; virtual; abstract; 
	end;

    IDisposable = class(IVersioned)
		const VERSION = 1;
		method dispose();
	end;

	ReferenceCountedVTable = class(VersionedVTable)
		addRef:  IReferenceCounted_addRefPtr;
		release: IReferenceCounted_releasePtr;
	end;

    EventsVTable = class(ReferenceCountedVTable)
		cancel: IEvents_cancelPtr;
	end;

	DisposableVTable = class(VersionedVTable)
		dispose: IDisposable_disposePtr;
	end;

implementation

constructor IVersionedImpl.create;
var	IVersionedImpl_vTable: VersionedVTable;
begin
	IVersionedImpl_vTable := VersionedVTable.create;
	IVersionedImpl_vTable.version := 0;
	vTable := IVersionedImpl_vTable;
end;

constructor IEventsImpl.create;
var	IEventsImpl_vTable: EventsVTable;
begin
	IEventsImpl_vTable := EventsVTable.create;
	IEventsImpl_vTable.version := 3;
	IEventsImpl_vTable.addRef := @IEventsImpl_addRefDispatcher;  <- error
	IEventsImpl_vTable.cancel := @IEventsImpl_cancelDispatcher;
	vTable := IEventsImpl_vTable;
end;

method IEventsImpl_addRefDispatcher(this: IEvents); 
begin
		IEventsImpl(this).addRef();
end;

method IEventsImpl_releaseDispatcher(this: IEvents): Integer; 
begin
		Result := IEventsImpl(this).release();
end;

method IEventsImpl_cancelDispatcher(this: IEvents); 
begin
	//	IEventsImpl(this).cancel();
end;

method IDisposable.dispose();
begin
	DisposableVTable(vTable).dispose(Self);
end;

method IReferenceCounted.addRef();
begin
	ReferenceCountedVTable(vTable).addRef(Self);
end;

method IReferenceCounted.release(): Integer;
begin
	Result := ReferenceCountedVTable(vTable).release(Self);
end;

constructor IReferenceCountedImpl.create;
var IReferenceCountedImpl_vTable: ReferenceCountedVTable;
begin
	IReferenceCountedImpl_vTable := ReferenceCountedVTable.create;
	IReferenceCountedImpl_vTable.version := 2;
	vTable := IReferenceCountedImpl_vTable;
end;

end.
2

Doesn’t look like those types match? addref wants a procedure(this: IReferenceCounted), not procedure(this: IEvents)

3

you are right, unfortunately it’s a copy / pasted from a source that compiles in Delphi FPC fashion

Souce FPC Delphi mode

4

Unfortunately Elements can’t accept mismatches in this regard. You can however change the sig & cast inside it.