feat(method): support method in definition

[kdada]

What this PR does / why we need it:

In the past, definition.Function only support functions. With method package in this pr, you can get the power to make a method be like a function.

// Before nirvana server starting
instance := InitSomeClass()
method.Put(instance)

// In definition:
{
    ...
    Function: method.Get(&SomeClass{}, "SomeMethod"),
    ... 
}

Then you don't need to do this:

func (* SomeClass) Definitions()[]definition.Definition {
    return []definition.Definition {
        ...
        Function: this.SomeMethod,
        ... 
    }
}

Which issue(s) this PR is related to (optional, link to 3rd issue(s)):

Fixes #

Reference to #

Special notes for your reviewer:

/cc @ddysher

Release note:

NONE

[ddysher]

@kdada few comments:

• we are constructing a struct instance when registering the function method, what is the implication behind this, i.e.
  • what if user wants to instantiate the struct with field value, e.g. Function: method.Get(&SomeClass{Some: 'abc'}, "SomeMethod"),, is this a valid use case?
  • what happens to the object (&SomeClass{}) after registration?
  • what if user wants to create another instance, do we want them to reuse the object?
• you seems to use MakeFunction to wrap the registered function, what is the performance penalty?

It's common to register multiple methods of a class, in current setup, users are supposed to do this multiple times, each time with a new instance of the object?

{
    ...
    Function: method.Get(&SomeClass{}, "SomeMethod1"),
    Function: method.Get(&SomeClass{}, "SomeMethod2"),
    Function: method.Get(&SomeClass{}, "SomeMethod2"),
    ... 
}

[ddysher]

👆 @kdada can u provide some pprof results (esp. memory for objects)? that will make me feel better ...

[kdada]

@ddysher

The method package provides a pattern to Get and Put instances.

Get returns a lazy loaded function. The function has a certain function prototype and an indefinite execution body. Related instance of the function won't be set until someone calls the function. This mechanism ensure that we can separate API definitions and instances.
The first parameter of Get is only for extracting instance type. So a filled object makes no sense.

Put is simple. The method just put an instance into method container. But for a type, there is only one instance valid. That means if you Put many instances with same type, only the last one is used.

Benchmark:

BenchmarkContainer-8     3000000               406 ns/op
BenchmarkDirect-8       10000000               222 ns/op

Function warp has twice consumption than direct call. But it isn't a big deal. Because the overhead of an entire API request is in microsecond. (PS. I'll write an unsafe calling package to skip the safe check of reflect packge. )

[zjj2wry]

add another struct implement TestInterface，used for test putInterface.

func (t *Test2Struct) Number() int {
	return t.a*2
}

[zjj2wry]

func NewTest(number int) TestInterface{
    return &TestStruct{
                  a: number, 
               }
}

Usually the initialization instance is a factory, and the instance can use the following method?

[zjj2wry]

/lgtm

[kdada]

/approve

[caicloud-bot]

[APPROVALNOTIFIER] This PR is APPROVED

This pull-request has been approved by: kdada, zjj2wry

The full list of commands accepted by this bot can be found here.

The pull request process is described here

Needs approval from an approver in each of these files:

• definition/OWNERS [kdada]

Approvers can indicate their approval by writing /approve in a comment
Approvers can cancel approval by writing /approve cancel in a comment