Usage

dbridge.cf.call(sessionId, 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);
});

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 dbridge.cf.call(sessionId, functionName ,  parameter , 10000, progress)
    p.then(onResult).catch(onError)
except dBError as e:
    print(e.code, e.source, e.message)

using RSG;

Action<object> iprogress;
IPromise<object> p = dbridge.cf.call(sessionId, 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);
});

dbridge.cf.enable = true;

dbridge.cf.enable = True

dbridge.cf.enable = true;

// function is exposed outside the property callback function, but in the scope of application.
function cfFunOutside (payload, response) {
    try {
      let upTime = {"uptime": "13:34:30 up 8 days,  3:10,  1 user,  load average: 0.03, 0.11, 0.21"};
        response.tracker = true;
        response.next('retrieving system uptime');
        response.end(JSON.stringify(upTime));
        response.exception('INVALID_PARAM', 'Wrong parameter'); 
    } catch(err) {
        console.log(err.source, err.code, err.message);
    }
}

dbridge.cf.functions = function () {
    // function is exposed inside the property callback function.
    function cfFunInside (payload, response) {
        try {
            let uName = {"uname": "Linux analysis 2.6.32-696.30.1.el6.x86_64 #1 SMP Tue May 22 03:28:18 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux"};
            response.tracker = true;
            response.next('retrieving uName');
            response.end(JSON.stringify(uName));
            response.exception('INVALID_PARAM', 'Wrong parameter'); 
        } catch(err) {
            console.log(err.source, err.code, err.message);
        }
    }
    // binding of functions to be exposed by clientfunctions
    try {
        dbridge.cf.regfn("sysUpTime", cfFunOutside);
        dbridge.cf.regfn("uName", cfFunInside);
    } catch(err) {
        console.log(err.source, err.code, err.message);
    }
}

// unbinding of function exposed by clientfunctions
dbridge.cf.unregfn("sysUpTime", cfFunOutside);

# function is exposed outside the property callback function, but in the scope of application.
async def cfFunOutside(inparameter, response):
  try:
    response.tracker = True
    upTime = {"uptime": "13:34:30 up 8 days,  3:10,  1 user,  load average: 0.03, 0.11, 0.21"};

    response.next('retrieving system uptime')
    response.end(json,dumps(upTime))
    response.exception('INVALID_PARAM', 'Wrong parameter') 
except dBError as e:
  print(e.code, e.source, e.message) 

async def cfFunctionBinder():
    async def cfFunInside(inparameter, response):
    // function is exposed inside the property callback function.
        response.tracker = True
        try:
          response.tracker = True
          uName = {"uname": "Linux analysis 2.6.32-696.30.1.el6.x86_64 #1 SMP Tue May 22 03:28:18 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux"};
          response.next('retrieving uName')
          response.end(json.dumps(uName))
          response.exception('INVALID_PARAM', 'Wrong parameter') 
        except dBError as e:
          print(e.code, e.source, e.message) 

   try:
      dbridge.cf.regfn("uName", cfFunInside)
      dbridge.cf.regfn("sysUpTime", cfFunOutside)
   except dBError as e:
      print(e.code, e.source, e.message) 

dbridge.cf..functions = cfFunctionBinder
# unbinding of function exposed by rpc functions
dbridge.cf..unregfn("sysUpTime", cfFunOutside)

// function is exposed outside the property callback function, but in the scope of application.
using dBridges.responseHandler;

async void cfFunOutside(object inparam, object response)
{
    try {
        CResponseHandler responsehandler = response as CResponseHandler;
        responsehandler.tracker = true;
        Dictionary<string , string> uName = new Dictionary<string , string>() {"uname", "Linux analysis 2.6.32-696.30.1.el6.x86_64 #1 SMP Tue May 22 03:28:18 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux"};

        responsehandler.next('retrieving uName');
        responsehandler.end(new JavaScriptSerializer().Serialize(uName));
        responsehandler.exception('INVALID_PARAM', 'Wrong parameter'); 
    } catch (dBError err) {
        Console.WriteLine("{0} ,  {1} , {2}" , err.source, err.code, err.message);
    }
}

async void cfFunctionBinder(object sender)
{
    try{
        dBridges.clientFunctions.cfclient cfclient = sender as dBridges.clientFunctions.cfclient;
        // function is exposed outside the property callback function, but in the scope of application.
        Action<object , object> ifunctionoutside = cfFunOutside;
        cfclient.regfn("sysUpTime", ifunctionoutside);

        // function is exposed inside the property callback function.
        Action<object , object> ifunctioninside;
        cfclient.regfn("uName", ifunctioninside = (object inparam, object response) =>{
            try {
                CResponseHandler responsehandler = response as CResponseHandler;
                responsehandler.tracker = true;
                Dictionary<string , string> uName = new Dictionary<string , string>() {"uname", "Linux analysis 2.6.32-696.30.1.el6.x86_64 #1 SMP Tue May 22 03:28:18 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux"};

                responsehandler.next('retrieving uName');
                responsehandler.end(new JavaScriptSerializer().Serialize(uName));
                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> icfFunctions = cfFunctionBinder;
dbridge.cf.functions = icfFunctions;
// unbinding of function exposed by clientfunctions
dbridge.cf.unregfn("sysUpTime", cfFunOutside);

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

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

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

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

# Binding to systemevent on dbridgeObject  
def void my_cf_function(payload , metadata):
    print(payload)
try:
    dbridge.cf.bind('eventName', my_cf_function)
except dBError as e:
    print(e.code, e.source, e.message)

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