Usage

//lets create an rpc endpoint/server named missionControl and expose 2 functions called nasa and isro.

try {
    const missionControl = dbridge.rpc.init('missionControl');
} catch (err) {
    console.log(err.source, err.code, err.message);
}

# lets create an rpc endpoint/server named missionControl and expose 2 functions called nasa and isro.
try:
     missionControl = dbridge.rpc.init('missionControl')
except dBError as e:
     print(e.code, e.source, e.message) 

//lets create an rpc endpoint/server named missionControl and expose 2 functions called nasa and isro.
using dBridges.remoteprocedure; 

try {
    Crpcserver missionControl = dbridge.rpc.init('missionControl');
} catch (dBError err) {
    Console.WriteLine("{0} ,  {1} , {2}" , err.source, err.code, err.message);
}

// function is exposed outside the property callback function, but in the scope of application.
function rpcFuncOustide (payload, response) {
    try {
        response.tracker = true;
        response.next('This is Houston');
        response.end('message received by Houston');
        response.exception('INVALID_PARAM', 'Wrong parameter'); 
    } catch(err) {
        console.log(err.source, err.code, err.message);
    }
}

missionControl.functions = function () {
    // function is exposed inside the property callback function.
    function rpcFuncInside (payload, response) {
        try {
            response.tracker = true;
            response.next('This is Hassan');
            response.end('message received by Hassan');
            response.exception('INVALID_PARAM', 'Wrong parameter'); 
            console.log(response.id);
        } catch(err) {
            console.log(err.source, err.code, err.message);
        }
    }
    // registering function to be exposed by rpcServer
    try {
        missionControl.regfn("nasa", rpcFuncOustide);
        missionControl.regfn("isro", rpcFuncInside);
    } catch(err) {
        console.log(err.source, err.code, err.message);
    }
}

// unregistering of function exposed by rpcServer
missionControl.unregfn("nasa", rpcFuncOustide);

# function is exposed outside the property callback function, but in the scope of application.
async def rpcFunOutside(inparameter, response):
  try:
    response.tracker = True
    print("iparameter = " , inparameter.inparama)
    print("extra info  = " , inparameter.sysinfo)
    response.next('This is Houston')
    response.end('message received by Houston')
    response.exception('INVALID_PARAM', 'Wrong parameter') 
except dBError as e:
    print(e.code, e.source, e.message) 

# function is exposed inside the property callback function.
async def rpcFunctionBinder():
    # function is exposed inside the property callback function, but in the scope of application.
    async def rpcFunInside(inparameter, response):
        response.tracker = True
        try:
          response.tracker = True
          print("iparameter = " , inparameter.inparama)
          print("extra info  = " , inparameter.sysinfo)
          response.next('This is Hassan')
          response.end('message received by Hassan')
          response.exception('INVALID_PARAM', 'Wrong parameter') 
        except dBError as e:
          print(e.code, e.source, e.message) 

   try:
      #// registering function to be exposed by rpcServer
      missionControl.regfn("nasa", rpcFunInside)
      missionControl.regfn("isro", rpcFunOutside)
   except dBError as e:
      print(e.code, e.source, e.message) 

missionControl.functions = rpcFunctionBinder
# unbinding of function exposed by rpc functions
missionControl.unregfn("rpcFunOutside", ifunctionoutside)

// function is exposed outside the property callback function, but in the scope of application.
using dBridges.responseHandler;
using dBridges.Utils;
async void rpcProcOutside(object inparam, object response)
{
    try {
        dBParams parameter = inparam as dBridges.Utils.dBParams;
        Console.WriteLine("iparameter = {0}" , parameter.inparama);
        Console.WriteLine("extra info  = {0}" , parameter.sysinfo);

        CResponseHandler responsehandler = response as CResponseHandler;
        responsehandler.tracker = true;
        responsehandler.next('This is Houston');
        responsehandler.end('message received by Houston');
        responsehandler.exception('INVALID_PARAM', 'Wrong parameter'); 
    } catch (dBError err) {
        Console.WriteLine("{0} ,  {1} , {2}" , err.source, err.code, err.message);
    }
}

// function is exposed inside the property callback function.
async void RpcFunctionBinder(object sender)
{
    try{
        //sender is same as rpcSvrObject 
        // function is exposed outside the property callback function, but in the scope of application.
       Action<object , object> ifunctionoutside = rpcProcOutside;

        // registering function to be exposed by rpcServer
       missionControl.regfn("nasa", ifunctionoutside);

        // registering function to be exposed by rpcServer
        Action<object , object> ifunctioninside;
        missionControl.regfn("isro", ifunctioninside = (object inparam, object response) =>{
        // function is exposed inside the property callback function, but in the scope of application.
             try {
                dBParams parameter = inparam as dBridges.Utils.dBParams;
                Console.WriteLine("iparameter = {0}" , parameter.inparama);
                Console.WriteLine("extra info  = {0}" , parameter.sysinfo);

                CResponseHandler responsehandler = response as CResponseHandler;
                responsehandler.tracker = true;
                responsehandler.next('This is Houston');
                responsehandler.end('message received by Houston');
                responsehandler.exception('INVALID_PARAM', 'Wrong parameter'); 
            } catch (dBError err) {
            Console.WriteLine("{0} ,  {1} , {2}" , err.source, err.code, err.message);
            }       
        });

    } catch (dBError err) {
        Console.WriteLine("{0} ,  {1} , {2}" , err.source, err.code, err.message);
    }
}

Action<object> irpcFunctions = RpcFunctionBinder;
missionControl.functions = irpcFunctions; 

// unregistering of function exposed by rpcServer
missionControl.unregfn("rpcProcOutside", ifunctionoutside);

try {
    missionControl.register();
} catch (err) {
    console.log(err.source, err.code, err.message);
}

// Best practice is to check the channel is online before publishing any message.
if (dbridge.connectionstate.isconnected()) {
    try {
        missionControl.register();
    } catch (err) {
        console.log(err.source, err.code, err.message);
    }
}

try:
    missionControl.register()
except dBError as e:
    print(e.code, e.source, e.message)

# Best practice is to check the channel is online before publishing any message.
if dbridge.connectionstate.isconnected():
    try:
        missionControl.register()
    except dBError as e:
        print(e.code, e.source, e.message)

try {
    missionControl.register();
} catch (dBError err) {
    Console.WriteLine("{0} ,  {1} , {2}" , err.source, err.code, err.message);
}

// Best practice is to check the channel is online before publishing any message.
if (dbridge.connectionstate.isconnected()) {
    try {
        missionControl.register();
    } catch (dBError err) {
        Console.WriteLine("{0} ,  {1} , {2}" , err.source, err.code, err.message);
    }    
}

missionControl.unregister();

missionControl.unregister()

missionControl.unregister();

try {
    missionControl.resetqueue();
} catch(err) {
    console.log(err.source, err.code, err.message);
}

try:
    await missionControl.resetqueue();
except dBError as e:
    print(e.code, e.source, e.message)

try {
    missionControl.resetqueue();
} catch (dBError err) {
    Console.WriteLine("{0} ,  {1} , {2}" , err.source, err.code, err.message);
}

//  Binding to systemevents on rpcObject  
try {
    missionControl.bind('eventName',  (payload, metadata) => {
        console.log(payload, metadata);
    });
} catch(err){
     console.log(err.source, err.code, err.message);
}

// Binding to systemevents on dbridgeObject 
try {
    dbridge.rpc.bind('eventName', (payload, metadata) => {
        console.log(payload, metadata);
    });
} catch(err){
     console.log(err.source, err.code, err.message);
}

#  Binding to systemevents on rpcObject  
async def eventCallback(payload , metadata):
    print(payload , metadata)
try:
    rpcSvrObject.bind('eventName', eventCallback)
except dBError as e:
    print(e.code, e.source, e.message) 

# Binding to systemevents on dbridgeObject 
try:
    dbridge.rpc.bind('eventName',  eventCallback)
except dBError as e:
    print(e.code, e.source, e.message)

//  Binding to systemevents on rpcObject  
try {
    Action<object , object> ievent;
    rpcSvrObject.bind("eventName", ievent = (object inparam, object metadata) =>{
        Console.WriteLine("{0} ,  {1}" , inparam ,  metadata);
    });
} catch (dBError err) {
    Console.WriteLine("{0} ,  {1} , {2}" , err.source, err.code, err.message);
}

// Binding to systemevents on dbridgeObject 
try {
    Action<object , object> ievent;
    dbridge.rpc.bind("eventName",  ievent = (object inparam, object metadata) =>{
        Console.WriteLine("{0} ,  {1}" , inparam ,  metadata);
    });
} catch (dBError err) {
    Console.WriteLine("{0} ,  {1} , {2}" , err.source, err.code, err.message);
}

//  Binding to all rpc events on rpcObject  
try {
    rpcObject.bind_all((payload, metadata) => {
        console.log(payload, metadata);
    });
} catch(err){
     console.log(err.source, err.code, err.message);
}

// Binding to all rpc events on dbridgeObject 
try {
    dbridge.rpc.bind_all((payload, metadata) => {
        console.log(payload, metadata);
    });
} catch(err){
     console.log(err.source, err.code, err.message);
}

# Binding to rpc events on rpcObject  
def eventFunction(payload ,  metadata):
  print(payload , metadata)

try:
    rpcObject.bind_all('event',  eventFunction)
except dBError as e:
  print(e.code, e.source, e.message) 

# Binding to rpc events on dbridgeObject 
try {
    dbridge.rpc.bind_all('event', eventFunction)
except dBError as e:
  print(e.code, e.source, e.message) 

//  Binding to all rpc events on rpcObject  
try {
    Action<object , object> irpcstatus;
    rpcObject.bind_all(irpcstatus =  (payload, metadata) => {
        Console.WriteLine("{0} , {1} " , payload, metadata);
    });
} catch (dBError err) {
    Console.WriteLine("{0} ,  {1} , {2}" , err.source, err.code, err.message);
}

// Binding to all rpc events on dbridgeObject 

try {
    Action<object , object> irpcstatus;
    dbridge.rpc.bind_all(irpcstatus =  (payload, metadata) => {
        Console.WriteLine("{0} , {1} " , payload, metadata);
    });
} catch (dBError err) {
    Console.WriteLine("{0} ,  {1} , {2}" , err.source, err.code, err.message);
}

// Remove just `handler` across the rpc server 
rpcObject.unbind_all(handler);

//Remove all handlers for the all event in the subscribed/connected rpc server
rpcObject.unbind_all();

// Remove `handler` across the subscribed/connected rpc servers
dbridge.rpc.unbind_all(handler);

// Remove all handlers for all events across all subscribed/connected rpc servers
dbridge.rpc.unbind_all();

# Remove just `handler` across the rpc server 
rpcObject.unbind_all(handler)

# Remove all handlers for the all event in the subscribed/connected rpc server
rpcObject.unbind_all()

# Remove `handler` across the subscribed/connected rpc servers
dbridge.rpc.unbind_all(handler)

# Remove all handlers for all events across all subscribed/connected rpc servers
dbridge.rpc.unbind_all()

// Remove just `handler` across the rpc server 
rpcObject.unbind_all(handler);

//Remove all handlers for the all event in the subscribed/connected rpc server
rpcObject.unbind_all();

// Remove `handler` across the subscribed/connected rpc servers
dbridge.rpc.unbind_all(handler);

// Remove all handlers for all events across all subscribed/connected rpc servers
dbridge.rpc.unbind_all();

const rpcServer_isonline = rpcObject.isOnline();

rpcServer_isonline = rpcObject.isOnline()

bool rpcServer_isonline = rpcObject.isOnline(); 

const rpcServerName = rpcObject.getServerName() 

rpcServerName = rpcObject.getServerName() 

string rpcServerName = rpcObject.getServerName() 

try {
    const rpcSvrClient = dbridge.rpc.connect('rpcServer'); 
    //name of the rpc endpoint/server that app wants to connect to. In our above example missionControl.
} catch (err) {
    console.log(err.source, err.code, err.message);
}

try:
     rpcSvrClient = dbridge.rpc.connect('rpcServer')
    # name of the rpc endpoint/server that app wants to connect to. In our above example missionControl.
except dBError as e:
     print(e.code, e.source, e.message) 

using  dBridges.remoteprocedure;
try {
    CrpCaller rpcSvrClient = dbridge.rpc.connect('rpcServer');
    //name of the rpc endpoint/server that app wants to connect to. In our above example missionControl.
} catch (dBError err) {
    Console.WriteLine("{0} ,  {1} , {2}" , err.source, err.code, err.message);
}

rpcSvrClient.call(functionName, parameter, ttlms, (response) => {
    console.log('multipart response',response)
}).then((response) => {
    console.log('end response', response)
}).catch((err) => {
    console.log('exception',err.source, err.code, err.message);
});

//Below example how a application can connect to a RPC endpoint / Server called mathServer and use add, multiply functions.
try {
    const myMathServer = dbridge.rpc.connect('mathServer');
} catch (err) {
    console.log(err.source, err.code, err.message);
}

let obj = { "num1":44.5, "num2":30};
let inparam = JSON.stringify(obj);

myMathServer.call(add, inparam, ttlms, (response) => {
}).then((response) => {
    console.log('response: ', JSON.parse(response));
}).catch((err) => {
    console.log('exception',err.source, err.code, err.message);
});

myMathServer.call(multiply, inparam, ttlms, (response) => {
}).then((response) => {
    console.log('response: ', JSON.parse(response));
}).catch((err) => {
    console.log('exception',err.source, err.code, err.message);
});

def progress(response):
    print("multipart: " , response)

def onResult(response):
    print("response: ", response)

def onError(error):
    print(error.code, error.source, error.message)
try:
    p =  await rpcClient.call("functionName" ,  parameter , 10000, progress)
    p.then(onResult).catch(onError)
except dBError as e:
    print(e.code, e.source, e.message) 

# Below example how a application can connect to a RPC endpoint / Server called mathServer and use add, multiply functions.
try:
    myMathServer = dbridge.rpc.connect('mathServer');
except dBError as e:
    print(e.code, e.source, e.message) 

obj = { "num1":44.5, "num2":30};
inparam = json.dumps(obj);
try:
    p =  await myMathServer.call(add ,  inparam , 10000, progress)
    p.then(onResult).catch(onError)

    q =  await myMathServer.call(multiply ,  inparam , 10000, progress)
    q.then(onResult).catch(onError)
except dBError as e:
    print(e.code, e.source, e.message) 

Action<object> iprogress;
IPromise<object> p = rpcClient.call(functionName, parameter, ttlms, iprogress = (response) => {
    Console.WriteLine("multipart response {0}",response)
});
p.Then((response) => {
    Console.WriteLine("end response {0}", response)
}).Catch((err) => {
    Console.WriteLine("exception {0}", err);
});

//Below example how a application can connect to a RPC endpoint / Server called mathServer and use add, multiply functions.
try {
    CrpCaller myMathServer = dbridge.rpc.connect('mathServer');
}catch (dBError err) {
    Console.WriteLine("{0} ,  {1} , {2}" , err.source, err.code, err.message);
}

Dictionary<string , int> obj = new Dictionary<string,int32>() { {"num1",44.5} , {"num2",30} };
inparam = new JavaScriptSerializer().Serialize(obj);

Action<object> iprogress;
IPromise<object> p = myMathServer.call(add, inparam, ttlms, iprogress = (response) => {
    Console.WriteLine("multipart response {0}",response)
});
p.Then((response) => {
    Console.WriteLine("end response {0}", response)
}).Catch((err) => {
    Console.WriteLine("exception {0}", err);
});

Action<object> iprogress;
IPromise<object> p = myMathServer.call(multiply, inparam, ttlms, iprogress = (response) => {
    Console.WriteLine("multipart response {0}",response)
});
p.Then((response) => {
    Console.WriteLine("end response {0}", response)
}).Catch((err) => {
    Console.WriteLine("exception {0}", err);
});

//  Binding to systemevent on rpcObject  
try {
    rpcObject.bind('eventName', (payload, metadata) => {
        console.log( payload, metadata);
    });
} catch(err) {
     console.log(err.source, err.code, err.message);
}
//  Binding to systemevent on dbridgeObject  
try {
    dbridge.rpc.bind('eventName', (payload, metadata) => {
        console.log( payload, metadata);
    });
} catch(err) {
     console.log(err.source, err.code, err.message);
}

#  Binding to systemevent on rpcObject  
async def eventCallback(payload , metadata):
    print(payload , metadata)   

try:
    rpcClient.bind("eventName", eventCallback)
except dBError as e:
    print(e.code, e.source, e.message)

#  Binding to systemevent on dbridgeObject  
try:
    dbridge.rpc.bind("eventName", eventCallback)
except dBError as e:
    print(e.code, e.source, e.message)

//  Binding to systemevent on rpcObject  
Action<object,object> iRpcStatus;
try {
    rpcSvrClient.bind('eventName',  iRpcStatus = (object payload, object metadata) => {
        Console.WriteLine("{0} , {1} " , payload, metadata);
    });
} catch(dBError err){
     Console.WriteLine("{0} , {1}, {2}", err.source, err.code, err.message);
}

// Binding to systemevent on dbridgeObject
try {
    dbridge.rpc.bind('eventName', iRpcStatus = (object payload, object metadata) => {
        Console.WriteLine("{0} , {1} " , payload, metadata);
    });
} catch(dBError err){
     Console.WriteLine("{0} , {1}, {2}" , err.source, err.code, err.message);
}

// Remove just `handler` across the rpc server 
rpcObject.unbind_all(handler);

//Remove all handlers for the all event in the subscribed/connected rpc server
rpcObject.unbind_all();

// Remove `handler` across the subscribed/connected rpc servers
dbridge.rpc.unbind_all(handler);

// Remove all handlers for all events across all subscribed/connected rpc servers
dbridge.rpc.unbind_all();

# Remove just `handler` across the rpc server 
rpcObject.unbind_all(handler)

# Remove all handlers for the all event in the subscribed/connected rpc server
rpcObject.unbind_all()

# Remove `handler` across the subscribed/connected rpc servers
dbridge.rpc.unbind_all(handler)

# Remove all handlers for all events across all subscribed/connected rpc servers
dbridge.rpc.unbind_all()

// Remove just `handler` across the rpc server 
rpcObject.unbind_all(handler);

//Remove all handlers for the all event in the subscribed/connected rpc server
rpcObject.unbind_all();

// Remove `handler` across the subscribed/connected rpc servers
dbridge.rpc.unbind_all(handler);

// Remove all handlers for all events across all subscribed/connected rpc servers
dbridge.rpc.unbind_all();