public override IEnumerable<SlideBlock> BuildUp(BuildUpContext context, IImmutableSet<string> filesInProgress)
{
if (filesInProgress.Contains(File))
throw new Exception("Cyclic dependency");
var xmlStream = new StringReader(context.FileSystem.GetContent(File));
var serializer = new XmlSerializer(typeof(SlideBlock[]));
var slideBlocks = (SlideBlock[])serializer.Deserialize(xmlStream);
var newInProgress = filesInProgress.Add(File);
return slideBlocks.SelectMany(b => b.BuildUp(context, newInProgress));
}
public Item Bet(Address bettor)
{
return(Bettors.Contains(bettor)
? this
: new Item(Stake, Bettors.Add(bettor)));
}
private void HandleCoordinatorMessage(PersistentShardCoordinator.ICoordinatorMessage message)
{
if (message is PersistentShardCoordinator.HostShard)
{
var shard = ((PersistentShardCoordinator.HostShard)message).Shard;
Log.Debug("Host shard [{0}]", shard);
RegionByShard = RegionByShard.SetItem(shard, Self);
UpdateRegionShards(Self, shard);
// Start the shard, if already started this does nothing
GetShard(shard);
Sender.Tell(new PersistentShardCoordinator.ShardStarted(shard));
}
else if (message is PersistentShardCoordinator.ShardHome)
{
var home = (PersistentShardCoordinator.ShardHome)message;
Log.Debug("Shard [{0}] located at [{1}]", home.Shard, home.Ref);
IActorRef region;
if (RegionByShard.TryGetValue(home.Shard, out region))
{
if (region.Equals(Self) && !home.Ref.Equals(Self))
{
// should not happen, inconsistency between ShardRegion and PersistentShardCoordinator
throw new IllegalStateException(string.Format("Unexpected change of shard [{0}] from self to [{1}]", home.Shard, home.Ref));
}
}
RegionByShard = RegionByShard.SetItem(home.Shard, home.Ref);
UpdateRegionShards(home.Ref, home.Shard);
if (!home.Ref.Equals(Self))
{
Context.Watch(home.Ref);
}
if (home.Ref.Equals(Self))
{
var shardRef = GetShard(home.Shard);
if (!Equals(shardRef, ActorRefs.Nobody))
{
DeliverBufferedMessage(home.Shard, shardRef);
}
}
else
{
DeliverBufferedMessage(home.Shard, home.Ref);
}
}
else if (message is PersistentShardCoordinator.RegisterAck)
{
_coordinator = ((PersistentShardCoordinator.RegisterAck)message).Coordinator;
Context.Watch(_coordinator);
RequestShardBufferHomes();
}
else if (message is PersistentShardCoordinator.BeginHandOff)
{
var shard = ((PersistentShardCoordinator.BeginHandOff)message).Shard;
Log.Debug("Begin hand off shard [{0}]", shard);
IActorRef regionRef;
if (RegionByShard.TryGetValue(shard, out regionRef))
{
IImmutableSet <ShardId> updatedShards;
if (!Regions.TryGetValue(regionRef, out updatedShards))
{
updatedShards = ImmutableHashSet <ShardId> .Empty;
}
updatedShards = updatedShards.Remove(shard);
if (updatedShards.Count == 0)
{
Regions = Regions.Remove(regionRef);
}
else
{
Regions = Regions.SetItem(regionRef, updatedShards);
}
RegionByShard = RegionByShard.Remove(shard);
}
Sender.Tell(new PersistentShardCoordinator.BeginHandOffAck(shard));
}
else if (message is PersistentShardCoordinator.HandOff)
{
var shard = ((PersistentShardCoordinator.HandOff)message).Shard;
Log.Debug("Hand off shard [{0}]", shard);
// must drop requests that came in between the BeginHandOff and now,
// because they might be forwarded from other regions and there
// is a risk or message re-ordering otherwise
if (ShardBuffers.ContainsKey(shard))
{
ShardBuffers = ShardBuffers.Remove(shard);
_loggedFullBufferWarning = false;
}
IActorRef actorRef;
if (Shards.TryGetValue(shard, out actorRef))
{
HandingOff = HandingOff.Add(actorRef);
actorRef.Forward(message);
}
else
{
Sender.Tell(new PersistentShardCoordinator.ShardStopped(shard));
}
}
else
{
Unhandled(message);
}
}
/// <summary>
/// TBD
/// </summary>
/// <param name="e">TBD</param>
/// <exception cref="ArgumentException">TBD</exception>
/// <returns>TBD</returns>
public State Updated(IDomainEvent e)
{
if (e is ShardRegionRegistered)
{
var message = e as ShardRegionRegistered;
if (Regions.ContainsKey(message.Region))
{
throw new ArgumentException($"Region {message.Region} is already registered", nameof(e));
}
return(Copy(regions: Regions.SetItem(message.Region, ImmutableList <ShardId> .Empty)));
}
if (e is ShardRegionProxyRegistered)
{
var message = e as ShardRegionProxyRegistered;
if (RegionProxies.Contains(message.RegionProxy))
{
throw new ArgumentException($"Region proxy {message.RegionProxy} is already registered", nameof(e));
}
return(Copy(regionProxies: RegionProxies.Add(message.RegionProxy)));
}
if (e is ShardRegionTerminated)
{
var message = e as ShardRegionTerminated;
if (!Regions.TryGetValue(message.Region, out var shardRegions))
{
throw new ArgumentException($"Terminated region {message.Region} not registered", nameof(e));
}
var newUnallocatedShards = RememberEntities ? UnallocatedShards.Union(shardRegions) : UnallocatedShards;
return(Copy(
regions: Regions.Remove(message.Region),
shards: Shards.RemoveRange(shardRegions),
unallocatedShards: newUnallocatedShards));
}
if (e is ShardRegionProxyTerminated)
{
var message = e as ShardRegionProxyTerminated;
if (!RegionProxies.Contains(message.RegionProxy))
{
throw new ArgumentException($"Terminated region proxy {message.RegionProxy} not registered", nameof(e));
}
return(Copy(regionProxies: RegionProxies.Remove(message.RegionProxy)));
}
if (e is ShardHomeAllocated)
{
var message = e as ShardHomeAllocated;
if (!Regions.TryGetValue(message.Region, out var shardRegions))
{
throw new ArgumentException($"Region {message.Region} not registered", nameof(e));
}
if (Shards.ContainsKey(message.Shard))
{
throw new ArgumentException($"Shard {message.Shard} is already allocated", nameof(e));
}
var newUnallocatedShards = RememberEntities ? UnallocatedShards.Remove(message.Shard) : UnallocatedShards;
return(Copy(
shards: Shards.SetItem(message.Shard, message.Region),
regions: Regions.SetItem(message.Region, shardRegions.Add(message.Shard)),
unallocatedShards: newUnallocatedShards));
}
if (e is ShardHomeDeallocated)
{
var message = e as ShardHomeDeallocated;
if (!Shards.TryGetValue(message.Shard, out var region))
{
throw new ArgumentException($"Shard {message.Shard} not allocated", nameof(e));
}
if (!Regions.TryGetValue(region, out var shardRegions))
{
throw new ArgumentException($"Region {region} for shard {message.Shard} not registered", nameof(e));
}
var newUnallocatedShards = RememberEntities ? UnallocatedShards.Add(message.Shard) : UnallocatedShards;
return(Copy(
shards: Shards.Remove(message.Shard),
regions: Regions.SetItem(region, shardRegions.Where(s => s != message.Shard).ToImmutableList()),
unallocatedShards: newUnallocatedShards));
}
return(this);
}
public Task Merge([NotNull] DocumentInfo document, [NotNull] IEnumerable <string> indexWords)
{
if (document == null)
{
throw new ArgumentNullException("document");
}
if (indexWords == null)
{
throw new ArgumentNullException("indexWords");
}
var sourceWords = new SortedSet <string>(indexWords, wordComparer).ToList();
bool hasWords = sourceWords.Any();
var singleDocumentList = ImmutableHashSet.Create(document);
// Merge join sorted word list with wordIndex list
lock (lockIndex)
{
IImmutableSet <DocumentInfo> oldDocuments = state.documents;
IImmutableSet <DocumentInfo> newDocuments;
bool isNewDocument;
if (hasWords)
{
newDocuments = oldDocuments.Add(document);
isNewDocument = newDocuments != oldDocuments; // new if was added to document set
}
else
{
newDocuments = oldDocuments.Remove(document);
isNewDocument = newDocuments == oldDocuments; // new if wasn't contained before in document set
if (isNewDocument)
{
return(CompletedTask.Instance);
}
}
var oldIndex = state.wordIndex;
var newIndex = new InternalSortedList <string, IImmutableSet <DocumentInfo> >(this.wordComparer, oldIndex.Count + sourceWords.Count);
int idxSource = 0;
int idxTarget = 0;
while (true)
{
int compareResult = 0;
if (idxTarget >= oldIndex.Count)
{
compareResult = -1;
}
if (idxSource >= sourceWords.Count)
{
if (compareResult != 0)
{
break;
}
compareResult = 1;
}
if (compareResult == 0)
{
compareResult = wordComparer.Compare(sourceWords[idxSource], oldIndex[idxTarget].Key);
}
if (compareResult < 0)
{
// add and include
newIndex.AddSorted(sourceWords[idxSource], singleDocumentList);
idxSource += 1;
//idxTarget += 1;
}
else if (compareResult > 0)
{
var item = oldIndex[idxTarget];
if (!isNewDocument)
{
var newValue = item.Value.Remove(document);
if (newValue.Count > 0)
{
newIndex.AddSorted(item.Key, newValue);
}
}
else
{
newIndex.AddSorted(item.Key, item.Value);
}
idxTarget += 1;
}
else
{
var item = oldIndex[idxTarget];
newIndex.AddSorted(item.Key, item.Value.Add(document));
idxSource += 1;
idxTarget += 1;
}
}
this.state = new State(newIndex, newDocuments);
}
return(CompletedTask.Instance);
}
/// <summary>
/// TBD
/// </summary>
/// <param name="e">TBD</param>
/// <exception cref="ArgumentException">TBD</exception>
/// <returns>TBD</returns>
public State Updated(IDomainEvent e)
{
if (e is ShardRegionRegistered)
{
var message = e as ShardRegionRegistered;
if (Regions.ContainsKey(message.Region))
{
throw new ArgumentException($"Region {message.Region} is already registered", nameof(e));
}
return(Copy(regions: Regions.SetItem(message.Region, ImmutableList <ShardId> .Empty)));
}
else if (e is ShardRegionProxyRegistered)
{
var message = e as ShardRegionProxyRegistered;
if (RegionProxies.Contains(message.RegionProxy))
{
throw new ArgumentException($"Region proxy {message.RegionProxy} is already registered", nameof(e));
}
return(Copy(regionProxies: RegionProxies.Add(message.RegionProxy)));
}
else if (e is ShardRegionTerminated)
{
IImmutableList <ShardId> shardRegions;
var message = e as ShardRegionTerminated;
if (!Regions.TryGetValue(message.Region, out shardRegions))
{
throw new ArgumentException($"Region {message.Region} not registered", nameof(e));
}
return(Copy(
regions: Regions.Remove(message.Region),
shards: Shards.RemoveRange(shardRegions),
unallocatedShards: shardRegions.Aggregate(UnallocatedShards, (set, shard) => set.Add(shard))));
}
else if (e is ShardRegionProxyTerminated)
{
var message = e as ShardRegionProxyTerminated;
if (!RegionProxies.Contains(message.RegionProxy))
{
throw new ArgumentException($"Region proxy {message.RegionProxy} not registered", nameof(e));
}
return(Copy(regionProxies: RegionProxies.Remove(message.RegionProxy)));
}
else if (e is ShardHomeAllocated)
{
IImmutableList <ShardId> shardRegions;
var message = e as ShardHomeAllocated;
if (!Regions.TryGetValue(message.Region, out shardRegions))
{
throw new ArgumentException($"Region {message.Region} not registered", nameof(e));
}
if (Shards.ContainsKey(message.Shard))
{
throw new ArgumentException($"Shard {message.Shard} is already allocated", nameof(e));
}
return(Copy(
shards: Shards.SetItem(message.Shard, message.Region),
regions: Regions.SetItem(message.Region, shardRegions.Add(message.Shard)),
unallocatedShards: UnallocatedShards.Remove(message.Shard)));
}
else if (e is ShardHomeDeallocated)
{
IActorRef region;
IImmutableList <ShardId> shardRegions;
var message = e as ShardHomeDeallocated;
if (!Shards.TryGetValue(message.Shard, out region))
{
throw new ArgumentException($"Shard {message.Shard} not allocated", nameof(e));
}
if (!Regions.TryGetValue(region, out shardRegions))
{
throw new ArgumentException($"Region {region} for shard {message.Shard} not registered", nameof(e));
}
return(Copy(
shards: Shards.Remove(message.Shard),
regions: Regions.SetItem(region, shardRegions.Where(s => s != message.Shard).ToImmutableList()),
unallocatedShards: UnallocatedShards.Add(message.Shard)));
}
else
{
return(this);
}
}
private Tuple <ImmutableList <Rule>, RecursionProblem> CheckForProblematicLeftRecursion(
ImmutableList <Rule> context,
IImmutableSet <Rule> visited,
RecursionProblem problem)
{
var rule = context[context.Count - 1];
// avoid infinite recursion
if (visited.Contains(rule))
{
return(null);
}
var produced = context[0].Produced;
var newVisited = visited.Add(rule);
var currentProblem = problem;
for (var i = 0; i < rule.Symbols.Count; ++i)
{
var symbol = rule.Symbols[i] as NonTerminal;
if (symbol == null)
{
break;
}
// found left recursion
if (symbol == produced)
{
if (currentProblem != RecursionProblem.None)
{
return(Tuple.Create(context, currentProblem));
}
// otherwise, we don't need to recurse but we still need to check hidden
}
else
{
// otherwise, recurse on each rule
var isAlias = this.IsAliasOf(symbol, produced) || this.IsAliasOf(produced, symbol);
foreach (var symbolRule in this.rulesByProduced[symbol])
{
var result = this.CheckForProblematicLeftRecursion(
context.Add(symbolRule),
newVisited,
currentProblem | (isAlias ? RecursionProblem.None : RecursionProblem.Indirect)
);
if (result != null)
{
return(result);
}
}
}
// continue past the symbol if it's nullable. Once we do this we're in the realm of hidden left recursion
if (!this.firstFollow.IsNullable(symbol))
{
break;
}
currentProblem |= RecursionProblem.Hidden;
}
// if we reach here without returning, we found nothing
return(null);
}
public SetDomain <T> With(T elem)
{
return(new SetDomain <T> (set.Add(elem)));
}
public static Block <PolymorphicAction <ActionBase> > MineGenesisBlock(
IDictionary <string, string> tableSheets,
GoldDistribution[] goldDistributions,
PendingActivationState[] pendingActivationStates,
AdminState adminState,
AuthorizedMinersState authorizedMinersState = null,
IImmutableSet <Address> activatedAccounts = null,
bool isActivateAdminAddress = false,
IEnumerable <string> credits = null,
PrivateKey privateKey = null,
DateTimeOffset?timestamp = null
)
{
if (!tableSheets.TryGetValue(nameof(GameConfigSheet), out var csv))
{
throw new KeyNotFoundException(nameof(GameConfigSheet));
}
var gameConfigState = new GameConfigState(csv);
var redeemCodeListSheet = new RedeemCodeListSheet();
redeemCodeListSheet.Set(tableSheets[nameof(RedeemCodeListSheet)]);
if (privateKey is null)
{
privateKey = new PrivateKey();
}
var ncg = new Currency("NCG", 2, privateKey.ToAddress());
activatedAccounts = activatedAccounts ?? ImmutableHashSet <Address> .Empty;
var initialStatesAction = new InitializeStates
(
rankingState: new RankingState(),
shopState: new ShopState(),
tableSheets: (Dictionary <string, string>)tableSheets,
gameConfigState: gameConfigState,
redeemCodeState: new RedeemCodeState(redeemCodeListSheet),
adminAddressState: adminState,
activatedAccountsState: new ActivatedAccountsState(
isActivateAdminAddress
? activatedAccounts.Add(adminState.AdminAddress)
: activatedAccounts),
goldCurrencyState: new GoldCurrencyState(ncg),
goldDistributions: goldDistributions,
pendingActivationStates: pendingActivationStates,
authorizedMinersState: authorizedMinersState,
creditsState: credits is null ? null : new CreditsState(credits)
);
var actions = new PolymorphicAction <ActionBase>[]
{
initialStatesAction,
};
var blockAction = new BlockPolicySource(Log.Logger).GetPolicy().BlockAction;
return
(BlockChain <PolymorphicAction <ActionBase> > .MakeGenesisBlock(
HashAlgorithmType.Of <SHA256>(),
actions,
privateKey : privateKey,
blockAction : blockAction,
timestamp : timestamp));
}
public override ChildrenContainer ShallDie(ActorRef actor)
{
return(new TerminatingChildrenContainer(InternalChildren, _toDie.Add(actor), _reason));
}