public async Task <bool> TryAddStateAsync <T>(string stateName, T value, CancellationToken cancellationToken)
{
Requires.Argument("stateName", stateName).NotNull();
if (this.stateChangeTracker.ContainsKey(stateName))
{
var stateMetadata = this.stateChangeTracker[stateName];
// Check if the property was marked as remove in the cache
if (stateMetadata.ChangeKind == StateChangeKind.Remove)
{
this.stateChangeTracker[stateName] = StateMetadata.Create(value, StateChangeKind.Update);
return(true);
}
return(false);
}
if (await this.stateProvider.ContainsStateAsync(this.actor.Id, stateName, cancellationToken))
{
return(false);
}
this.stateChangeTracker[stateName] = StateMetadata.Create(value, StateChangeKind.Add);
return(true);
}
public async Task <bool> TryRemoveStateAsync(string stateName, CancellationToken cancellationToken)
{
ArgumentVerifier.ThrowIfNull(stateName, nameof(stateName));
EnsureStateProviderInitialized();
if (this.stateChangeTracker.ContainsKey(stateName))
{
var stateMetadata = this.stateChangeTracker[stateName];
switch (stateMetadata.ChangeKind)
{
case StateChangeKind.Remove:
return(false);
case StateChangeKind.Add:
this.stateChangeTracker.Remove(stateName);
return(true);
}
stateMetadata.ChangeKind = StateChangeKind.Remove;
return(true);
}
if (await this.actor.Host.StateProvider.ContainsStateAsync(this.actorTypeName, this.actor.Id.ToString(), stateName, cancellationToken))
{
this.stateChangeTracker.Add(stateName, StateMetadata.CreateForRemove());
return(true);
}
return(false);
}
public async Task SetStateAsync <T>(string stateName, T value, CancellationToken cancellationToken)
{
ArgumentVerifier.ThrowIfNull(stateName, nameof(stateName));
EnsureStateProviderInitialized();
if (this.stateChangeTracker.ContainsKey(stateName))
{
var stateMetadata = this.stateChangeTracker[stateName];
stateMetadata.Value = value;
if (stateMetadata.ChangeKind == StateChangeKind.None ||
stateMetadata.ChangeKind == StateChangeKind.Remove)
{
stateMetadata.ChangeKind = StateChangeKind.Update;
}
}
else if (await this.actor.Host.StateProvider.ContainsStateAsync(this.actorTypeName, this.actor.Id.ToString(), stateName, cancellationToken))
{
this.stateChangeTracker.Add(stateName, StateMetadata.Create(value, StateChangeKind.Update));
}
else
{
this.stateChangeTracker[stateName] = StateMetadata.Create(value, StateChangeKind.Add);
}
}
public async Task SetStateAsync <T>(string stateName, T value, CancellationToken cancellationToken)
{
this.ThrowIfClosed();
Requires.Argument("stateName", stateName).NotNull();
if (this.stateChangeTracker.ContainsKey(stateName))
{
var stateMetadata = this.stateChangeTracker[stateName];
stateMetadata.Value = value;
if (stateMetadata.ChangeKind == StateChangeKind.None ||
stateMetadata.ChangeKind == StateChangeKind.Remove)
{
stateMetadata.ChangeKind = StateChangeKind.Update;
}
}
else if (await this.stateProvider.ContainsStateAsync(this.actor.Id, stateName, cancellationToken))
{
this.stateChangeTracker.Add(stateName, StateMetadata.Create(value, StateChangeKind.Update));
}
else
{
this.stateChangeTracker[stateName] = StateMetadata.Create(value, StateChangeKind.Add);
}
}
public GenotypeState(StateMetadata metadata) : base(metadata)
{
YTK = Convert.ToByte(metadata["YTK"]);
SetGenom(metadata["Genom"]);
direction = Directions.None;
action = Actions.None;
}
public async Task <bool> TryAddStateAsync <T>(string stateName, T value, CancellationToken cancellationToken)
{
ArgumentVerifier.ThrowIfNull(stateName, nameof(stateName));
EnsureStateProviderInitialized();
if (this.stateChangeTracker.ContainsKey(stateName))
{
var stateMetadata = this.stateChangeTracker[stateName];
// Check if the property was marked as remove in the cache
if (stateMetadata.ChangeKind == StateChangeKind.Remove)
{
this.stateChangeTracker[stateName] = StateMetadata.Create(value, StateChangeKind.Update);
return(true);
}
return(false);
}
if (await this.actor.Host.StateProvider.ContainsStateAsync(this.actorTypeName, this.actor.Id.ToString(), stateName, cancellationToken))
{
return(false);
}
this.stateChangeTracker[stateName] = StateMetadata.Create(value, StateChangeKind.Add);
return(true);
}
public async Task <bool> TryRemoveStateAsync(string stateName, CancellationToken cancellationToken)
{
Requires.Argument("stateName", stateName).NotNull();
if (this.stateChangeTracker.ContainsKey(stateName))
{
var stateMetadata = this.stateChangeTracker[stateName];
switch (stateMetadata.ChangeKind)
{
case StateChangeKind.Remove:
return(false);
case StateChangeKind.Add:
this.stateChangeTracker.Remove(stateName);
return(true);
}
stateMetadata.ChangeKind = StateChangeKind.Remove;
return(true);
}
if (await this.stateProvider.ContainsStateAsync(this.actor.Id, stateName, cancellationToken))
{
this.stateChangeTracker.Add(stateName, StateMetadata.CreateForRemove());
return(true);
}
return(false);
}
public async Task <ConditionalValue <T> > TryGetStateAsync <T>(string stateName, CancellationToken cancellationToken)
{
ArgumentVerifier.ThrowIfNull(stateName, nameof(stateName));
EnsureStateProviderInitialized();
if (this.stateChangeTracker.ContainsKey(stateName))
{
var stateMetadata = this.stateChangeTracker[stateName];
// Check if the property was marked as remove in the cache
if (stateMetadata.ChangeKind == StateChangeKind.Remove)
{
return(new ConditionalValue <T>(false, default));
}
return(new ConditionalValue <T>(true, (T)stateMetadata.Value));
}
var conditionalResult = await this.TryGetStateFromStateProviderAsync <T>(stateName, cancellationToken);
if (conditionalResult.HasValue)
{
this.stateChangeTracker.Add(stateName, StateMetadata.Create(conditionalResult.Value, StateChangeKind.None));
}
return(conditionalResult);
}
/// <summary>
/// Формирует метаданные цвета формы жизни
/// </summary>
/// <returns></returns>
public override StateMetadata GetMetadata()
{
StateMetadata stateMetadata = base.GetMetadata();
stateMetadata.Add("Color", $"{R} {G} {B}");
stateMetadata.Add("ColorType", _colorType.ToString());
return(stateMetadata);
}
/// <summary>
/// Определяет, оказывает ли феномен воздействие на форму жизни и возвращает
/// результат этого воздействия
/// </summary>
/// <param name="point">Точка</param>
/// <param name="lifeFormMetadataMetadata">метаданные форммы жизни, находящейся в этой точке</param>
/// <returns>Эффект воздействия феномена</returns>
public List <StateMetadata> GetEffects(Point point, LifeFormMetadata lifeFormMetadataMetadata)
{
log.Trace(LogPhenomenMessages.PhenomenGetEffects, "SunPhenomen", point.X, point.Y);
if (point == null)
{
ArgumentException ex = new ArgumentNullException(nameof(point));
log.Error(LogPhenomenMessages.NullArgument, "Point", ex);
throw ex;
}
if (lifeFormMetadataMetadata == null)
{
ArgumentNullException ex = new ArgumentNullException(nameof(lifeFormMetadataMetadata));
log.Error(LogPhenomenMessages.NullArgument, "LifeFormMetadata", ex);
throw ex;
}
if (!isIn(point))
{
ArgumentException ex = new ArgumentException("Point isn't in phenomen area.", nameof(point));
log.Error(LogPhenomenMessages.PointNotFound);
throw ex;
}
if (!lifeFormMetadataMetadata.ContainsKey("GenotypeState"))
{
ArgumentException ex = new ArgumentException("life form metadata isn't contains Genotype state metadata", nameof(lifeFormMetadataMetadata));
log.Error(LogPhenomenMessages.GenotypeStateNotFound);
throw ex;
}
if (!lifeFormMetadataMetadata["GenotypeState"].ContainsKey("Action") ||
lifeFormMetadataMetadata["GenotypeState"]["Action"] != ActionPhotosynthesisName)
{
log.Info(LogPhenomenMessages.GenotypeStateAction);
return(new List <StateMetadata>(0));
}
double depthFactor = 1 / (1 + (point.Y - _place[0].Y) / _place[1].Y);
log.Info(LogPhenomenMessages.DepthFactorCalc, depthFactor.ToString());
StateMetadata stateMetadata = new StateMetadata("EnergyState", BaseIntensity * _powerFactor * depthFactor, null);
List <StateMetadata> ret = new List <StateMetadata>(1);
ret.Add(stateMetadata);
log.Trace(LogPhenomenMessages.EndMethod, "SunPhenomen.GetEffects");
return(ret);
}
public List<ChaincodeMessage> Next()
{
List<StateMetadata> entriesList = new List<StateMetadata>();
StateMetadata validationValue = new StateMetadata {Metakey = ChaincodeStub.VALIDATION_PARAMETER, Value = ByteString.CopyFrom(val)};
entriesList.Add(validationValue);
StateMetadataResult stateMetadataResult = new StateMetadataResult();
stateMetadataResult.Entries.AddRange(entriesList);
List<ChaincodeMessage> list = new List<ChaincodeMessage>();
list.Add(new ChaincodeMessage {Type = ChaincodeMessage.Types.Type.Response, ChannelId = orgMsg.ChannelId, Txid = orgMsg.Txid, Payload = stateMetadataResult.ToByteString()});
return list;
}
public ColorState(StateMetadata metadata) : base(metadata)
{
byte[] bytes = metadata["Color"].Split(' ').Select(x => byte.Parse(x)).ToArray();
R = bytes[0];
G = bytes[1];
B = bytes[2];
if (!Enum.TryParse(metadata["ColorType"], out this._colorType))
{
throw new ArgumentException("Недопустимое знчение metadata[\"ColorType\"]", metadata["ColorType"]);
}
}
public async Task <T> GetOrAddStateAsync <T>(string stateName, T value, CancellationToken cancellationToken)
{
var condRes = await this.TryGetStateAsync <T>(stateName, cancellationToken);
if (condRes.HasValue)
{
return(condRes.Value);
}
var changeKind = this.IsStateMarkedForRemove(stateName) ? StateChangeKind.Update : StateChangeKind.Add;
this.stateChangeTracker[stateName] = StateMetadata.Create(value, changeKind);
return(value);
}
public void test()
{
var context = MachineContext.Create(b => b
.RegisterIdentities(typeof(UserId) /*, typeof(SuperUserId)*/)
);
var metadata = new StateMetadata();
metadata.ProcessId = new UserId()
{
Value = "hello"
};
var bytes = ProtobufSerializer.SerializeProtocalBuffer(metadata, context.Serializer.Model);
var back = ProtobufSerializer.DeserializeProtocalBuffer <StateMetadata>(bytes, context.Serializer.Model);
}
public async Task <T> AddOrUpdateStateAsync <T>(
string stateName,
T addValue,
Func <string, T, T> updateValueFactory,
CancellationToken cancellationToken = default)
{
ArgumentVerifier.ThrowIfNull(stateName, nameof(stateName));
EnsureStateProviderInitialized();
if (this.stateChangeTracker.ContainsKey(stateName))
{
var stateMetadata = this.stateChangeTracker[stateName];
// Check if the property was marked as remove in the cache
if (stateMetadata.ChangeKind == StateChangeKind.Remove)
{
this.stateChangeTracker[stateName] = StateMetadata.Create(addValue, StateChangeKind.Update);
return(addValue);
}
var newValue = updateValueFactory.Invoke(stateName, (T)stateMetadata.Value);
stateMetadata.Value = newValue;
if (stateMetadata.ChangeKind == StateChangeKind.None)
{
stateMetadata.ChangeKind = StateChangeKind.Update;
}
return(newValue);
}
var conditionalResult = await this.TryGetStateFromStateProviderAsync <T>(stateName, cancellationToken);
if (conditionalResult.HasValue)
{
var newValue = updateValueFactory.Invoke(stateName, conditionalResult.Value);
this.stateChangeTracker.Add(stateName, StateMetadata.Create(newValue, StateChangeKind.Update));
return(newValue);
}
this.stateChangeTracker[stateName] = StateMetadata.Create(addValue, StateChangeKind.Add);
return(addValue);
}
public void SetMetadata_Should_UpdateStateMetadata()
{
var metadata = new StateMetadata
{
Value = State.Ok.Value,
Priority = 1,
Icon = "icon",
Color = "color",
DisplayName = "name",
};
var metadataCollection = new StateMetadata[] { metadata };
State.SetMetadata(metadataCollection);
Assert.AreEqual(metadataCollection[0].Icon, State.Ok.Metadata.Icon);
Assert.AreEqual(metadataCollection[0].Color, State.Ok.Metadata.Color);
Assert.AreEqual(metadataCollection[0].Value, State.Ok.Metadata.Value);
Assert.AreEqual(metadataCollection[0].Priority, State.Ok.Metadata.Priority);
Assert.AreEqual(metadataCollection[0].DisplayName, State.Ok.Metadata.DisplayName);
}
public override StateMetadata GetMetadata()
{
string strGenom = "";
StateMetadata stateMetadata = base.GetMetadata();
if (action == Actions.Move || action == Actions.CheckEnergy ||
action == Actions.Eat || action == Actions.DoDescendant)
{
stateMetadata.Add("Action", action.ToString() + "|" + direction.ToString());
}
else
{
stateMetadata.Add("Action", action.ToString());
}
foreach (byte b in genom)
{
strGenom += b.ToString() + "|";
}
stateMetadata.Add("Genom", "" + strGenom);
stateMetadata.Add("YTK", YTK.ToString());
return(stateMetadata);
}
