void OnDestroy()
{
set_recurring_reply(gameObject.GetHashCode(), null);
_recurring_callback_holder = null;
set_recurring_data_push(gameObject.GetHashCode(), null);
_recurring_data_push_holder = null;
}
public void ProtocolWithBlockProperties(bool required, bool instance)
{
using (var pb = new PropertyBlock()) {
var callbackCalled = false;
SimpleCallback action = () => {
callbackCalled = true;
};
if (required)
{
if (instance)
{
pb.MyRequiredProperty = action;
}
else
{
PropertyBlock.MyRequiredStaticProperty = action;
}
}
else
{
if (instance)
{
pb.MyOptionalProperty = action;
}
else
{
PropertyBlock.MyOptionalStaticProperty = action;
}
}
ObjCBlockTester.CallProtocolWithBlockProperties(pb, required, instance);
Assert.IsTrue(callbackCalled, "Callback");
}
}
void OnApplicationQuit()
{
set_recurring_reply(gameObject.GetHashCode(), null);
_recurring_callback_holder = null;
set_recurring_data_push(gameObject.GetHashCode(), null);
_recurring_data_push_holder = null;
}
public Notification(NotificationType t, string tex, bool s, SimpleCallback cb)
{
Type = t;
Text = tex;
ShowHideButton = s;
Callback = cb;
}
void Awake()
{
Debug.Log("testing callbacks on object:" + gameObject.GetHashCode());
// during the course of this call into the plugin, it will call back the _onetime_callback() function.
// because the plugin call/marshaling layer retains a reference to the SimpleCallback delegate, it
// can not be freed or GC'd during the call
// all of the following syntaxes work:
// 1. reply_during_call(new SimpleCallback(this._onetime_callback));
// 2. reply_during_call(this._onetime_callback);
// 3. below, the most clear form
reply_during_call(_onetime_callback);
// to pass a delegate that is called after the call into the plugin completes, either later
// or repeatedly later, you have to retain the delegate, which you can only do by holding
// it in a wider-scope, in this case in a private member/ivar. the marshaling layer will
// add a hold/addref/retain to the delegate during the call and release it on return, so
// unless you are holding on to it the plugin would be left with an invalid pointer as
// soon as GC runs. it's worth understanding that the delegate is effectively two "objects":
// a managed object in C# which may move due to GC which is holding onto a fixed
// (possibly unmanaged - that's runtime-dependent) function-pointer which is what the
// plugin can refer to. GC may move the managed C# object around, but the function pointer
// in the native-code plugin remains immobile.
_recurring_callback_holder = new SimpleCallback(_recurring_callback);
set_recurring_reply(gameObject.GetHashCode(), _recurring_callback_holder);
// this is a one-time data-polling call to pull bytes from native/unmanaged code.
// the difficulty with a poll API is that the plugin cannot allocate memory for the
// caller easily unless both sides agree how it is going to be released. a polling
// API can be useful if you have a native data structure or very long-lived buffer
// associated with the specific object instance that Unity can depend on not moving
// or disappearing. alternately you can force the caller to deallocate the memory
// returned from the poll. as with any real-time system, though, you want to make
// sure you are minimizing data copies (and conversions), so think through the
// memory lifetimes carefully.
IntPtr buffer = IntPtr.Zero, length = IntPtr.Zero;
poll_data(gameObject.GetHashCode(), out buffer, out length);
if (buffer != IntPtr.Zero && length != IntPtr.Zero)
{
int len = length.ToInt32();
byte[] data = new byte[len];
Marshal.Copy(buffer, data, 0, len);
Debug.Log("polled " + len + " bytesinto C# as " + data);
}
// this recurring callback, like the SimpleCallback, must be held longer than the
// duration of the call. this example is to demonstrate a common requirement: passing
// data between a native/unmanaged plugin C#. in this case the native plugin pushes
// raw bytes of data into a C# byte[], which is a nice way to control the lifetime
// of the data on the plugin's side - by the time the callback returns the plugin
// knows Unity/C# has no further access, they should have copied what they needed.
// this form of "push" API's where the native side buffers data and pushes it to
// Unity/C# and the C# side also buffers and uses and frees it on its own schedule
// is a pretty safe design which can minimize the total number of data copies
// and problems with memory leaks.
_recurring_data_push_holder = new DataCallback(_recurring_data_push);
set_recurring_data_push(gameObject.GetHashCode(), _recurring_data_push_holder);
}
public void DelegateMethodTest()
{
SimpleCallback callback = new SimpleCallback(SimpleCallbackImpl);
method = GetMethodForTest("SimpleCallbackImpl");
messageCollection = rule.CheckMethod(method, new MinimalRunner());
Assert.IsNull(messageCollection);
}
public void DelegateMethodTestWithMultipleDelegates()
{
SimpleCallback callback = new SimpleCallback(SimpleCallbackImpl);
SimpleCallback callback2 = new SimpleCallback(SimpleCallbackImpl2);
AssertRuleDoesNotApply <AvoidUnusedParametersTest> ("SimpleCallbackImpl");
AssertRuleDoesNotApply <AvoidUnusedParametersTest> ("SimpleCallbackImpl2");
}
public void Logout(SimpleCallback callback = null)
{
UserId = null;
UserName = null;
UserEmail = null;
UserLoggedIn = false;
callback?.Invoke();
}
public void TC015_MultipleResponseCallback()
{
bool errorThrown = false;
List <int> expected = new List <int>();
List <int> response = new List <int>();
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
SimpleCallback[] delegates = new SimpleCallback[] {
delegate() { response.Add(0); },
delegate() { response.Add(1); },
delegate() { response.Add(2); },
delegate() { response.Add(3); },
delegate() { response.Add(4); },
delegate() { response.Add(5); },
delegate() { response.Add(6); },
delegate() { response.Add(7); },
delegate() { response.Add(8); },
delegate() { response.Add(9); },
delegate() { response.Add(10); },
delegate() { response.Add(11); },
delegate() { response.Add(12); },
delegate() { response.Add(13); },
delegate() { response.Add(14); }
};
for (int i = 0; i < 15; i++)
{
expected.Add(i);
natsClient.Publish("foo", delegates[i]);
}
natsClient.Publish("foo", delegate()
{
resetEvent.Set();
});
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
for (int i = 0; i < 15; i++)
{
Assert.AreEqual(expected[i], response[i]);
}
}
void Awake () {
Debug.Log("testing callbacks on object:" + gameObject.GetHashCode());
// during the course of this call into the plugin, it will call back the _onetime_callback() function.
// because the plugin call/marshaling layer retains a reference to the SimpleCallback delegate, it
// can not be freed or GC'd during the call
// all of the following syntaxes work:
// 1. reply_during_call(new SimpleCallback(this._onetime_callback));
// 2. reply_during_call(this._onetime_callback);
// 3. below, the most clear form
reply_during_call(_onetime_callback);
// to pass a delegate that is called after the call into the plugin completes, either later
// or repeatedly later, you have to retain the delegate, which you can only do by holding
// it in a wider-scope, in this case in a private member/ivar. the marshaling layer will
// add a hold/addref/retain to the delegate during the call and release it on return, so
// unless you are holding on to it the plugin would be left with an invalid pointer as
// soon as GC runs. it's worth understanding that the delegate is effectively two "objects":
// a managed object in C# which may move due to GC which is holding onto a fixed
// (possibly unmanaged - that's runtime-dependent) function-pointer which is what the
// plugin can refer to. GC may move the managed C# object around, but the function pointer
// in the native-code plugin remains immobile.
_recurring_callback_holder = new SimpleCallback(_recurring_callback);
set_recurring_reply(gameObject.GetHashCode(), _recurring_callback_holder);
// this is a one-time data-polling call to pull bytes from native/unmanaged code.
// the difficulty with a poll API is that the plugin cannot allocate memory for the
// caller easily unless both sides agree how it is going to be released. a polling
// API can be useful if you have a native data structure or very long-lived buffer
// associated with the specific object instance that Unity can depend on not moving
// or disappearing. alternately you can force the caller to deallocate the memory
// returned from the poll. as with any real-time system, though, you want to make
// sure you are minimizing data copies (and conversions), so think through the
// memory lifetimes carefully.
IntPtr buffer=IntPtr.Zero, length=IntPtr.Zero;
poll_data(gameObject.GetHashCode(), out buffer, out length);
if (buffer != IntPtr.Zero && length != IntPtr.Zero) {
int len = length.ToInt32();
byte[] data = new byte[len];
Marshal.Copy(buffer, data, 0, len);
Debug.Log("polled " + len + " bytesinto C# as " + data);
}
// this recurring callback, like the SimpleCallback, must be held longer than the
// duration of the call. this example is to demonstrate a common requirement: passing
// data between a native/unmanaged plugin C#. in this case the native plugin pushes
// raw bytes of data into a C# byte[], which is a nice way to control the lifetime
// of the data on the plugin's side - by the time the callback returns the plugin
// knows Unity/C# has no further access, they should have copied what they needed.
// this form of "push" API's where the native side buffers data and pushes it to
// Unity/C# and the C# side also buffers and uses and frees it on its own schedule
// is a pretty safe design which can minimize the total number of data copies
// and problems with memory leaks.
_recurring_data_push_holder = new DataCallback(_recurring_data_push);
set_recurring_data_push(gameObject.GetHashCode(), _recurring_data_push_holder);
}
/// <summary>
/// Queues the server.
/// </summary>
/// <param name="callback">The callback.</param>
private void QueueServer(SimpleCallback callback)
{
if (callback == null)
{
return;
}
this.pongs.Enqueue(callback);
this.SendCommand(this.resource.PINGREQUEST);
}
public void Init()
{
var responder = new SpecificResponder <Simple>(new SimpleImpl());
server = new SocketServer("localhost", 0, responder);
server.Start();
transceiver = new SocketTransceiver("localhost", server.Port);
simpleClient = SpecificRequestor.CreateClient <SimpleCallback>(transceiver);
}
IEnumerator StartsPerClassTask(SimpleCallback callThis)
{
Debug.Log("starting");
yield return(new WaitForSeconds(2));
Debug.Log("finishing");
//this is quite specific
callThis.PersonalCall();
}
public void CreateMoreComplexCallable()
{
EasyType typebuilder = new EasyType(module, "mytype");
ArgumentReference arg1 = new ArgumentReference(typeof(int));
ArgumentReference arg2 = new ArgumentReference(typeof(DateTime));
ArgumentReference arg3 = new ArgumentReference(typeof(object));
EasyCallable callable = typebuilder.CreateCallable(
new ReturnReferenceExpression(typeof(string)),
arg1, arg2, arg3);
FieldReference field1 = typebuilder.CreateField("field1", callable.TypeBuilder);
SimpleCallback sc = new SimpleCallback();
ArgumentReference arg = new ArgumentReference(typeof(SimpleCallback));
EasyConstructor constructor = typebuilder.CreateConstructor(arg);
constructor.CodeBuilder.InvokeBaseConstructor();
constructor.CodeBuilder.AddStatement(new AssignStatement(field1,
new NewInstanceExpression(callable,
arg.ToExpression(),
new MethodPointerExpression(arg, typeof(SimpleCallback).GetMethod("RunAs")))));
constructor.CodeBuilder.AddStatement(new ReturnStatement());
arg1 = new ArgumentReference(typeof(int));
arg2 = new ArgumentReference(typeof(DateTime));
arg3 = new ArgumentReference(typeof(object));
ReturnReferenceExpression ret1 = new ReturnReferenceExpression(typeof(string));
EasyMethod getField1 = typebuilder.CreateMethod("Exec", ret1, arg1, arg2, arg3);
getField1.CodeBuilder.AddStatement(
new ReturnStatement(
new ConvertExpression(typeof(String),
new MethodInvocationExpression(field1,
callable.Callmethod,
new ReferencesToObjectArrayExpression(arg1, arg2, arg3)))));
Type newType = typebuilder.BuildType();
RunPEVerify();
object instance = Activator.CreateInstance(newType, new object[] { sc });
MethodInfo method = instance.GetType().GetMethod("Exec");
object result = method.Invoke(instance, new object[] { 1, DateTime.Now, "" });
Assert.AreEqual("hello2", result);
}
public static void ShowIt(GameWindow window)
{
FormScreenMark form = new FormScreenMark();
form.Window = window;
form.btnUpdateScreen_Click(form, null);
SimpleCallback sc = new SimpleCallback(form.L2Window_ScreenshotUpdate);
form.Window.ProgressBindings.ScreenshotUpdate += sc;
form.Window.ProgressBindings.RefreshScreenshot();
form.updateWhoList();
form.ShowDialog();
window.ProgressBindings.ScreenshotUpdate -= sc;
}
}//OnLookAround
public IEnumerator LookAround(SimpleCallback callback = null)
{
yield return(new WaitForSeconds(1f));
DirSwitcherCmp.OnSwitchDirection();
yield return(new WaitForSeconds(1f));
DirSwitcherCmp.OnSwitchDirection();
yield return(new WaitForSeconds(1f));
callback?.Invoke();
}//LookAround
public static void ShowIt(GameWindow window)
{
FormScreenMark form = new FormScreenMark();
form.Window = window;
form.btnUpdateScreen_Click(form, null);
SimpleCallback sc = new SimpleCallback(form.L2Window_ScreenshotUpdate);
form.Window.ProgressBindings.ScreenshotUpdate += sc;
form.Window.ProgressBindings.RefreshScreenshot();
form.updateWhoList();
form.ShowDialog();
window.ProgressBindings.ScreenshotUpdate -= sc;
}
/// <summary>
/// Saves the email for the player data
/// </summary>
/// <param name="callback"></param>
public static void Identify(string email, SimpleCallback callback)
{
string identifyUrl = string.Format(
"/games/{0}/player/identify",
Proba.Configuration.GameId
);
Request request = new Request(identifyUrl);
request
.AddParam("email", email)
.Post()
.onFinish += (r) => {
BaseResponse res = JsonUtility.FromJson <BaseResponse>(r.Response);
if (res.success)
{
callback();
}
};
}
/// <summary>
/// Publish a message to a given subject, with optional reply subject and completion block.
/// </summary>
/// <param name="subject">the subject to publish to</param>
/// <param name="callback">server callback</param>
/// <param name="msg">the message to publish</param>
/// <param name="optReply">replay subject</param>
public void Publish(string subject, SimpleCallback callback, string msg, string optReply)
{
lock (this.publishLock)
{
if (msg == null)
{
throw new ArgumentNullException("msg");
}
if (string.IsNullOrEmpty(subject))
{
return;
}
this.SendCommand(string.Format(CultureInfo.InvariantCulture, "PUB {0} {1} {2}{3}{4}{5}", subject, optReply, msg.Length, Resource.CRLF, msg, Resource.CRLF));
if (callback != null)
{
this.QueueServer(callback);
}
}
}
/// <summary>
/// Spend an amount of credits
/// </summary>
/// <param name="credits">Amount of credits</param>
public void Spend(int credits, SimpleCallback callback = null)
{
string spendCreditsUrl = string.Format(
"/games/{0}/player/spend",
Proba.Configuration.GameId
);
Request request = new Request(spendCreditsUrl);
request.AddParam("amount", credits);
// Send request
request
.Post()
.onFinish += (r) => {
if (callback != null)
{
BaseResponse res = JsonUtility.FromJson <BaseResponse>(r.Response);
callback(res);
}
};;
}
public void Publish(string replyTo, string payload, SimpleCallback block)
{
Logger.Info("reply_to: {0}: payload: {1}", replyTo, payload);
string unencrypted = string.Empty;
if (this.Credentials != null)
{
unencrypted = payload;
payload = this.Encrypt(replyTo, payload);
}
//todo: vladi: encode JSON;
//YamlNode json =payload;
// TODO figure out if we want to try to scale down the message instead
// of generating an exception
//if (json.Bytesize < NATS_MAX_PAYLOAD_SIZE)
//{
try
{
this.Nats.Publish(replyTo, block, payload);
}
catch (Exception ex)
{
Logger.Error("Error while publishing to nats");
}
//}
//else
//{
// string msg = "message > NATS_MAX_PAYLOAD, stored in blobstore";
// string original = this.Credentials != null ? payload : unencrypted;
// RemoteException exception = new RemoteException(msg, null, original);
// Logger.Fatal(msg);
// // todo: vladi: fix exception serialization
// this.Nats.Publish(replyTo, block, exception.ToHash().ToString());
//}
}
public DebugDraw()
{
_drawAabb = new DrawAabbUnmanagedDelegate(DrawAabb);
_drawArc = new DrawArcUnmanagedDelegate(DrawArc);
_drawBox = new DrawBoxUnmanagedDelegate(DrawBox);
_drawCapsule = new DrawCapsuleUnmanagedDelegate(DrawCapsule);
_drawCone = new DrawConeUnmanagedDelegate(DrawCone);
_drawContactPoint = new DrawContactPointUnmanagedDelegate(DrawContactPoint);
_drawCylinder = new DrawCylinderUnmanagedDelegate(DrawCylinder);
_drawLine = new DrawLineUnmanagedDelegate(DrawLine);
_drawPlane = new DrawPlaneUnmanagedDelegate(DrawPlane);
_drawSphere = new DrawSphereUnmanagedDelegate(DrawSphere);
_drawSpherePatch = new DrawSpherePatchUnmanagedDelegate(DrawSpherePatch);
_drawTransform = new DrawTransformUnmanagedDelegate(DrawTransform);
_drawTriangle = new DrawTriangleUnmanagedDelegate(DrawTriangle);
_getDebugMode = new GetDebugModeUnmanagedDelegate(GetDebugModeUnmanaged);
_cb = new SimpleCallback(SimpleCallbackUnmanaged);
IntPtr native = btIDebugDrawWrapper_new(
GCHandle.ToIntPtr(GCHandle.Alloc(this)),
Marshal.GetFunctionPointerForDelegate(_drawAabb),
Marshal.GetFunctionPointerForDelegate(_drawArc),
Marshal.GetFunctionPointerForDelegate(_drawBox),
Marshal.GetFunctionPointerForDelegate(_drawCapsule),
Marshal.GetFunctionPointerForDelegate(_drawCone),
Marshal.GetFunctionPointerForDelegate(_drawContactPoint),
Marshal.GetFunctionPointerForDelegate(_drawCylinder),
Marshal.GetFunctionPointerForDelegate(_drawLine),
Marshal.GetFunctionPointerForDelegate(_drawPlane),
Marshal.GetFunctionPointerForDelegate(_drawSphere),
Marshal.GetFunctionPointerForDelegate(_drawSpherePatch),
Marshal.GetFunctionPointerForDelegate(_drawTransform),
Marshal.GetFunctionPointerForDelegate(_drawTriangle),
Marshal.GetFunctionPointerForDelegate(_getDebugMode),
Marshal.GetFunctionPointerForDelegate(_cb));
InitializeUserOwned(native);
}
/// <summary>
/// Save a property into the properties list for this player
/// </summary>
/// <param name="name"></param>
/// <param name="value"></param>
public void SaveProperty(string name, string value, SimpleCallback callback = null)
{
string savePropertyUrl = string.Format(
"/games/{0}/player/properties",
Proba.Configuration.GameId
);
Request request = new Request(savePropertyUrl);
request.AddParam("name", name);
request.AddParam("value", value);
// Send request
request
.Post()
.onFinish += (r) => {
if (callback != null)
{
BaseResponse res = JsonUtility.FromJson <BaseResponse>(r.Response);
callback(res);
}
};;
}
private static extern void reply_during_call(SimpleCallback callback);
/// <summary>
/// Publish a message to a given subject, with optional reply subject and completion block.
/// </summary>
/// <param name="subject">the subject to publish to</param>
/// <param name="callback">server callback</param>
/// <param name="msg">the message to publish</param>
/// <param name="optReply">replay subject</param>
public void Publish(string subject, SimpleCallback callback, string msg, string optReply)
{
lock (this.publishLock)
{
if (msg == null)
{
throw new ArgumentNullException("msg");
}
if (string.IsNullOrEmpty(subject))
{
return;
}
this.SendCommand(string.Format(CultureInfo.InvariantCulture, "PUB {0} {1} {2}{3}{4}{5}", subject, optReply, msg.Length, Resource.CRLF, msg, Resource.CRLF));
if (callback != null)
{
this.QueueServer(callback);
}
}
}
public static void DoSomethingAsynchronous(SimpleCallback simpleCallback)
{
// ... do something ...
simpleCallback(true);
}
public void GetScreenshot(SimpleCallback callback)
{
RefreshScreenshot();
}
void OnApplicationQuit() {
set_recurring_reply(gameObject.GetHashCode(), null);
_recurring_callback_holder = null;
set_recurring_data_push(gameObject.GetHashCode(), null);
_recurring_data_push_holder = null;
}
/// <summary>
/// Publish a message to a given subject, with optional reply subject and completion block.
/// </summary>
/// <param name="subject">the subject to publish to</param>
/// <param name="callback">server callback</param>
public void Publish(string subject, SimpleCallback callback)
{
this.Publish(subject, callback, Resource.EMPTYMSG, null);
}
public void DelegateMethodTest ()
{
SimpleCallback callback = new SimpleCallback (SimpleCallbackImpl);
method = GetMethodForTest ("SimpleCallbackImpl");
messageCollection = rule.CheckMethod (method, new MinimalRunner ());
Assert.IsNull (messageCollection);
}
internal void InitTarget(IDebugDraw target)
{
_drawAabb = new DrawAabbUnmanagedDelegate(target.DrawAabb);
_drawArc = new DrawArcUnmanagedDelegate(target.DrawArc);
_drawBox = new DrawBoxUnmanagedDelegate(target.DrawBox);
_drawCapsule = new DrawCapsuleUnmanagedDelegate(target.DrawCapsule);
_drawCone = new DrawConeUnmanagedDelegate(target.DrawCone);
_drawContactPoint = new DrawContactPointUnmanagedDelegate(target.DrawContactPoint);
_drawCylinder = new DrawCylinderUnmanagedDelegate(target.DrawCylinder);
_drawLine = new DrawLineUnmanagedDelegate(target.DrawLine);
_drawPlane = new DrawPlaneUnmanagedDelegate(target.DrawPlane);
_drawSphere = new DrawSphereUnmanagedDelegate(target.DrawSphere);
_drawSpherePatch = new DrawSpherePatchUnmanagedDelegate(target.DrawSpherePatch);
_drawTransform = new DrawTransformUnmanagedDelegate(target.DrawTransform);
_drawTriangle = new DrawTriangleUnmanagedDelegate(target.DrawTriangle);
_getDebugMode = new GetDebugModeUnmanagedDelegate(GetDebugModeUnmanaged);
_cb = new SimpleCallback(SimpleCallbackUnmanaged);
_native = btIDebugDrawWrapper_new(
GCHandle.ToIntPtr(GCHandle.Alloc(this)),
Marshal.GetFunctionPointerForDelegate(_drawAabb),
Marshal.GetFunctionPointerForDelegate(_drawArc),
Marshal.GetFunctionPointerForDelegate(_drawBox),
Marshal.GetFunctionPointerForDelegate(_drawCapsule),
Marshal.GetFunctionPointerForDelegate(_drawCone),
Marshal.GetFunctionPointerForDelegate(_drawContactPoint),
Marshal.GetFunctionPointerForDelegate(_drawCylinder),
Marshal.GetFunctionPointerForDelegate(_drawLine),
Marshal.GetFunctionPointerForDelegate(_drawPlane),
Marshal.GetFunctionPointerForDelegate(_drawSphere),
Marshal.GetFunctionPointerForDelegate(_drawSpherePatch),
Marshal.GetFunctionPointerForDelegate(_drawTransform),
Marshal.GetFunctionPointerForDelegate(_drawTriangle),
Marshal.GetFunctionPointerForDelegate(_getDebugMode),
Marshal.GetFunctionPointerForDelegate(_cb));
}
/// <summary>
/// Publish a message to a given subject, with optional reply subject and completion block.
/// </summary>
/// <param name="subject">the subject to publish to</param>
/// <param name="callback">server callback</param>
public void Publish(string subject, SimpleCallback callback)
{
this.Publish(subject, callback, Resource.EMPTYMSG, null);
}
public void GetScreenshot(SimpleCallback callback)
{
RefreshScreenshot();
}
void OnDestroy() {
set_recurring_reply(gameObject.GetHashCode(), null);
_recurring_callback_holder = null;
set_recurring_data_push(gameObject.GetHashCode(), null);
_recurring_data_push_holder = null;
}
/// <summary>
/// Publish a message to a given subject, with optional reply subject and completion block.
/// </summary>
/// <param name="subject">the subject to publish to</param>
/// <param name="callback">server callback</param>
/// <param name="msg">the message to publish</param>
public void Publish(string subject, SimpleCallback callback, string msg)
{
this.Publish(subject, callback, msg, null);
}
/// <summary>
/// Queues the server.
/// </summary>
/// <param name="callback">The callback.</param>
private void QueueServer(SimpleCallback callback)
{
if (callback == null)
{
return;
}
this.pongs.Enqueue(callback);
this.SendCommand(this.resource.PINGREQUEST);
}
public void GetScreenshot(SimpleCallback callback)
{
ScreenshotUpdate += callback;
RefreshScreenshot();
}
private static extern void set_recurring_reply(int objectHash, SimpleCallback callback);
public void GetScreenshot(SimpleCallback callback)
{
ScreenshotUpdate += callback;
RefreshScreenshot();
}
public void AnonymousMethodWithUnusedParameters()
{
SimpleCallback callback = delegate(int x) {
//Empty
};
}
IEnumerator StartsPerClassTask( SimpleCallback callThis )
{
Debug.Log( "starting" );
yield return new WaitForSeconds(2);
Debug.Log( "finishing" );
//this is quite specific
callThis.PersonalCall();
}
public void CreateMoreComplexCallable()
{
EasyType typebuilder = new EasyType( module, "mytype" );
ArgumentReference arg1 = new ArgumentReference( typeof(int) );
ArgumentReference arg2 = new ArgumentReference( typeof(DateTime) );
ArgumentReference arg3 = new ArgumentReference( typeof(object) );
EasyCallable callable = typebuilder.CreateCallable(
new ReturnReferenceExpression(typeof(string)),
arg1, arg2, arg3 );
FieldReference field1 = typebuilder.CreateField( "field1", callable.TypeBuilder );
SimpleCallback sc = new SimpleCallback();
ArgumentReference arg = new ArgumentReference( typeof(SimpleCallback) );
EasyConstructor constructor = typebuilder.CreateConstructor( arg );
constructor.CodeBuilder.InvokeBaseConstructor();
constructor.CodeBuilder.AddStatement( new AssignStatement(field1,
new NewInstanceExpression( callable,
arg.ToExpression(),
new MethodPointerExpression( arg, typeof(SimpleCallback).GetMethod("RunAs") ) ) ) );
constructor.CodeBuilder.AddStatement( new ReturnStatement() );
arg1 = new ArgumentReference( typeof(int) );
arg2 = new ArgumentReference( typeof(DateTime) );
arg3 = new ArgumentReference( typeof(object) );
ReturnReferenceExpression ret1 = new ReturnReferenceExpression(typeof(string));
EasyMethod getField1 = typebuilder.CreateMethod( "Exec", ret1, arg1, arg2, arg3 );
getField1.CodeBuilder.AddStatement(
new ReturnStatement(
new ConvertExpression( typeof(String),
new MethodInvocationExpression( field1,
callable.Callmethod,
new ReferencesToObjectArrayExpression(arg1, arg2, arg3) ) ) ) );
Type newType = typebuilder.BuildType();
RunPEVerify();
object instance = Activator.CreateInstance( newType, new object[] { sc } );
MethodInfo method = instance.GetType().GetMethod("Exec");
object result = method.Invoke( instance, new object[] { 1, DateTime.Now, "" } );
Assert.AreEqual( "hello2", result );
}
/// <summary>
/// Publish a message to a given subject, with optional reply subject and completion block.
/// </summary>
/// <param name="subject">the subject to publish to</param>
/// <param name="callback">server callback</param>
/// <param name="msg">the message to publish</param>
public void Publish(string subject, SimpleCallback callback, string msg)
{
this.Publish(subject, callback, msg, null);
}
public void TC015_MultipleResponseCallback()
{
bool errorThrown = false;
List<int> expected = new List<int>();
List<int> response = new List<int>();
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler<ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
SimpleCallback[] delegates = new SimpleCallback[] {
delegate() { response.Add(0); },
delegate() { response.Add(1); },
delegate() { response.Add(2); },
delegate() { response.Add(3); },
delegate() { response.Add(4); },
delegate() { response.Add(5); },
delegate() { response.Add(6); },
delegate() { response.Add(7); },
delegate() { response.Add(8); },
delegate() { response.Add(9); },
delegate() { response.Add(10); },
delegate() { response.Add(11); },
delegate() { response.Add(12); },
delegate() { response.Add(13); },
delegate() { response.Add(14); }
};
for (int i = 0; i < 15; i++)
{
expected.Add(i);
natsClient.Publish("foo", delegates[i]);
}
natsClient.Publish("foo", delegate()
{
resetEvent.Set();
});
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
for (int i = 0; i < 15; i++)
{
Assert.AreEqual(expected[i], response[i]);
}
}
private void ReceiveData(byte[] data, int bytesRead)
{
if (this.buf == null)
{
this.buf = new List <byte>(bytesRead);
}
this.buf.AddRange(data.Take(bytesRead));
while (this.buf != null)
{
switch (this.parseState)
{
case ParseState.AwaitingControlLine:
{
ASCIIEncoding ascii = new ASCIIEncoding();
string strBuffer = ascii.GetString(this.buf.ToArray());
if (this.resource.MSG.IsMatch(strBuffer))
{
Match match = this.resource.MSG.Match(strBuffer);
strBuffer = this.resource.MSG.Replace(strBuffer, string.Empty);
this.subscriptionId = Convert.ToInt32(match.Groups[2].Value, CultureInfo.InvariantCulture);
this.reply = match.Groups[4].Value;
this.needed = Convert.ToInt32(match.Groups[5].Value, CultureInfo.InvariantCulture);
this.parseState = ParseState.AwaitingMsgPayload;
}
else if (this.resource.OK.IsMatch(strBuffer))
{
strBuffer = this.resource.OK.Replace(strBuffer, string.Empty);
}
else if (this.resource.ERR.IsMatch(strBuffer))
{
if (this.OnError != null)
{
this.OnError(this, new ReactorErrorEventArgs(this.resource.ERR.Match(strBuffer).Groups[1].Value));
}
strBuffer = this.resource.ERR.Replace(strBuffer, string.Empty);
}
else if (this.resource.PING.IsMatch(strBuffer))
{
this.SendCommand(this.resource.PONGRESPONSE);
strBuffer = this.resource.PING.Replace(strBuffer, string.Empty);
}
else if (this.resource.PONG.IsMatch(strBuffer))
{
if (this.pongs.Count > 0)
{
SimpleCallback callback = this.pongs.Dequeue();
try
{
callback();
}
catch (Exception ex)
{
if (this.OnError != null)
{
this.OnError(this, new ReactorErrorEventArgs(Language.CallbackException, ex));
}
}
}
strBuffer = this.resource.PONG.Replace(strBuffer, string.Empty);
}
else if (this.resource.INFO.IsMatch(strBuffer))
{
this.serverInfo = JsonConvertibleObject.ObjectToValue <Dictionary <string, object> >(JsonConvertibleObject.DeserializeFromJson(this.resource.INFO.Match(strBuffer).Groups[1].Value));
strBuffer = this.resource.INFO.Replace(strBuffer, string.Empty);
}
else if (this.resource.UNKNOWN.IsMatch(strBuffer))
{
if (this.OnError != null)
{
this.OnError(this, new ReactorErrorEventArgs(Language.ERRUnknownProtocol + this.resource.UNKNOWN.Match(strBuffer).Value));
}
strBuffer = this.resource.UNKNOWN.Replace(strBuffer, string.Empty);
}
else
{
this.buf = ascii.GetBytes(strBuffer).ToList();
return;
}
this.buf = ascii.GetBytes(strBuffer).ToList();
if (this.buf != null && this.buf.Count == 0)
{
this.buf = null;
}
}
break;
case ParseState.AwaitingMsgPayload:
{
if (this.buf.Count < (this.needed + Resource.CRLF.Length))
{
return;
}
ASCIIEncoding ascii = new ASCIIEncoding();
string strBuffer = ascii.GetString(this.buf.ToArray());
this.OnMessage(this.subscriptionId, this.reply, strBuffer.Substring(0, this.needed));
strBuffer = strBuffer.Substring(this.needed + Resource.CRLF.Length);
this.reply = string.Empty;
this.subscriptionId = this.needed = 0;
this.parseState = ParseState.AwaitingControlLine;
this.buf = ascii.GetBytes(strBuffer).ToList();
if (this.buf != null && this.buf.Count == 0)
{
this.buf = null;
}
}
break;
}
}
}
private static extern void SimpleCallbackFun(SimpleCallback c);
//------------------- Section 2 test functions -------------------------------------------------
private void Run2_1()
{
SimpleCallback sc = new SimpleCallback(SimpleCallbackUnityFun);
SimpleCallbackFun(sc);
}
public void Publish(string replyTo, string payload, SimpleCallback block)
{
Logger.Info("reply_to: {0}: payload: {1}", replyTo, payload);
string unencrypted = string.Empty;
if (this.Credentials != null)
{
unencrypted = payload;
payload = this.Encrypt(replyTo, payload);
}
//todo: vladi: encode JSON;
//YamlNode json =payload;
// TODO figure out if we want to try to scale down the message instead
// of generating an exception
//if (json.Bytesize < NATS_MAX_PAYLOAD_SIZE)
//{
try
{
this.Nats.Publish(replyTo, block, payload);
}
catch (Exception ex)
{
Logger.Error("Error while publishing to nats");
}
//}
//else
//{
// string msg = "message > NATS_MAX_PAYLOAD, stored in blobstore";
// string original = this.Credentials != null ? payload : unencrypted;
// RemoteException exception = new RemoteException(msg, null, original);
// Logger.Fatal(msg);
// // todo: vladi: fix exception serialization
// this.Nats.Publish(replyTo, block, exception.ToHash().ToString());
//}
}
