unknown call_other(object ob, string fun, mixed arg, ...)
unknown call_other(object *ob, string fun, mixed arg, ...)
ob->fun (mixed arg, ...)
ob->"fun" (mixed arg, ...)
ob->(fun) (mixed arg, ...)
Call a member function <fun> in another object <ob> with an
the argument(s) <arg...>. Result is the value returned from
the called function (or 0 for non-existing or void functions).
Additionally the efun accepts an array of objects as <ob>: the
function is called with the same arguments in all the given objects.
The single results are collected in an array and yield the final
result. Array elements can be objects or the names of existing
objects; destructed objects and 0s will yield a '0' as result, but
don't cause an error.
The object(s) can be given directly or via a string (i.e. its
object_name). If it is given by a string and the object does not
exist yet, it will be loaded.
ob->fun(args) and "ob_name"->fun(args) is equivalent to
call_other(ob, "fun", args). Nowadays the ob_name string can
also be a variable.
ob->fun(args) and ob->"fun"(args) are equivalent to
call_other(ob, "fun", args). ob->(fun)(args) are equivalent
to call_other(ob, fun, args) where fun is a runtime expression
returning the function name.
If ob::fun does not define a publicly accessible function, the
efun will call the H_DEFAULT_METHOD hook if set. If the hook
is not set or can't resolve the call either, call_other()
will return 0, which is indistinguishable from a function returning 0.
Calls to the master object never use the H_DEFAULT_METHOD hook.
To force non-default calls, the efun call_direct() can be used.
"publicly accessible" means "public" when calling other objects,
and "public" or "static" when calling this_object(). "private"
and "protected" function can never be called with call_other().
The return type of call_other() is 'any' be default. However,
if your LPC code uses #pragma strict_types, the return type is
'unknown', and the result of call_other() must be casted to
the appropriate type before you can use it for anything.
// All the following statements call the lfun QueryProp()
// in the current player with the argument P_SHORT.
string str, fun;
str = (string)call_other(this_player(), "QueryProp", P_SHORT);
fun = "QueryProp";
str = (string)call_other(this_player(), fun, P_SHORT);
str = (string)this_player()->QueryProp(P_SHORT);
str = (string)this_player()->"QueryProp"(P_SHORT);
fun = "QueryProp";
str = (string)this_player()->(fun)(P_SHORT);
You have to do explicit type casting because of the unknown
return type, if you have set #pragma strict_types.
// This statement calls the lfun short() in all interactive users
// and stores the collected results in a variable.
s = (string *)users()->short();
!Compat: call_other("/users/luser/thing", "???", 0);
Compat: call_other("users/luser/thing", "???", 0);
This looks a bit weird but it was used very often to just load
the object by calling a not existing function like "???".
Fortunately nowadays there is an efun load_object() for this
In LDMud 3.2.8 the following improvements were made:
- the forms x->"y"() and x->(y)() are recognized;
- the form x->y() no longer clashes with a local variable also
- a simul_efun call_other() also catches ->() calls.
- call_other can be applied on arrays of objects.
LDMud 3.2.10 made the call on arrays of objects configurable.
LDMud 3.3.113 introduced the H_DEFAULT_METHOD hook.
LDMud 3.5.0 made the call on arrays of objects non-optional.
call_direct(E), call_strict(E), call_direct_strict(E),
call_resolved(E), call_direct_resolved(E), create(A), pragma(LPC),
extern_call(E), function_exists(E), functions(LPC), map_objects(E)