Respond to an unknown method call: Difference between revisions

{{task|Object oriented}}

 

This task is intended only for object systems that use a dynamic dispatch mechanism without static checking.

 

 

=={{header|Brat}}==

 

example.no_method = { meth_name, *args |

}

 

 

=={{header|C sharp|C#}}==

{{works with|C sharp|4.0}}

 

using System.Dynamic;

 

ex.Bar();

}

 

=={{header|C++}}==

To avoid the pure virtual call, we can put some default function implementation into the abstract class which handles the situation (e.g. throws a custom exception or whatnot).

 

public:

virtual void bark() // concrete virtual, not pure

e.bark(); // throws exception

}

 

=={{header|Common Lisp}}==

In Common Lisp, if a generic function is invoked on arguments for which there is no applicable specialized method, the method <code>no-applicable-method</code> is called with the generic function and the arguments.

 

(:documentation "Do something to thing."))

 

 

(defmethod do-something ((thing (eql 3)))

 

 

 

=={{header|D}}==

 

foreach (arg; args)

write(arg, " ");

 

void main() {

 

=={{header|E}}==

Practically, the object definition syntax provides a ''matcher'' clause to handle unrecognized messages. This example has the same behavior as the Python example.

 

to foo() { println("this is foo") }

to bar() { println("this is bar") }

}

}

 

=={{header|Fancy}}==

class CatchThemAll {

def foo {

a we_can_do_it

a they_can_too: "eat" and: "walk"

 

=={{header|Fantom}}==

In Fantom, you can call methods statically or dynamically. Static calls to methods will be checked at compile time. Dynamic method calls (indicated by an <code>instance->method</code> syntax) are run through a "[http://fantom.org/doc/sys/Obj.html#trap trap]" method at run time. This method looks up the given method name, and throws an exception if the method/field is not known. This exception can be caught, and processed specially:

 

class A

{

}

}

 

Output:

</pre>

 

==Icon and {{header|Unicon}}==

 

 

The example below is based upon the last case. The procedure 'DynMethod' would be used in place of normal method invocation. A special method 'UndefinedMethod' can be defined to handle unknown methods. The procedure 'DynMethod' requires knowledge of the internals of the code emitted to support objects.

 

 

if not (type(obj) ? ( tab(find("__")), ="__state", pos(0))) then

runerr(205,obj) # invalid value - not an object

 

if meth == ("initially"|"UndefinedMethod") then fail # avoid protected

 

if fieldnames(m) == meth then # method exists?

return m[meth]!push(copy(arglist),obj) # ... call it

return obj.UndefinedMethod!arglist # ... call it

else runerr(207,obj) # error invalid method (i.e. field)

 

x := foo()

y := foo2()

return

end

 

 

=={{header|J}}==

 

For example, we could define

doSomething_z_=: assert&0 bind 'doSomething was not implemented'

doSomething__y ''

 

doSomething_adhoc1_=: smoutput bind 'hello world'

 

With those definitions in a fresh session (where <code>adhoc2</code> has not been given a definition for <code>doSomething</code>), we get the following behavior:

 

hello world

example<'adhoc2'

 

=={{header|JavaScript}}==

{{works with|Firefox}}

example.foo = function () {

alert("this is foo");

example.grill(); // alerts "tried to handle unknown method grill"

example.ding("dong"); // alerts "tried to handle unknown method ding"

 

=={{header|Lua}}==

This is specifically the purpose of the __index metamethod:

 

local object={print=print}

setmetatable(object,{__index=function(t,k)return function() print("You called the method",k)end end})

object.print("Hi") -->Hi

object.hello() -->You called the method hello

 

=={{header|Objective-C}}==

<code>-forwardInvocation:</code> is usually used to "forward" the message on to another object to handle.

 

 

// The methods need to be declared somewhere

- (void)grill;

- (void)ding:(NSString *)s;

@end

 

- (void)foo;

- (void)bar;

NSLog(@"this is foo");

}

- (void)bar {

NSLog(@"this is bar");

}

- (void)forwardInvocation:(NSInvocation *)inv {

NSLog(@"tried to handle unknown method %@", NSStringFromSelector([inv selector]));

[inv getArgument:&arg atIndex:i+2];

}

}

// forwardInvocation: does not work without methodSignatureForSelector:

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {

int numArgs = [[NSStringFromSelector(aSelector) componentsSeparatedByString:@":"] count] - 1;

int main()

{

 

 

 

return 0;

 

=={{header|Oz}}==

To respond to unknown method calls, classes can implement the <code>otherwise</code> method. As its sole argument, this method gets the received message, i.e. a record with the name of the unknown method as its label and the arguments as the record features.

class Example

meth init skip end

{Object bar}

{Object grill}

 

Output:

 

=={{header|Perl}}==

sub new {

bless {}

$example->grill; # prints "tried to handle unknown method Example::grill"

$example->ding("dong"); # prints "tried to handle unknown method Example::ding"

 

=={{header|PHP}}==

class Example {

function foo() {

$example->ding("dong"); // prints "tried to handle unknown method ding"

// prints "it had arguments: dong

 

=={{header|PicoLisp}}==

 

=={{header|Python}}==

Python objects can implement a <code>__getattr__()</code> method to handle accesses of unknown attributes (methods are just attributes that are callable; so this function handles both methods and non-method fields). Here we assume that if you access an unknown attribute, you want a method, so we return a function that can be called.

def foo(self):

def bar(self):

def __getattr__(self, name):

def method(*args):

if args:

return method

 

example.grill() # prints “tried to handle unknown method grill”

example.ding("dong") # prints “tried to handle unknown method ding”

 

=={{header|Ruby}}==

def foo

puts "this is foo"

example.grill # prints “tried to handle unknown method grill”

example.ding("dong") # prints “tried to handle unknown method ding”

 

=={{header|Scala}}==

{{works with|Scala|2.9}}

As of scala 2.9, scalac must receive the -Xexperimental optional for Dynamic to receive this treatment.

{

def foo()=println("this is foo")

}

}

Output:

<pre>this is foo

tried to handle unknown method ding

it had arguments: dong</pre>

 

=={{header|Slate}}==

Here is an example of unknown methods being used to call shell commands (this is already defined in the base image):

 

 

_@shell didNotUnderstand: message at: position

ifFalse: [args do: [| :arg | command ; ' ' ; arg]]]]] writingAs: String)

ifNil: [resend] ifNotNilDo: [| :cmd | [Platform run: cmd]]]

 

Here is an example of it being used:

 

kernel.new.little.64.1244260494374694.image slate2.image

net.image slate.image

True

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

 

foo [ 'foo received' displayNl ]

bar [ 'bar received' displayNl ]

doesNotUnderstand: aMessage [

('message "' , (aMessage selector asString) , '"') displayNl.

a bar.

a weCanDoIt.

 

=={{header|Tcl}}==

{{works with|Tcl|8.6}} or {{libheader|TclOO}}

# First create a simple, conventional class and object

oo::class create Example {

example grill; # prints “tried to handle unknown method "grill"”

example ding dong; # prints “tried to handle unknown method "ding"”

 

{{omit from|Ada}}

{{omit from|AutoHotkey}}

{{omit from|AWK}}

{{omit from|C}} <!-- static compiled, no runtime function creation -->

{{omit from|C++}}

{{omit from|Java}}

{{omit from|Locomotive Basic}}

{{omit from|M4}}

{{omit from|OCaml}}

{{omit from|PARI/GP}}

{{omit from|PowerShell}}

{{omit from|PureBasic}}

{{omit from|Retro}}

{{omit from|TI-89 BASIC}} <!-- No objects -->

{{omit from|ZX Spectrum Basic}}