public async Task CustomBlockingObeyed() { var processor = CreateProcessor(); processor.Start(); // Start up the first task that won't complete until we're sure both tasks started var item1CompletionSource = new TaskCompletionSource <object>(); processor.Enqueue(testItemType, async _ => { await item1CompletionSource.Task; }); var didItem2Finish = false; var blockedType = new QueueItemType("blocked", 1, isBlocked: (_, type) => !processor.IsQueueIdle(testItemType)); var item2 = new QueueItem(blockedType, async _ => didItem2Finish = true); item2.StateChanged += (item, state) => { if (state == QueueItemState.Waiting) { item1CompletionSource.SetResult(null); } }; processor.Enqueue(item2); // Wait for everything to finish. await processor.WaitForIdle(); Assert.IsTrue(didItem2Finish); }
public QueueItem(QueueItemType type, string data) { Id = Guid.NewGuid(); Type = type; Data = data; QueueDate = DateTime.UtcNow; }
public ProductionQueueItem(QueueItemType type, int quantity, ShipDesign shipDesign, string fleetName) : base() { this.type = type; this.quantity = quantity; this.shipDesign = shipDesign; this.fleetName = fleetName; }
/// <summary> /// ClearQueueItems /// </summary> /// <param name="type"></param> public void ClearQueueItems(QueueItemType type) { switch (type) { case QueueItemType.QueueItems: case QueueItemType.AllItems: Q.Clear(); break; } }
public void Execute(IQueueable queueable, QueueItemType type) { using (var context = new QueueContext(_appSettingsService.ConnectionString)) { var queueItem = new QueueItem(type, JsonConvert.SerializeObject(queueable)); context.QueueItems.Add(queueItem); context.SaveChanges(); } }
bool productionQueueHasType(List <ProductionQueueItem> items, QueueItemType type) { bool result = false; foreach (ProductionQueueItem item in items) { result |= (item.getType() == type); } return(result); }
private FeedQueueItem GetQueueItem(VkGroup @group, QueueItemType dataFeedType) { FeedQueueItem item = new FeedQueueItem() { VkGroupId = @group.Id, QueueItemType = dataFeedType, CreationDate = this.dateTimeHelper.GetDateTimeNow(), }; return(item); }
public QueueItem(GameObject item, QueueItemType type) { this.item = item; buildTime = 15; elapsedBuildTime = 0; completed = false; itemType = type; if (type == QueueItemType.Building || type == QueueItemType.BuildingResources) { refundReturn = item.buyCost; } }
int productionQueueIndex(List <ProductionQueueItem> items, QueueItemType type) { int index = 0; foreach (ProductionQueueItem item in items) { if (item.getType() == type) { break; } index++; } return(index); }
public static LinkRest MakeQueueItemLink(QueueItemType itemType, Guid id) { string relation; switch (itemType) { case QueueItemType.Message: relation = RestRelations.MessageQueueItemRelation; break; default: throw new ArgumentOutOfRangeException(nameof(itemType), itemType, null); } return new LinkRest(relation, "/" + QueueItemUrl.Replace("{id:guid}", id.ToString())); }
/// <summary> /// AddQueueItemToInboundFrame /// Adds an RPC queue item to the outbound frame /// </summary> /// <param name="qItemType">type of rpc (client or server)</param> /// <param name="timeStamp">when it was received</param> /// <param name="sourceNetworkId">who sent the rpc</param> /// <param name="message">the message being received</param> internal void AddQueueItemToInboundFrame(QueueItemType qItemType, float timeStamp, ulong sourceNetworkId, NetworkBuffer message) { long originalPosition = message.Position; NetworkUpdateStage updateStage; using (var reader = PooledNetworkReader.Get(message)) { var longValue = reader.ReadUInt64Packed(); // NetworkObjectId (temporary, we reset position just below) var shortValue = reader.ReadUInt16Packed(); // NetworkBehaviourId (temporary, we reset position just below) updateStage = (NetworkUpdateStage)reader.ReadByteDirect(); } message.Position = originalPosition; var rpcQueueHistoryItem = GetQueueHistoryFrame(RpcQueueHistoryFrame.QueueFrameType.Inbound, updateStage); rpcQueueHistoryItem.IsDirty = true; long StartPosition = rpcQueueHistoryItem.QueueBuffer.Position; //Write the packed version of the queueItem to our current queue history buffer rpcQueueHistoryItem.QueueWriter.WriteUInt16((ushort)qItemType); rpcQueueHistoryItem.QueueWriter.WriteSingle(timeStamp); rpcQueueHistoryItem.QueueWriter.WriteUInt64(sourceNetworkId); //Inbound we copy the entire packet and store the position offset long streamSize = message.Length; rpcQueueHistoryItem.QueueWriter.WriteInt64(streamSize); rpcQueueHistoryItem.QueueWriter.WriteInt64(message.Position); rpcQueueHistoryItem.QueueWriter.WriteBytes(message.GetBuffer(), streamSize); //Add the packed size to the offsets for parsing over various entries rpcQueueHistoryItem.QueueItemOffsets.Add((uint)rpcQueueHistoryItem.QueueBuffer.Position); //Calculate the packed size based on stream progression rpcQueueHistoryItem.TotalSize += (uint)(rpcQueueHistoryItem.QueueBuffer.Position - StartPosition); }
public QueueItem(QueueItemType t, Vec2 pt, int button) { type = t; p.set(pt); this.button = button; }
public QueueItem(QueueItemType t) { type = t; }
public QueueItem() { type = QueueItemType.LaunchBomb; }
/** * Add a ship that is to be built into a fleet to the Planet's ProductionQueue */ public void addQueueItem(QueueItemType type, int quantity, ShipDesign shipDesign, string fleetName) { queue.getItems().Add(new ProductionQueueItem(type, quantity, shipDesign, fleetName)); }
/** * Add an item to the Planet's ProductionQueue */ public void addQueueItem(QueueItemType type, int quantity) { queue.getItems().Add(new ProductionQueueItem(type, quantity)); }
public SimpleQueueItem(QueueItemType type, string id) { Id = id; _type = type; }
public ProductionQueueItem(QueueItemType type, int quantity) : base() { this.type = type; this.quantity = quantity; }
private IDequeueResolver GetDequeueResolverFor(QueueItemType queueItemType) { return(_dequeueResolvers.FirstOrDefault(dr => dr.ResolvesQueueItemType(queueItemType))); }
/// <summary> /// BeginAddQueueItemToOutboundFrame /// Adds a queue item to the outbound queue frame /// </summary> /// <param name="qItemType">type of rpc (client or server)</param> /// <param name="timeStamp">when it was scheduled to be sent</param> /// <param name="networkChannel">the channel to send it on</param> /// <param name="sourceNetworkId">who is sending the rpc</param> /// <param name="targetNetworkIds">who the rpc is being sent to</param> /// <returns></returns> public PooledNetworkWriter BeginAddQueueItemToFrame(QueueItemType qItemType, float timeStamp, NetworkChannel networkChannel, ulong sourceNetworkId, ulong[] targetNetworkIds, RpcQueueHistoryFrame.QueueFrameType queueFrameType, NetworkUpdateStage updateStage) { bool getNextFrame = NetworkManager.Singleton.IsHost && queueFrameType == RpcQueueHistoryFrame.QueueFrameType.Inbound; var rpcQueueHistoryItem = GetQueueHistoryFrame(queueFrameType, updateStage, getNextFrame); rpcQueueHistoryItem.IsDirty = true; //Write the packed version of the queueItem to our current queue history buffer rpcQueueHistoryItem.QueueWriter.WriteUInt16((ushort)qItemType); rpcQueueHistoryItem.QueueWriter.WriteSingle(timeStamp); rpcQueueHistoryItem.QueueWriter.WriteUInt64(sourceNetworkId); if (queueFrameType != RpcQueueHistoryFrame.QueueFrameType.Inbound) { rpcQueueHistoryItem.QueueWriter.WriteByte((byte)networkChannel); if (targetNetworkIds != null && targetNetworkIds.Length != 0) { //In the event the host is one of the networkIds, for outbound we want to ignore it (at this spot only!!) //Get a count of clients we are going to send to (and write into the buffer) var numberOfClients = 0; for (int i = 0; i < targetNetworkIds.Length; i++) { if (NetworkManager.Singleton.IsHost && targetNetworkIds[i] == NetworkManager.Singleton.ServerClientId) { continue; } numberOfClients++; } //Write our total number of clients rpcQueueHistoryItem.QueueWriter.WriteInt32(numberOfClients); //Now write the cliend ids for (int i = 0; i < targetNetworkIds.Length; i++) { if (NetworkManager.Singleton.IsHost && targetNetworkIds[i] == NetworkManager.Singleton.ServerClientId) { continue; } rpcQueueHistoryItem.QueueWriter.WriteUInt64(targetNetworkIds[i]); } } else { rpcQueueHistoryItem.QueueWriter.WriteInt32(0); } } //Mark where we started in the stream to later determine the actual RPC message size (position before writing RPC message vs position after write has completed) rpcQueueHistoryItem.MarkCurrentStreamPosition(); //Write a filler dummy size of 0 to hold this position in order to write to it once the RPC is done writing. rpcQueueHistoryItem.QueueWriter.WriteInt64(0); if (NetworkManager.Singleton.IsHost && queueFrameType == RpcQueueHistoryFrame.QueueFrameType.Inbound) { if (!IsUsingBatching()) { rpcQueueHistoryItem.QueueWriter.WriteInt64(1); } else { rpcQueueHistoryItem.QueueWriter.WriteInt64(0); } rpcQueueHistoryItem.HasLoopbackData = true; //The only case for this is when it is the Host } //Return the writer to the invoking method. return(rpcQueueHistoryItem.QueueWriter); }
public void AddQueueItem(GameObject item, QueueItemType type) { queueItems.Add(new QueueItem(item, type)); queueLength = queueItems.Count; }
public QueueItem(QueueItemType itemType) { QueueItemType = (int)itemType; }
public ProductionQueueItem(QueueItemType type, int quantity, ShipDesign shipDesign) : base() { this.type = type; this.quantity = quantity; this.shipDesign = shipDesign; }
public QueueItem(QueueItemType t, char cr, int cd) { type = t; c = cr; code = cd; }
public bool ResolvesQueueItemType(QueueItemType queueItemType) => queueItemType == QueueItemType.Email;
public bool ResolvesQueueItemType(QueueItemType queueItemType) => queueItemType == QueueItemType.Audit;
public void setType(QueueItemType type) { this.type = type; }