private void AddSourceEntry(SourceEntry sourceEntry) { //Console.WriteLine($"adding {sourceEntry}"); if (!Entries.ContainsKey(sourceEntry.ThisHash)) { Entries.Add(sourceEntry.ThisHash, new List <SourceEntry> { sourceEntry }); } else { Entries[sourceEntry.ThisHash].Add(sourceEntry); } if (!FilesToTokens.ContainsKey(sourceEntry.FileHash)) { FilesToTokens.Add(sourceEntry.FileHash, new List <int> { sourceEntry.ThisHash }); } else { FilesToTokens[sourceEntry.FileHash].Add(sourceEntry.ThisHash); } }
/// <summary> /// Searches for a given file entry in the file list. /// </summary> /// <param name="directory">Directory to search in.</param> /// <param name="fileName">File name to find, without the extension.</param> /// <param name="extension">File extension, without the leading dot.</param> public PackageEntry FindEntry(string directory, string fileName, string extension) { if (directory == null) { throw new ArgumentNullException(nameof(directory)); } if (fileName == null) { throw new ArgumentNullException(nameof(fileName)); } if (extension == null) { throw new ArgumentNullException(nameof(extension)); } if (!Entries.ContainsKey(extension)) { return(null); } // We normalize path separators when reading the file list // And remove the trailing slash directory = directory.Replace('\\', DirectorySeparatorChar).Trim(DirectorySeparatorChar); // If the directory is empty after trimming, set it to a space to match Valve's behaviour if (directory.Length == 0) { directory = " "; } return(Entries[extension].Find(x => x.DirectoryName == directory && x.FileName == fileName)); }
/// <summary> /// Accesses a stored value /// </summary> /// <param name="Key">The name of the stored value</param> /// <returns>If the given key is present, returns the value being stored, otherwise returns null</returns> public dynamic this[string Key] { get { lock (Entries) { if (Entries.ContainsKey(Key)) { return(Entries[Key]); } else { return(null); } } } set { lock (Entries) { if (Entries.ContainsKey(Key)) { Entries[Key] = value; } else { Entries.Add(Key, value); } } } }
public override void ProcessKill(Mobile victim, Mobile damager) { var bc = victim as BaseCreature; if (bc == null || bc.Map != Map.TerMur || damager.Map != Map.TerMur) { return; } Type type = bc.GetType(); if (!Entries.ContainsKey(type)) { return; } if (damager is BaseCreature && (((BaseCreature)damager).Controlled || ((BaseCreature)damager).Summoned)) { damager = ((BaseCreature)damager).GetMaster(); } if (damager == null) { return; } if (bc.GetHighestDamager() == damager) { AwardPoints(damager, Entries[type].Item1, false); } else { AwardPoints(damager, Entries[type].Item2, false); } }
public void AddPending(BODType type, int points) { if (Entries.ContainsKey(type)) { Entries[type].PendingRewardPoints = points; } }
public override void ProcessKill(BaseCreature victim, Mobile damager, int index) { if (victim.Map != Map.TerMur || damager.Map != Map.TerMur) { return; } Type type = victim.GetType(); if (damager is BaseCreature && (((BaseCreature)damager).Controlled || ((BaseCreature)damager).Summoned)) { damager = ((BaseCreature)damager).GetMaster(); } if (damager == null) { return; } if (index == 0) { if (Entries.ContainsKey(type)) { AwardPoints(damager, Entries[type].Item1, false); } } else { if (Entries.ContainsKey(type)) { AwardPoints(damager, Entries[type].Item2, false); } } }
protected void RemoveLease(TLease lease) { if (Entries.ContainsKey(lease.Id) == true) { Entries.Remove(lease.Id); } }
protected IQueryable <GeoDataEntry> Search(string searchTerm, BoundingBox boundingBox, int maxResults) { lock (Entries) { //always want to query at least DataProviderMinResults # of entries so that //Ranking logic is (most) accurately applied maxResults = Math.Max(maxResults, DataProviderMinResults); //remove entry if it already exists and is expired var newKey = new ServiceCacheKey(StringComparer, boundingBox, searchTerm, maxResults); ServiceCacheKey existingKey = Entries.ContainsKey(newKey) ? Entries.Keys.Single(k => k.Equals(newKey)) : null; if (existingKey != null && IsFlushable(existingKey)) { Entries.Remove(existingKey); existingKey = null; } //if this set of args hasn't been queried before, or //if it has but for a lower number of maxResults, refresh cache for this key if (existingKey == null || existingKey.MaxResults < maxResults) { if (boundingBox != null) { Entries[newKey] = DataProvider.SearchNear(searchTerm, boundingBox, maxResults); } else { Entries[newKey] = DataProvider.Search(searchTerm.Trim(), maxResults); } } return(Entries[newKey]); } }
public void RemovePending(BODType type) { if (Entries.ContainsKey(type)) { Entries[type].PendingRewardPoints = 0; } }
public void TestStoragePopulatedDeleteEntryExist() { storage.DeleteEntry("foo2"); Assert.That(Entries.ContainsKey("foo2"), Is.False); if (m_server) { Assert.That(IdMap, Has.Count.GreaterThanOrEqualTo(2)); Assert.That(IdMap[1], Is.Null); } if (m_server) { Assert.That(outgoing, Has.Count.EqualTo(1)); Assert.That(outgoing[0].only, Is.Null); Assert.That(outgoing[0].except, Is.Null); var msg = outgoing[0].msg; Assert.That(msg.Type, Is.EqualTo(Message.MsgType.EntryDelete)); Assert.That(msg.Id, Is.EqualTo(1)); } else { Assert.That(outgoing, Is.Empty); } }
protected void RemoveEntry(Guid id) { if (Entries.ContainsKey(id) == true) { TLease lease = Entries[id]; LatestLeases.Remove(lease); Entries.Remove(id); } }
public int GetPendingRewardFor(BODType type) { if (Entries.ContainsKey(type)) { return(Entries[type].PendingRewardPoints); } return(0); }
protected override void When(DomainEvent domainEvent) { DHCPv4Lease lease = null; switch (domainEvent) { case DHCPv4LeaseCreatedEvent e: DHCPv4Lease leaseToAdd = new DHCPv4Lease( e.EntityId, e.Address, e.StartedAt, e.ValidUntil, e.RenewalTime, e.PreferredLifetime, e.ClientIdenfier == null ? DHCPv4ClientIdentifier.Empty : DHCPv4ClientIdentifier.FromOptionData(e.ClientIdenfier), e.UniqueIdentifier, e.AncestorId, _additonalApplier ); if (Entries.ContainsKey(e.EntityId) == false) { AddEntry(e.EntityId, leaseToAdd); CleanEntries(); } break; case DHCPv4LeaseRemovedEvent e: RemoveEntry(e.EntityId); break; case DHCPv4LeaseCanceledEvent e: lease = GetLeaseAndRemoveEntry(e.EntityId); break; case DHCPv4LeaseReleasedEvent e: lease = GetLeaseAndRemoveEntry(e.EntityId); break; case DHCPv4LeaseRevokedEvent e: lease = GetLeaseAndRemoveEntry(e.EntityId); break; case DHCPv4ScopeRelatedEvent e: lease = GetLeaseById(e.EntityId); break; default: break; } if (domainEvent?.IsHandled() == false) { ApplyToEnity(lease, domainEvent); } }
public override Entry GetEntry(uint id) { if (Entries.ContainsKey(id)) { return(Entries[id]); } return(null); }
public new void Load(string path) { base.Load(path); if (Entries.ContainsKey("IniVersion") && Entries["IniVersion"].Count > 0) { Entries["IniVersion"].Remove(Entries["IniVersion"].Last().Key); } }
public virtual Entry GetEntry(uint id) { if (EntriesPerTexture <= 0 && Entries.ContainsKey(id)) { return(Entries[id]); } else if (Entries?.ContainsKey((uint)(id % EntriesPerTexture)) ?? false) { return(Entries[(uint)(id % EntriesPerTexture)]); } return(null); }
public override void ProcessQuest(Mobile from, Type type) { if (from == null || type == null) { return; } if (Entries.ContainsKey(type)) { AwardPoints(from, Entries[type].Item1, true); } }
public virtual Entry GetEntry(Enum id) { if (Entries.ContainsKey(Convert.ToUInt32(id))) { return(Entries[Convert.ToUInt32(id)]); } if (Entries.ContainsKey((uint)(Convert.ToUInt32(id) % EntriesPerTexture))) { return(Entries[(uint)(Convert.ToUInt32(id) % EntriesPerTexture)]); } return(null); }
public BaseStatsEntry this[byte level] { get { if (Entries.ContainsKey(level)) { return(Entries[level]); } else { return(null); } } }
public void UpdateTimestamp(string baseFile) { var numTimestamps = 0; if (Entries.ContainsKey("IniVersion")) { numTimestamps = Entries["IniVersion"].Count; } var newTimestamp = new DateTimeOffset(File.GetLastWriteTimeUtc(baseFile)).ToUnixTimeSeconds() + ".000000"; Add("IniVersion", numTimestamps.ToString(), newTimestamp); }
public virtual PvPProfileHistoryEntry EnsureEntry(PvPSeason season, bool replace = false) { if (!Entries.ContainsKey(season.Number)) { Entries.Add(season.Number, new PvPProfileHistoryEntry(season.Number)); } else if (replace) { Entries[season.Number] = new PvPProfileHistoryEntry(season.Number); } return(Entries[season.Number] ?? (Entries[season.Number] = new PvPProfileHistoryEntry(season.Number))); }
public override void ProcessQuest(Mobile from, BaseQuest quest) { if (from == null || quest == null) { return; } Type type = quest.GetType(); if (Entries.ContainsKey(type)) { AwardPoints(from, Entries[type].Item1, true); } }
private void GeneratePages(ID label, ID label_pg1, byte count, sbyte offset) { if (!Entries.ContainsKey(label_pg1) && !Entries.ContainsKey(label) && !Entries.ContainsKey(ID.Size_08x08_P_)) { return; } count = (byte)MathHelper.Clamp(count, 1, 99); var P_ = Entries[ID.Size_08x08_P_][0].Clone(); P_.Offset.X += Entries[label][0].Width + offset; P_.CustomPalette = 2; var _ = new Entry[10]; _[1] = Entries[ID.Num_8x8_1_1][0].Clone(); _[1].Offset.X += P_.Offset.X + P_.Width + 2; _[1].CustomPalette = 7; for (byte i = 2; i <= 9 && i <= count; i++) { _[i] = Entries[ID.Num_8x8_1_1 + i - 1][0].Clone(); _[i].Offset.X = _[1].Offset.X; _[i].CustomPalette = _[1].CustomPalette; } Entry[] __ = null; if (count > 9) { __ = new Entry[10]; __[0] = Entries[ID.Num_8x8_1_0][0].Clone(); __[0].Offset.X += P_.Offset.X + P_.Width + 2 + _[1].Width; __[0].CustomPalette = 7; for (byte i = 1; i <= 9; i++) { __[i] = _[i].Clone(); __[i].Offset.X = __[0].Offset.X; } } for (byte i = 1; i <= count; i++) { if (i < 10) { Entries[label_pg1 + i - 1] = new EntryGroup(Entries[label][0], P_, _[i]); } else if (i >= 10 && __ != null) { Entries[label_pg1 + i - 1] = new EntryGroup(Entries[label][0], P_, _[i / 10], __[i % 10]); } } }
public object Get(string key) { object value = null; cache.TryGetValue(key, out value); if (value != null) { //test for expired entry if (Entries.ContainsKey(key) && Entries[key].CompareTo(DateTime.Now) <= 0) { value = null; } } return(value); }
public TLease GetAncestor(TLease lease) { if (lease.HasAncestor() == false) { return(null); } if (Entries.ContainsKey(lease.AncestorId.Value) == false) { return(null); } else { return(Entries[lease.AncestorId.Value]); } }
public void CreateEntry(string query, Expression <Func <TEntity, object> > predicate) { ArgumentHelper.ThrowIfNullOrEmpty(query, nameof(query)); ArgumentHelper.ThrowIfNull(predicate, nameof(predicate)); if (Entries.ContainsKey(query)) { throw new ArgumentException("An entry with the same query name already exists.", nameof(query)); } Entries.Add(query, new SortDefinition <TEntity, TId>() { Name = query, Predicate = predicate }); }
/// <summary> /// Create a new setting. The setting is saved to drive and loaded automatically. /// Each definition can be used to add only one setting, trying to add a second setting will throw an exception. /// </summary> /// <typeparam name="T">Type of the value contained in this setting.</typeparam> /// <param name="configDefinition">Section and Key of the setting.</param> /// <param name="defaultValue">Value of the setting if the setting was not created yet.</param> /// <param name="configDescription">Description of the setting shown to the user and other metadata.</param> public ConfigEntry <T> AddSetting <T>(ConfigDefinition configDefinition, T defaultValue, ConfigDescription configDescription = null) { if (!TomlTypeConverter.CanConvert(typeof(T))) { throw new ArgumentException($"Type {typeof(T)} is not supported by the config system. Supported types: {string.Join(", ", TomlTypeConverter.GetSupportedTypes().Select(x => x.Name).ToArray())}"); } lock (_ioLock) { if (Entries.ContainsKey(configDefinition)) { throw new ArgumentException("The setting " + configDefinition + " has already been created. Use GetSetting to get it."); } try { _disableSaving = true; var entry = new ConfigEntry <T>(this, configDefinition, defaultValue, configDescription); Entries[configDefinition] = entry; if (HomelessEntries.TryGetValue(configDefinition, out string homelessValue)) { entry.SetSerializedValue(homelessValue); HomelessEntries.Remove(configDefinition); } _disableSaving = false; if (SaveOnConfigSet) { Save(); } return(entry); } finally { _disableSaving = false; } } }
public BODContext(GenericReader reader) { int version = reader.ReadInt(); ConfigEntries(); this.PointsMode = (PointsMode)reader.ReadInt(); BOBFilter = new BOBFilter(reader); int count = reader.ReadInt(); for (int i = 0; i < count; i++) { BODType type = (BODType)reader.ReadInt(); BODEntry entry = new BODEntry(reader); if (Entries.ContainsKey(type)) { Entries[type] = entry; } } }
public void ProjectileHitEnemy(float damage, bool fatal, HealthHaver enemy) { CustomEnemyTagsSystem tags = enemy.gameObject.GetComponent <CustomEnemyTagsSystem>(); if (tags != null && tags.ignoreForGoodMimic == true) { return; } if (enemy != null && enemy.aiActor != null && ((fatal && !enemy.IsBoss) || (enemy.IsBoss && canChangeToBossWeapon))) { int GunID = -1; if (enemy.aiActor.aiShooter != null && enemy.aiActor.aiShooter.CurrentGun != null) { if (SpecialOverrideGuns.ContainsKey(enemy.aiActor.EnemyGuid)) { GunID = SpecialOverrideGuns[enemy.aiActor.EnemyGuid]; } else { GunID = enemy.aiActor.aiShooter.CurrentGun.PickupObjectId; } } else if (Entries.ContainsKey(enemy.aiActor.EnemyGuid)) { GunID = Entries[enemy.aiActor.EnemyGuid]; } if (GunID > 0) { if (enemy.IsBoss) { canChangeToBossWeapon = false; Invoke("ResetBossWeaponCooldown", 2.5f); } TransformToTargetGunSpecial((PickupObjectDatabase.GetById(GunID) as Gun)); } } }
/// <summary>添加文件。 /// 必须指定文件路径<paramref name="fileName"/>,如果不指定实体名<paramref name="entryName"/>,则使用文件名,并加到顶级目录。</summary> /// <param name="fileName">文件路径</param> /// <param name="entryName">实体名</param> /// <param name="stored">是否仅存储,不压缩</param> /// <returns></returns> public ZipEntry AddFile(String fileName, String entryName = null, Boolean?stored = false) { if (String.IsNullOrEmpty(fileName)) { throw new ArgumentNullException("fileName"); } if (String.IsNullOrEmpty(entryName)) { entryName = Path.GetFileName(fileName); } entryName = entryName.Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar); // 判断并添加目录 String dir = Path.GetDirectoryName(entryName); if (!String.IsNullOrEmpty(dir)) { if (!dir.EndsWith(DirSeparator)) { dir += DirSeparator; } if (!Entries.ContainsKey(dir)) { var zde = new ZipEntry(); zde.FileName = dir; Entries.Add(dir, zde); } } var entry = ZipEntry.Create(fileName, entryName, stored); Entries.Add(entry.FileName, entry); return(entry); }