Let's help each other out
https://www.autohotkey.com/boards/
Code: Select all
class TestClass{
__call(Name)
{
Msgbox % Name
return
}
TestMethod()
{
Msgbox Fail
}
}
Class TestClass2 extends TestClass{
TestMethod2(){
Msgbox Fail
}
}
Test:=new TestClass2()
test.TestMethod()
test.testMethod2()Oh right corrected tested no different result.Also, TestMethod() expects a msg argument, hence, (even if you remove return) it's not getting called.
No __Call is only called if there is no function with that name.
If 1 Msgbox shows a different Text than "Fail" then the behaviour differs from the one discribed in the Help File.
Code: Select all
class TestClass
{
__Call(m, p*) {
MsgBox, Called first even if method exists
}
method() {
MsgBox, Hello World
}
}
tc := new TestClass
tc.method()
returnahkHelp wrote:Meta-functions are methods defined by an object's base which can define exactly how the object should act when an unknown key is requested. For example, if obj.key has not been assigned a value, it invokes the __Get meta-function. Similarly, obj.key := value invokes __Set and obj.key() invokes __Call.
Code: Select all
class TestClass
{
__Call(m, p*) {
MsgBox, Called first even if method exists
}
method() {
MsgBox, Hello
}
}
tc := new TestClass
tc.method() ; derived object calls method
TestClass.method() ; base object calls methodCode: Select all
class TestClass{
__call(Name)
{
Msgbox % Name
return
}
TestMethod()
{
Msgbox Fail
}
}
Class TestClass2 extends TestClass{
TestMethod2(){
Msgbox Fail
}
}
Test:=new TestClass2()
test.TestMethod()
test.testMethod2()Code: Select all
class TestClass{
__call(Name)
{
Msgbox % Name
; return
}
TestMethod()
{
Msgbox Fail
}
}
Class TestClass2 extends TestClass{
TestMethod2(){
Msgbox Fail
}
}
Test:=new TestClass2()
test.TestMethod()
test.testMethod2()Testclass doesn't have a base.Meta-functions are methods defined by an object's base which can define exactly how the object should act when an unknown key is requested. For example, if obj.key has not been assigned a value, it invokes the __Get meta-function. Similarly, obj.key := value invokes __Set and obj.key() invokes __Call.
In these cases, the base object is invoked as follows:
- If this base object defines the appropriate meta-function, call it. If the meta-function explicitly returns, the return value is used as the result of the operation and no further processing occurs.
Set: If the operation was successful, __Set should return the new value of the field, which may differ from the original r-value. This allows assignments to be chained, as in a.x := b.y := z. An empty string should be returned if the assignment failed, allowing the script to detect the error.- If this is a get or call operation, search for a matching key in the base object's own fields.
Get: If found, the value of that field is returned.
Call: If found, the function stored in the field (by name or reference) is called, passing the original target object as the this parameter.- Recursively invoke its own base object. This allows properties of an object to be "inherited" from its base, its base's base and so on.
Code: Select all
class TestClass{
__call(Name) ;obsolete in the example
{
Msgbox % Name
return
}
TestMethod()
{
Msgbox Fail
}
}
Class TestClass2 extends TestClass{
__call(Name)
{
Msgbox % Name
return
}
TestMethod2(){
Msgbox Fail
}
}
Test:=new TestClass2()
test.TestMethod()
test.testMethod2()
Code: Select all
class TestClass
{
__call(MethodCall)
{
Msgbox,% MethodCall ".__call 1"
}
TestMethod(ClassName)
{
Msgbox,% ClassName ".Method 1"
}
}
Class TestClass2 extends TestClass
{
__call(MethodCall)
{
Msgbox,% MethodCall ".__call 2"
}
TestMethod2(ClassName)
{
Msgbox,% ClassName ".Method 2"
}
}
TestClass:=new TestClass()
TestClass2:=new TestClass2()
TestClass.TestMethod("TestClass")
Pause
TestClass.TestMethod2("TestClass")
Pause
TestClass2.TestMethod("TestClass2")
Pause
TestClass2.TestMethod2("TestClass2")
Pause
F1::pauseDo you mean in the class itself?the prior base does not get called UNLESS the method does not exist in the extended class
Code: Select all
class MainClass {
__call(MethodCall){
Msgbox,% MethodCall "`n__call MainClass"
}
MainCall(param){
Msgbox,% "MainCall`nparam: " param
}
}
class TestClass extends MainClass{
__call(MethodCall){
Msgbox,% MethodCall "`n__call TestClass"
}
}
Class TestClass2 extends TestClass{
__call(MethodCall){
Msgbox,% MethodCall "`n__call TestClass2"
}
}
TestClass2:=new TestClass2()
TestClass2.MainCall("test","param")
Code: Select all
class MainClass {
static MainCall:="MyFunc"
__call(MethodCall){
Msgbox,% MethodCall "`n__call MainClass"
}
}
class TestClass extends MainClass{
__call(MethodCall){
Msgbox,% MethodCall "`n__call TestClass"
}
}
Class TestClass2 extends TestClass{
__call(MethodCall){
Msgbox,% MethodCall "`n__call TestClass2"
}
}
MyFunc(p*){
MsgBox Function %A_ThisFunc% called
}
TestClass2:=new TestClass2()
TestClass2.MainCall("test","param")Sorry for the long delay.So... why Wish List? It's no more a wish/feature/change request than it is a bug report.