Exemplo n.º 1
0
        public HandleInfoResult HandleInfo(HandleInfoContext ctx, Object msg)
        {
            switch (msg)
            {
            case Tuple <Atom, Pid, String, Byte[]> c when c.Item1 == "write":
                Atom result = (Atom)Erl.Modules.File.WriteFile(c.Item3, c.Item4);
                Erl.Send(c.Item2, new Atom(result));
                break;

            case Tuple <Atom, String> cmd when cmd.Item1 == "open":
                Tuple <Atom, Pid> success = (Tuple <Atom, Pid>)Erl.Modules.File.Open(cmd.Item2, new object[] { new Atom("write") });
                this.fileHandle = success.Item2;
                break;

            case Tuple <Atom, byte[]> cmd when cmd.Item1 == "write":
                Erl.Modules.File.Write(this.fileHandle, cmd.Item2);
                break;

            case Tuple <Atom, Pid> cmd when cmd.Item1 == "close":
                Erl.Modules.File.Close(this.fileHandle);
                Erl.Send(cmd.Item2, new Atom("ok"));
                break;
            }
            return(ctx.NoReply());
        }
Exemplo n.º 2
0
 public TerminateResult Terminate(TerminateContext ctx, Atom reason)
 {
     if (this.owner.HasValue)
     {
         Erl.Send(this.owner, new Atom("bye"));
     }
     return(ctx.Ok());
 }
Exemplo n.º 3
0
        private void HandleInfoImpl(InfoMsg msg)
        {
            switch (msg)
            {
            case ("hello bob", _):
                Erl.Send(msg.Item2, "hello joe");
                break;

            case (_, _):
                Erl.Send(msg.Item2, "woah");
                break;
            }
        }
Exemplo n.º 4
0
        ProcessResult WorkerLoopReceive(Process ctx, Object msg)
        {
            switch (msg)
            {
            case Atom cmd when cmd == "bye":
                return(ctx.Finish(new Atom("ok")));

            case Tuple <Atom, Pid, Atom> tuple when tuple.Item1 == "send_me":
                Erl.Send(tuple.Item2, tuple.Item3);
                break;

            default:
                Console.WriteLine("Unexpected message received, looping");
                break;
            }
            return(ctx.Receive((Process ctx, Object msg) => WorkerLoopReceive(ctx, msg)));
        }
Exemplo n.º 5
0
        ProcessResult WorkerLoopReceive(Process ctx, Object msg)
        {
            switch (msg)
            {
            case Tuple <Pid, Atom> tuple:
                Erl.Send(tuple.Item1, tuple.Item2);
                break;

            case Tuple <Pid, Int32> tuple:
                Erl.Send(tuple.Item1, tuple.Item2);
                break;

            case Tuple <Pid, Int64> tuple:
                Erl.Send(tuple.Item1, tuple.Item2);
                break;

            case Tuple <Pid, String> tuple:
                Erl.Send(tuple.Item1, tuple.Item2);
                break;

            case Tuple <Pid, Pid> tuple:
                Erl.Send(tuple.Item1, tuple.Item2);
                break;

            case Tuple <Pid, Tuple <Int32, Int32> > tuple:
                Erl.Send(tuple.Item1, tuple.Item2);
                break;

            case Tuple <Pid, Tuple <Int32, String> > tuple:
                Erl.Send(tuple.Item1, tuple.Item2);
                break;

            case Tuple <Pid, Tuple <Int32, Int32, Int32> > tuple:
                Erl.Send(tuple.Item1, tuple.Item2);
                break;

            case Tuple <Pid, Tuple <Int32, String, Pid> > tuple:
                Erl.Send(tuple.Item1, tuple.Item2);
                break;

            default:
                Console.WriteLine("Unexpected message received in test");
                break;
            }
            return(ctx.Receive <Object>(WorkerLoopReceive));
        }
Exemplo n.º 6
0
 ProcessResult WorkerLoopReceive(Process ctx, OurCoolRecord msg)
 {
     Erl.Send(msg.Owner, msg);
     return(ctx.Finish(Erl.MakeAtom("ok")));
 }