internal HashtableEntryDefinition MatchEntry(string keyName, TerminatingErrorContext invocationContext) { if (string.IsNullOrEmpty(keyName)) { PSTraceSource.NewArgumentNullException("keyName"); } HashtableEntryDefinition matchingEntry = null; for (int i = 0; i < this.hashEntries.Count; i++) { if (this.hashEntries[i].IsKeyMatch(keyName)) { if (matchingEntry == null) { matchingEntry = this.hashEntries[i]; } else { ProcessAmbiguousKey(invocationContext, keyName, matchingEntry, this.hashEntries[i]); } } } if (matchingEntry != null) { return(matchingEntry); } ProcessIllegalKey(invocationContext, keyName); return(null); }
private static void ProcessAmbiguousKey(TerminatingErrorContext invocationContext, string keyName, HashtableEntryDefinition matchingEntry, HashtableEntryDefinition currentEntry) { string msg = StringUtil.Format(FormatAndOut_MshParameter.AmbiguousKeyError, keyName, matchingEntry.KeyName, currentEntry.KeyName); ParameterProcessor.ThrowParameterBindingException(invocationContext, "DictionaryKeyAmbiguous", msg); }
private Hashtable VerifyHashTable(IDictionary hash, TerminatingErrorContext invocationContext) { Hashtable hashtable = new Hashtable(); foreach (DictionaryEntry entry in hash) { if (entry.Key == null) { ProcessNullHashTableKey(invocationContext); } string key = entry.Key as string; if (key == null) { ProcessNonStringHashTableKey(invocationContext, entry.Key); } HashtableEntryDefinition definition = this.paramDef.MatchEntry(key, invocationContext); if (hashtable.Contains(definition.KeyName)) { ProcessDuplicateHashTableKey(invocationContext, key, definition.KeyName); } bool flag = false; if ((definition.AllowedTypes == null) || (definition.AllowedTypes.Length == 0)) { flag = true; } else { for (int i = 0; i < definition.AllowedTypes.Length; i++) { if (entry.Value == null) { ProcessMissingKeyValue(invocationContext, key); } if (definition.AllowedTypes[i].IsAssignableFrom(entry.Value.GetType())) { flag = true; break; } } } if (!flag) { ProcessIllegalHashTableKeyValue(invocationContext, key, entry.Value.GetType(), definition.AllowedTypes); } hashtable.Add(definition.KeyName, entry.Value); } return(hashtable); }
/// <summary> /// for a key name, verify it is a legal entry: /// 1. it must match (partial match allowed) /// 2. it must be unambiguous (if partial match) /// If an error condition occurs, an exception will be thrown /// </summary> /// <param name="keyName">Key to verify.</param> /// <param name="invocationContext">Invocation context for error reporting.</param> /// <returns>Matching hash table entry.</returns> /// <exception cref="ArgumentException"></exception> internal HashtableEntryDefinition MatchEntry(string keyName, TerminatingErrorContext invocationContext) { if (string.IsNullOrEmpty(keyName)) { PSTraceSource.NewArgumentNullException("keyName"); } HashtableEntryDefinition matchingEntry = null; for (int k = 0; k < this.hashEntries.Count; k++) { if (this.hashEntries[k].IsKeyMatch(keyName)) { // we have a match if (matchingEntry == null) { // this is the first match, we save the entry // and we keep going for ambiguity check matchingEntry = this.hashEntries[k]; } else { // we already had a match, we have an ambiguous key ProcessAmbiguousKey(invocationContext, keyName, matchingEntry, this.hashEntries[k]); } } } if (matchingEntry != null) { // we found an unambiguous match return(matchingEntry); } // we did not have a match ProcessIllegalKey(invocationContext, keyName); return(null); }
/// <exception cref="ArgumentException"></exception> private Hashtable VerifyHashTable(IDictionary hash, TerminatingErrorContext invocationContext) { // full blown hash, need to: // 1. verify names(keys) and expand names if there are partial matches // 2. verify value types Hashtable retVal = new Hashtable(); foreach (DictionaryEntry e in hash) { if (e.Key is null) { ProcessNullHashTableKey(invocationContext); } string currentStringKey = e.Key as string; if (currentStringKey is null) { ProcessNonStringHashTableKey(invocationContext, e.Key); } // find a match for the key HashtableEntryDefinition def = _paramDef.MatchEntry(currentStringKey, invocationContext); if (retVal.Contains(def.KeyName)) { // duplicate key error ProcessDuplicateHashTableKey(invocationContext, currentStringKey, def.KeyName); } // now the key is verified, need to check the type bool matchType = false; if (def.AllowedTypes is null || def.AllowedTypes.Length == 0) { // we match on any type, it will be up to the entry to further check matchType = true; }
/// <exception cref="ArgumentException"></exception> private Hashtable VerifyHashTable(IDictionary hash, TerminatingErrorContext invocationContext) { // full blown hash, need to: // 1. verify names(keys) and expand names if there are partial matches // 2. verify value types Hashtable retVal = new Hashtable(); foreach (DictionaryEntry e in hash) { if (e.Key == null) { ProcessNullHashTableKey(invocationContext); } string currentStringKey = e.Key as string; if (currentStringKey == null) { ProcessNonStringHashTableKey(invocationContext, e.Key); } // find a match for the key HashtableEntryDefinition def = _paramDef.MatchEntry(currentStringKey, invocationContext); if (retVal.Contains(def.KeyName)) { // duplicate key error ProcessDuplicateHashTableKey(invocationContext, currentStringKey, def.KeyName); } // now the key is verified, need to check the type bool matchType = false; if (def.AllowedTypes == null || def.AllowedTypes.Length == 0) { // we match on any type, it will be up to the entry to further check matchType = true; } else { for (int t = 0; t < def.AllowedTypes.Length; t++) { if (e.Value == null) { ProcessMissingKeyValue(invocationContext, currentStringKey); } if (def.AllowedTypes[t].IsAssignableFrom(e.Value.GetType())) { matchType = true; break; } } } if (!matchType) { // bad type error ProcessIllegalHashTableKeyValue(invocationContext, currentStringKey, e.Value.GetType(), def.AllowedTypes); } retVal.Add(def.KeyName, e.Value); } return(retVal); }