private void AddRemoveConnection(AttachmentKind kind, AttachedGrid attached, bool add) { Attachments attach; if (!Connections.TryGetValue(attached, out attach)) { if (add) { attach = new Attachments(myGrid, attached.myGrid); Connections.Add(attached, attach); } else { Log.AlwaysLog("cannot remove, no attachments of kind " + kind, Logger.severity.ERROR); return; } } if (add) { attach.Add(kind); } else { attach.Remove(kind); } }
/// <summary> /// Yields attached grids. /// </summary> /// <param name="startGrid">Grid to start search from.</param> /// <param name="allowedConnections">The types of connections allowed between grids.</param> /// <param name="runOnStartGrid">If true, yields the startGrid.</param> /// <returns>Each attached grid.</returns> public static IEnumerable <IMyCubeGrid> AttachedGrids(IMyCubeGrid startGrid, AttachmentKind allowedConnections, bool runOnStartGrid) { if (runOnStartGrid) { yield return(startGrid); } AttachedGrid attached = GetFor(startGrid); if (attached == null) { yield break; } HashSet <AttachedGrid> search = s_searchSet.Get(); try { foreach (IMyCubeGrid grid in attached.Attached(allowedConnections, search)) { yield return(grid); } } finally { search.Clear(); s_searchSet.Return(search); } }
/// <summary> /// Determines if two grids are attached. /// </summary> /// <param name="grid0">The starting grid.</param> /// <param name="grid1">The grid to search for.</param> /// <param name="allowedConnections">The types of connections allowed between grids.</param> /// <returns>True iff the grids are attached.</returns> public static bool IsGridAttached(IMyCubeGrid grid0, IMyCubeGrid grid1, AttachmentKind allowedConnections) { Logger.DebugLog("condition: grid0 == null", Logger.severity.FATAL, condition: grid0 == null); Logger.DebugLog("condition: grid1 == null", Logger.severity.FATAL, condition: grid1 == null); if (grid0 == grid1) { return(true); } AttachedGrid attached1 = GetFor(grid0); if (attached1 == null) { return(false); } AttachedGrid attached2 = GetFor(grid1); if (attached2 == null) { return(false); } HashSet <AttachedGrid> search = s_searchSet.Get(); bool result = attached1.IsGridAttached(attached2, allowedConnections, search); search.Clear(); s_searchSet.Return(search); return(result); }
public async Task <List <Message> > GetAttachments(AttachmentKind kind, int conversationId, string whoAccessedId, int offset, int count) { var conversation = await conversationRepository.GetByIdAsync(conversationId); if (conversation == null) { throw new KeyNotFoundException("Wrong conversation to get attachments from."); } //only member of conversation could request messages of non-public conversation. if (!await usersConversationsRepository.Exists(whoAccessedId, conversationId) && !conversation.IsPublic) { throw new UnauthorizedAccessException("You are unauthorized to do such an action."); } var deleted = await deletedMessages.AsQuerableAsync( new GetDeletedMessagesOfUserSpec(whoAccessedId)); var messages = await messagesRepository.ListAsync( new GetSpecificAttachmentsSpec (deleted, conversationId, kind, offset, count)); return((from msg in messages select msg.ToMessage()).ToList()); }
private LevelStructure RandomKind(AttachmentKind kind) { var validComponents = Components.Where(structure => (structure.HasAttachmentKindAndDirection(kind, AttachmentDirection.InAttach))); int count = validComponents.Count(); Debug.Assert(count > 0); return(validComponents.ElementAt(UnityEngine.Random.Range(0, count))); }
// This is mainly used to find the "root" objects we can start with public bool HasAttachmentKindAndDirection(AttachmentKind kind, AttachmentDirection direction) { foreach (StructureAttachmentPoint inAttachPoint in this.GetComponentsInChildren <StructureAttachmentPoint>()) { if (((inAttachPoint.Kind & kind) != 0) && (inAttachPoint.Direction == direction)) { return(true); } } return(false); }
public void Add(AttachmentKind kind) { myLogger.debugLog("adding: " + kind, "Add()"); ushort count; if (!dictionary.TryGetValue(kind, out count)) { attachmentKinds |= kind; count = 0; } count++; myLogger.debugLog(kind + " count: " + count, "Add()"); dictionary[kind] = count; }
public void Add(AttachmentKind kind) { Log.DebugLog("adding: " + kind); ushort count; if (!dictionary.TryGetValue(kind, out count)) { attachmentKinds |= kind; count = 0; } count++; Log.DebugLog(kind + " count: " + count); dictionary[kind] = count; }
public void Remove(AttachmentKind kind) { myLogger.debugLog("removing: " + kind, "Remove()"); ushort count = dictionary[kind]; count--; if (count == 0) { attachmentKinds &= ~kind; dictionary.Remove(kind); } else dictionary[kind] = count; myLogger.debugLog(kind + " count: " + count, "Add()"); }
/// <summary> /// Determines if two grids are attached. /// </summary> /// <param name="grid0">The starting grid.</param> /// <param name="grid1">The grid to search for.</param> /// <param name="allowedConnections">The types of connections allowed between grids.</param> /// <returns>True iff the grids are attached.</returns> public static bool IsGridAttached(IMyCubeGrid grid0, IMyCubeGrid grid1, AttachmentKind allowedConnections) { if (grid0 == grid1) return true; using (lock_search.AcquireExclusiveUsing()) { AttachedGrid attached1 = GetFor(grid0); if (attached1 == null) return false; AttachedGrid attached2 = GetFor(grid1); if (attached2 == null) return false; return attached1.IsGridAttached(attached2, allowedConnections, searchIdPool++); } }
internal static void AddRemoveConnection(AttachmentKind kind, IMyCubeGrid grid1, IMyCubeGrid grid2, bool add) { if (grid1 == grid2 || Globals.WorldClosed) { return; } AttachedGrid attached1 = GetFor(grid1), attached2 = GetFor(grid2); if (attached1 == null || attached2 == null) { return; } attached1.AddRemoveConnection(kind, attached2, add); attached2.AddRemoveConnection(kind, attached1, add); }
public void Remove(AttachmentKind kind) { Log.DebugLog("removing: " + kind); ushort count = dictionary[kind]; count--; if (count == 0) { attachmentKinds &= ~kind; dictionary.Remove(kind); } else { dictionary[kind] = count; } Log.DebugLog(kind + " count: " + count); }
private bool IsGridAttached(AttachedGrid target, AttachmentKind allowedConnections, HashSet <AttachedGrid> searched) { if (!searched.Add(this)) { throw new Exception("AttachedGrid already searched"); } foreach (var gridAttach in Connections) { if ((gridAttach.Value.attachmentKinds & allowedConnections) == 0 || searched.Contains(gridAttach.Key)) { continue; } if (gridAttach.Key == target || gridAttach.Key.IsGridAttached(target, allowedConnections, searched)) { return(true); } } return(false); }
private IEnumerable <IMyCubeGrid> Attached(AttachmentKind allowedConnections, HashSet <AttachedGrid> searched) { if (!searched.Add(this)) { throw new Exception("AttachedGrid already searched"); } foreach (var gridAttach in Connections) { if ((gridAttach.Value.attachmentKinds & allowedConnections) == 0 || searched.Contains(gridAttach.Key)) { continue; } yield return(gridAttach.Key.myGrid); foreach (var result in gridAttach.Key.Attached(allowedConnections, searched)) { yield return(result); } } }
public GetSpecificAttachmentsSpec( IQueryable <DeletedMessagesDataModel> deletedMessages, int conversationId, AttachmentKind attachmentKind, int offset, int count ) : base( msg => msg.ConversationID == conversationId && msg.Type == MessageType.Attachment && msg.AttachmentInfo.AttachmentKind.Kind == attachmentKind && !deletedMessages.Any(x => x.MessageID == msg.MessageID) ) { ApplyOrderByDescending(x => x.TimeReceived); ApplyPaging(offset, count); AddNestedInclude(x => x.AttachmentInfo.AttachmentKind); AddInclude(x => x.User); AddNestedInclude(x => x.ForwardedMessage.AttachmentInfo.AttachmentKind); AddNestedInclude(x => x.ForwardedMessage.User); AsNoTracking(); }
/// <summary> /// Runs a function on all the attached grids. /// </summary> /// <param name="startGrid">The starting grid/</param> /// <param name="allowedConnections">The types of connections allowed between grids.</param> /// <param name="runFunc">Func that runs on attached grids, if it returns true, short-circuit</param> /// <param name="runOnStartGrid">Iff true, action will be run on startGrid.</param> public static void RunOnAttached(IMyCubeGrid startGrid, AttachmentKind allowedConnections, Func<IMyCubeGrid, bool> runFunc, bool runOnStartGrid = false) { if (runOnStartGrid && runFunc(startGrid)) return; using (lock_search.AcquireExclusiveUsing()) { AttachedGrid attached = GetFor(startGrid); if (attached == null) return; attached.RunOnAttached(allowedConnections, runFunc, searchIdPool++); } }
/// <summary> /// Yields each slim block on each attached grid. If a grid is closed, it is skipped. /// </summary> /// <param name="startGrid">Grid to start search from.</param> /// <param name="allowedConnections">The types of connections allowed between grids.</param> /// <param name="runOnStartGrid">If true, yields the startGrid.</param> /// <returns>Each block on each attached grid</returns> public static IEnumerable <IMySlimBlock> AttachedSlimBlocks(IMyCubeGrid startGrid, AttachmentKind allowedConnections, bool runOnStartGrid) { foreach (CubeGridCache cache in AttachedGridCache(startGrid, allowedConnections, runOnStartGrid)) { foreach (IMySlimBlock block in cache.AllSlimBlocks()) { yield return(block); } } }
private void RunOnAttached(AttachmentKind allowedConnections, Func<IMyCubeGrid, bool> runFunc, uint searchId) { myLogger.debugLog(lastSearchId == searchId, "Already searched! lastSearchId == searchId", "GetAttached()", Logger.severity.ERROR); lastSearchId = searchId; using (lock_Connections.AcquireSharedUsing()) foreach (var gridAttachments in Connections) { if (searchId == gridAttachments.Key.lastSearchId) continue; if ((gridAttachments.Value.attachmentKinds & allowedConnections) == 0) continue; if (runFunc(gridAttachments.Key.myGrid)) return; gridAttachments.Key.RunOnAttached(allowedConnections, runFunc, searchId); } }
public ValueTask <AttachmentKindDataModel> GetById(AttachmentKind kind) { return(_dbContext.AttachmentKinds.FindAsync(kind)); }
private bool IsGridAttached(AttachedGrid target, AttachmentKind allowedConnections, uint searchId) { myLogger.debugLog(lastSearchId == searchId, "Already searched! lastSearchId == searchId", "IsGridAttached()", Logger.severity.ERROR); lastSearchId = searchId; using (lock_Connections.AcquireSharedUsing()) foreach (var gridAttachments in Connections) { if (searchId == gridAttachments.Key.lastSearchId) continue; if ((gridAttachments.Value.attachmentKinds & allowedConnections) == 0) continue; if (gridAttachments.Key == target) return true; if (gridAttachments.Key.IsGridAttached(target, allowedConnections, searchId)) return true; } return false; }
private void AddRemoveConnection(AttachmentKind kind, AttachedGrid attached, bool add) { using (lock_Connections.AcquireExclusiveUsing()) { Attachments attach; if (!Connections.TryGetValue(attached, out attach)) { attach = new Attachments(myGrid, attached.myGrid); Connections.Add(attached, attach); } if (add) attach.Add(kind); else attach.Remove(kind); } }
internal static void AddRemoveConnection(AttachmentKind kind, IMyCubeGrid grid1, IMyCubeGrid grid2, bool add) { if (grid1 == grid2) return; AttachedGrid attached1 = GetFor(grid1), attached2 = GetFor(grid2); if (attached1 != null) attached1.AddRemoveConnection(kind, attached2, add); if (attached2 != null) attached2.AddRemoveConnection(kind, attached1, add); }
internal static void AddRemoveConnection(AttachmentKind kind, Ingame.IMyCubeGrid grid1, Ingame.IMyCubeGrid grid2, bool add) { AddRemoveConnection(kind, grid1 as IMyCubeGrid, grid2 as IMyCubeGrid, add); }
/// <summary> /// Runs a function on all the blocks in all the attached grids. /// </summary> /// <param name="startGrid">Grid to start at.</param> /// <param name="allowedConnections">The types of connections allowed between grids.</param> /// <param name="runFunc">Func that runs on blocks of attached grids, if it returns true, short-circuit</param> /// <param name="runOnStartGrid">Iff true, action will be run on blocks of startGrid.</param> public static void RunOnAttachedBlock(IMyCubeGrid startGrid, AttachmentKind allowedConnections, Func<IMySlimBlock, bool> runFunc, bool runOnStartGrid = false) { List<IMySlimBlock> dummy = new List<IMySlimBlock>(); bool terminated = false; Func<IMyCubeGrid, bool> runOnGrid = grid => { grid.GetBlocks_Safe(dummy, slim => { if (!terminated) terminated = runFunc(slim); return false; }); return terminated; }; RunOnAttached(startGrid, allowedConnections, runOnGrid, runOnStartGrid); }
private void AddRemoveConnection(AttachmentKind kind, AttachedGrid attached, bool add) { using (lock_Connections.AcquireExclusiveUsing()) { Attachments attach; if (!Connections.TryGetValue(attached, out attach)) { if (add) { attach = new Attachments(myGrid, attached.myGrid); Connections.Add(attached, attach); } else { myLogger.alwaysLog("cannot remove, no attachments of kind " + kind, Logger.severity.ERROR); return; } } if (add) attach.Add(kind); else attach.Remove(kind); } }