public BoardState Apply(BoardState state, Turn turn)
{
CheckArg.NotNull(state);
CheckArg.NotNull(turn);
if (turn is not Move move)
{
throw new NotSupportedException();
}
var(f, c) = state[move.From] ?? throw new UserErrorException($"There are no figure at {move.From}");
if (move.From == move.To)
{
throw new RuleViolationError(new RuleViolation("Figure can't move to the same cell"));
}
state = state.Without(move.From);
if (state[move.To].HasValue)
{
state = state.Without(move.To);
}
return(state.With(f, c, move.To));
}
public static long HashAddress(string anAddress)
{
CheckArg.Address(anAddress);
var hash = anAddress.GetHashCode();
return(hash);
}
private void GetEntries(IActor actor)
{
CheckArg.Actor(actor);
var entries = fUri2Actor.Keys.AsEnumerable <string>();
actor.SendMessage(entries);
}
public void Behavior(IActor actor, MemoryStream stream)
{
CheckArg.Actor(actor);
// divide object in chunk
int chunkSize = 2048;
int memSize = stream.Capacity;
int pos = 0;
int chunknumber = 0;
List <Chunk> chunkList = new List <Chunk>();
stream.Seek(0, SeekOrigin.Begin);
while (pos < memSize)
{
Chunk chk = new Chunk();
int currChunkSize = Math.Min(chunkSize, memSize - pos + 1);
chk.chunkPart = chunknumber++;
chk.data = new byte[currChunkSize];
stream.Read(chk.data, 0, currChunkSize);
pos += currChunkSize;
chunkList.Add(chk);
}
chunkList.OrderBy(t => t.chunkPart).Last().last = true;
foreach (var item in chunkList)
{
actor.SendMessage(item);
}
}
public override BoardState ReadJson(JsonReader reader, Type objectType, BoardState?existingValue, bool hasExistingValue, JsonSerializer serializer)
{
CheckArg.NotNull(reader);
CheckArg.NotNull(serializer);
var bs = BoardState.Empty;
reader.EnsureStartObject();
while (reader.EnsureRead() != JsonToken.EndObject)
{
var cellStr = reader.EnsureProperty();
var cell = Cell.Parse(cellStr);
reader.EnsureRead();
reader.EnsureStartObject();
reader.EnsureRead();
reader.EnsureProperty(nameof(Figure));
reader.EnsureRead();
var figure = serializer.Deserialize <Figure>(reader);
reader.EnsureRead();
reader.EnsureProperty(nameof(Color));
reader.EnsureRead();
var color = serializer.Deserialize <Color>(reader);
reader.EnsureRead();
reader.EnsureEndObject();
bs = bs.With(figure, color, cell);
}
return(bs);
}
public static IFuture <string> Retrieve(this IActor actor)
{
CheckArg.Actor(actor);
IFuture <string> future = new Future <string>();
actor.SendMessage(future);
return(future);
}
public static string RetrieveSync(this IActor actor)
{
CheckArg.Actor(actor);
IFuture <string> future = new Future <string>();
actor.SendMessage(future);
return(future.Result());
}
public void Launch(IActor asker, IndexRouter router)
{
CheckArg.Actor(router);
var response = new Response(router, asker, this);
Become(new Behavior <Response>(r => DoProcessQuery(r)));
SendMessage(response);
}
public RuleViolation?Check(BoardState state, Turn turn)
{
CheckArg.NotNull(state);
CheckArg.NotNull(turn);
// TODO: just "everything is correct" yet
return(null);
}
public Buffer(IEnumerable <Consumer <T> > someConsumers) : base("BufferEmpty", null)
{
CheckArg.IEnumerable(someConsumers);
foreach (var item in someConsumers)
{
ConsList.Enqueue(item);
item.Buffer = this;
}
AddBehavior(new Behavior <Work <T> >(t =>
{
this.SendMessage(InternalCurrentState, t);
}
));
AddBehavior(new FsmBehavior <string, Work <T> >("BufferEmpty", "BufferNotEmpty",
t =>
{
if (ConsList.Count != 0)
{
var cons = ConsList.Dequeue();
cons.SendMessage(t);
}
else
{
WorkList.Enqueue(t);
}
}, t => true));
AddBehavior(new FsmBehavior <string, Work <T> >("BufferNotEmpty", "BufferNotEmpty",
t =>
{
if (ConsList.Count != 0)
{
var cons = ConsList.Dequeue();
cons.SendMessage(t);
}
else
{
WorkList.Enqueue(t);
}
},
t => WorkList.Count != 0));
AddBehavior(new Behavior <Consumer <T> >(t =>
{
if (WorkList.Count == 0)
{
ConsList.Enqueue(t);
InternalCurrentState = "BufferEmpty";
}
else
{
t.SendMessage(WorkList.Dequeue());
}
}));
}
public static DataContractObject DeSerialize(Stream inputStream)
{
CheckArg.Stream(inputStream);
inputStream.Seek(0, SeekOrigin.Begin);
IDataContractSurrogate dataContractSurrogate = new DataContractActorSurrogate();
DataContractSerializer dcs = new DataContractSerializer(typeof(DataContractObject), null, 1000, true, true, dataContractSurrogate);
return((DataContractObject)dcs.ReadObject(inputStream));
}
public DemoClient(BrokerActor <int> aBroker)
{
CheckArg.Actor(aBroker);
foreach (var item in Enumerable.Range(1, 10))
{
// aBroker.SendMessage(String.Format("Start Job {0}",item));
aBroker.SendMessage(item);
}
}
public void CheckArgReturnTest()
{
using (var stream = new MemoryStream())
{
CheckArg.Stream(stream);
}
try
{
CheckArg.Stream(null);
Assert.Fail();
}
catch (ActorException)
{
}
CheckArg.Address("My address");
try
{
CheckArg.Address(string.Empty);
Assert.Fail();
}
catch (ActorException)
{
}
CheckArg.Behaviors(new Actor.Base.Behaviors());
try
{
CheckArg.Behaviors(null);
Assert.Fail();
}
catch (ActorException)
{
}
CheckArg.Behavior(new Actor.Base.Behavior <string>());
try
{
CheckArg.Behavior(null);
Assert.Fail();
}
catch (ActorException)
{
}
CheckArg.Actor(new Actor.Base.BaseActor());
try
{
CheckArg.Actor(null);
Assert.Fail();
}
catch (ActorException)
{
}
}
public void SendStream(string host, Stream stream)
{
CheckArg.Stream(stream);
stream.Seek(0, SeekOrigin.Begin);
MemoryStream clone = new MemoryStream();
stream.CopyTo(clone);
clone.Seek(0, SeekOrigin.Begin);
_future.SendMessage((Stream)clone);
}
public static SerialObject DeSerialize(Stream inputStream)
{
CheckArg.Stream(inputStream);
inputStream.Seek(0, SeekOrigin.Begin);
NetDataContractSerializer dcs = new NetDataContractSerializer();
dcs.SurrogateSelector = new ActorSurrogatorSelector();
dcs.Binder = new ActorBinder();
return((SerialObject)dcs.ReadObject(inputStream));
}
public static async Task <string> Stat(IActor sender)
{
CheckArg.Actor(sender);
GetInstance().SendMessage((Action <IActor>)GetInstance().DoStat, sender);
var task = await HostDirectoryActor.GetInstance()
.Receive(ans => { return((ans is IActor) && (sender.Equals(((IActor)ans)))); });
return(task as string);
}
public static async Task <string> Stat(IActor sender)
{
CheckArg.Actor(sender);
GetInstance().SendMessage((Action <IActor>)GetInstance().DoStat, sender);
var task = await GetInstance()
.ReceiveAsync(ans => ans is IActor actor && (sender.Equals(actor))).ConfigureAwait(false);
return(task as string);
}
public static ShardDirectoryActor AttachShardDirectoryActor(ActorServer actorServer)
{
CheckArg.Actor(actorServer);
IActor shardFound = DirectoryActor.GetDirectory().GetActorByName("KnownShards");
if (shardFound != null)
{
return((ShardDirectoryActor)shardFound);
}
return(new ShardDirectoryActor(actorServer));
}
public void Bind(IPlayer implementation)
{
CheckArg.NotNull(implementation);
if (IsBound)
{
throw new InvalidOperationException("Adapter is already bound");
}
_implementation = implementation;
}
public static TKey Calc(IEnumerable <TKey> keys)
{
CheckArg.IEnumerable(keys);
var dic = new Dictionary <HashKey, TKey>();
foreach (var k in keys)
{
dic[HashKey.ComputeHash(k.ToString())] = k;
}
var elected = dic.Keys.OrderBy(h => h.ToString()).FirstOrDefault();
return(dic[elected]);
}
public ConsoleUI(GameFlow gameFlow, IConsoleIO console, IStorage storage, RulesEngine rulesEngine)
{
CheckArg.NotNull(gameFlow);
CheckArg.NotNull(console);
CheckArg.NotNull(storage);
CheckArg.NotNull(rulesEngine);
GameCmdHandler = new GameCmdHandler(gameFlow, storage, console);
TurnCmdHandler = new TurnCmdHandler(rulesEngine);
BoardPrinter = new BoardPrinter(console, gameFlow);
CommandParser = new CommandParser();
CommandCycle = new CommandCycle(console, GameCmdHandler, TurnCmdHandler, BoardPrinter, CommandParser);
}
public ShardDirectoryActor(ActorServer actorServer)
: base()
{
CheckArg.Actor(actorServer);
_shardList = new Dictionary <string, string>
{
{ "LocalHost", actorServer.FullHost }
};
DirectoryActor.GetDirectory().Register(this, "KnownShards");
HostDirectoryActor.Register(this);
Become(new Behavior <ShardRequest>(
t => t is ShardRequest,
DoProcessShardRequest));
}
public IEnumerable <Turn> GetPossibleTurns(BoardState state, Color playerColor)
{
CheckArg.NotNull(state);
foreach (var(cell, (_, color)) in state.Figures)
{
if (color == playerColor)
{
foreach (var t in GetPossibleTurns(state, cell))
{
yield return(t);
}
}
}
}
public static void Start(ActorConfigManager configManager)
{
CheckArg.ActorConfigManager(configManager);
ActorTagHelper.FullHost = configManager.Host().Host;
_serverInstance = new ActorServer
{
_configManager = configManager ?? throw new ActorException(MessageNullConfigManager),
Name = configManager.Host().Host,
Port = configManager.Host().Port
};
_serverInstance.ListenerService = configManager.GetListenerService();
_serverInstance.SerializeService = configManager.GetSerializeService();
_serverInstance.HostService = configManager.GetHostService();
_serverInstance.ServerCommandService = ActorConfigManager.GetServerCommandService();
_serverInstance.DoInit(new HostRelayActor(_serverInstance.ListenerService));
}
public override void WriteJson(JsonWriter writer, BoardState?value, JsonSerializer serializer)
{
CheckArg.NotNull(writer);
CheckArg.NotNull(value);
CheckArg.NotNull(serializer);
writer.WriteStartObject();
foreach (var(cell, (figure, color)) in value.Figures)
{
writer.WritePropertyName(cell.ToString());
writer.WriteStartObject();
writer.WritePropertyName(nameof(Figure));
serializer.Serialize(writer, figure);
writer.WritePropertyName(nameof(Color));
serializer.Serialize(writer, color);
writer.WriteEndObject();
}
writer.WriteEndObject();
}
public IEnumerable <Field> Launch(IndexRouter router)
{
CheckArg.Actor(router);
ConcurrentQueue <Field> bc = new ConcurrentQueue <Field>();
var spin = new SpinWait();
var asker = new BaseActor(new Behavior <string, IEnumerable <Field> >
(
(s, fs) =>
{
foreach (var item in fs)
{
bc.Enqueue(item);
}
ReceivedMsg++;
if (ReceivedMsg == 1)
{
Interlocked.Increment(ref streamStart);
}
if (ReceivedMsg >= TotalMsg)
{
Interlocked.Increment(ref streamEnd);
}
}
));
var response = new Response(router, asker, this);
Become(new Behavior <Response>(r => DoProcessQuery(r)));
SendMessage(response);
while (Interlocked.CompareExchange(ref streamStart, streamStart, 0) == 0)
{
spin.SpinOnce();
}
do
{
while (bc.TryDequeue(out Field field))
{
yield return(field);
}
;
spin.SpinOnce();
}while (Interlocked.CompareExchange(ref streamEnd, streamEnd, 0) == 0);
}
// TODO: SRE violation and logic duplication with CommandParser! CellParser should be extracted as well as Move/Turn Parser
public static Cell Parse(string s)
{
CheckArg.NotNull(s);
if (s.Length != 2)
{
throw new ArgumentOutOfRangeException(nameof(s));
}
char h = s[0];
int v = int.Parse(s[1].ToString(), NumberStyles.Integer, CultureInfo.InvariantCulture);
if (!IsValid(h, v))
{
throw new ArgumentOutOfRangeException(nameof(s), s, "Invalid cell value");
}
return(At(h, v));
}
public override Turn ReadJson(JsonReader reader, Type objectType, Turn?existingValue, bool hasExistingValue, JsonSerializer serializer)
{
CheckArg.NotNull(reader);
CheckArg.NotNull(serializer);
reader.EnsureStartObject();
reader.EnsureRead();
reader.EnsureProperty(nameof(Move.From));
var from = serializer.Deserialize <Cell>(reader);
reader.EnsureRead();
reader.EnsureProperty(nameof(Move.To));
var to = serializer.Deserialize <Cell>(reader);
reader.EnsureRead();
reader.EnsureEndObject();
return(new Move(from, to));
}
public void SendStream(string uri, Stream stream)
{
CheckArg.Stream(stream);
using (StreamReader srDebug = new StreamReader(stream))
{
while (!srDebug.EndOfStream)
{
Debug.Print(srDebug.ReadLine());
}
stream.Seek(0, SeekOrigin.Begin);
using (var client = new HttpClient())
{
using (var hc = new StreamContent(stream))
{
client.PostAsync(uri, hc).Wait();
}
}
}
}
public override void WriteJson(JsonWriter writer, Turn?value, JsonSerializer serializer)
{
CheckArg.NotNull(writer);
CheckArg.NotNull(value);
CheckArg.NotNull(serializer);
if (value is Move move)
{
writer.WriteStartObject();
writer.WritePropertyName(nameof(Move.From));
serializer.Serialize(writer, move.From);
writer.WritePropertyName(nameof(Move.To));
serializer.Serialize(writer, move.To);
writer.WriteEndObject();
}
else
{
throw new JsonSerializationException("Unsupported Turn kind");
}
}
