/// <summary> /// Removes a cmdlet entry from the cmdlet table. /// </summary> /// <param name="name"> /// The name of the cmdlet entry to remove. /// </param> /// <param name="force"> /// If true, the cmdlet is removed even if it is ReadOnly. /// </param> /// <exception cref="ArgumentException"> /// If <paramref name="name"/> is null or empty. /// </exception> /// <exception cref="SessionStateUnauthorizedAccessException"> /// If the function is constant. /// </exception> internal void RemoveCmdletEntry(string name, bool force) { if (string.IsNullOrEmpty(name)) { throw PSTraceSource.NewArgumentException("name"); } // Use the scope enumerator to find an existing function SessionStateScopeEnumerator scopeEnumerator = new SessionStateScopeEnumerator(_currentScope); foreach (SessionStateScope scope in scopeEnumerator) { CmdletInfo cmdletInfo = scope.GetCmdlet(name); if (cmdletInfo != null) { // Make sure the cmdlet isn't private or if it is that the current // scope is the same scope the cmdlet was retrieved from. if ((cmdletInfo.Options & ScopedItemOptions.Private) != 0 && scope != _currentScope) { cmdletInfo = null; } else { scope.RemoveCmdletEntry(name, force); break; } } } }
private void InitializeScopeEnumerator() { // Define the lookup scope and if we have to do single // level or dynamic lookup based on the lookup variable _initialScope = sessionState.CurrentScope; if (_lookupPath.IsGlobal) { _initialScope = sessionState.GlobalScope; _isSingleScopeLookup = true; } else if (_lookupPath.IsLocal || _lookupPath.IsPrivate) { _initialScope = sessionState.CurrentScope; _isSingleScopeLookup = true; } else if (_lookupPath.IsScript) { _initialScope = sessionState.ScriptScope; _isSingleScopeLookup = true; } _scopeEnumerable = new SessionStateScopeEnumerator(_initialScope); _isInitialized = true; }
/// <summary> /// Gets an IEnumerable for the alias table. /// </summary> internal IDictionary <string, AliasInfo> GetAliasTable() { // On 7.0 version we have 132 aliases so we set a larger number to reduce re-allocations. const int InitialAliasCount = 150; Dictionary <string, AliasInfo> result = new Dictionary <string, AliasInfo>(InitialAliasCount, StringComparer.OrdinalIgnoreCase); SessionStateScopeEnumerator scopeEnumerator = new SessionStateScopeEnumerator(_currentScope); foreach (SessionStateScope scope in scopeEnumerator) { foreach (AliasInfo entry in scope.AliasTable) { if (!result.ContainsKey(entry.Name)) { // Make sure the alias isn't private or if it is that the current // scope is the same scope the alias was retrieved from. if ((entry.Options & ScopedItemOptions.Private) == 0 || scope == _currentScope) { result.Add(entry.Name, entry); } } } } return(result); }
/// <summary> /// Gets an IEnumerable for the cmdlet table. /// </summary> internal IDictionary <string, List <CmdletInfo> > GetCmdletTable() { Dictionary <string, List <CmdletInfo> > result = new Dictionary <string, List <CmdletInfo> >(StringComparer.OrdinalIgnoreCase); SessionStateScopeEnumerator scopeEnumerator = new SessionStateScopeEnumerator(_currentScope); foreach (SessionStateScope scope in scopeEnumerator) { foreach (KeyValuePair <string, List <CmdletInfo> > entry in scope.CmdletTable) { if (!result.ContainsKey(entry.Key)) { // Make sure the cmdlet isn't private or if it is that the current // scope is the same scope the alias was retrieved from. List <CmdletInfo> toBeAdded = new List <CmdletInfo>(); foreach (CmdletInfo cmdletInfo in entry.Value) { if ((cmdletInfo.Options & ScopedItemOptions.Private) == 0 || scope == _currentScope) { toBeAdded.Add(cmdletInfo); } } result.Add(entry.Key, toBeAdded); } } } return(result); }
/// <summary> /// Gets an IEnumerable for the alias table /// </summary> /// internal IDictionary <string, AliasInfo> GetAliasTable() { Dictionary <string, AliasInfo> result = new Dictionary <string, AliasInfo>(StringComparer.OrdinalIgnoreCase); SessionStateScopeEnumerator scopeEnumerator = new SessionStateScopeEnumerator(_currentScope); foreach (SessionStateScope scope in scopeEnumerator) { foreach (AliasInfo entry in scope.AliasTable) { if (!result.ContainsKey(entry.Name)) { // Make sure the alias isn't private or if it is that the current // scope is the same scope the alias was retrieved from. if ((entry.Options & ScopedItemOptions.Private) == 0 || scope == _currentScope) { result.Add(entry.Name, entry); } } } } return(result); } // GetAliasTable
public void Dispose() { this.current = default(T); this.scopeEnumerable.Dispose(); this.scopeEnumerable = (SessionStateScopeEnumerator)null; this.isInitialized = false; GC.SuppressFinalize((object)this); }
public void Dispose() { this.current = default(T); this.scopeEnumerable.Dispose(); this.scopeEnumerable = null; this.isInitialized = false; GC.SuppressFinalize(this); }
} // RemoveAlias /// <summary> /// Gets the aliases by command name (used by metadata-driven help) /// </summary> /// <param name="command"></param> /// <returns></returns> internal IEnumerable <string> GetAliasesByCommandName(string command) { SessionStateScopeEnumerator scopeEnumerator = new SessionStateScopeEnumerator(_currentScope); foreach (SessionStateScope scope in scopeEnumerator) { foreach (string alias in scope.GetAliasesByCommandName(command)) { yield return(alias); } } yield break; }
/// <summary> /// Gets the value of the specified alias from the alias table. /// </summary> /// /// <param name="aliasName"> /// The name of the alias value to retrieve. /// </param> /// /// <param name="origin"> /// The origin of the command calling this API. /// </param> /// <returns> /// The AliasInfo representing the alias. /// </returns> /// internal AliasInfo GetAlias(string aliasName, CommandOrigin origin) { AliasInfo result = null; if (String.IsNullOrEmpty(aliasName)) { return(null); } // Use the scope enumerator to find the alias using the // appropriate scoping rules SessionStateScopeEnumerator scopeEnumerator = new SessionStateScopeEnumerator(_currentScope); foreach (SessionStateScope scope in scopeEnumerator) { result = scope.GetAlias(aliasName); if (result != null) { // Now check the visibility of the variable... SessionState.ThrowIfNotVisible(origin, result); // Make sure the alias isn't private or if it is that the current // scope is the same scope the alias was retrieved from. if ((result.Options & ScopedItemOptions.Private) != 0 && scope != _currentScope) { result = null; } else { break; } } } return(result); } // GetAlias
/// <summary> /// Gets a flattened view of the functions that are visible using /// the current scope as a reference and filtering the functions in /// the other scopes based on the scoping rules. /// </summary> /// <returns> /// An IDictionary representing the visible functions. /// </returns> internal IDictionary GetFunctionTable() { SessionStateScopeEnumerator scopeEnumerator = new SessionStateScopeEnumerator(_currentScope); Dictionary <string, FunctionInfo> result = new Dictionary <string, FunctionInfo>(StringComparer.OrdinalIgnoreCase); foreach (SessionStateScope scope in scopeEnumerator) { foreach (FunctionInfo entry in scope.FunctionTable.Values) { if (!result.ContainsKey(entry.Name)) { result.Add(entry.Name, entry); } } } return(result); }
private void InitializeScopeEnumerator() { this.initialScope = this.sessionState.CurrentScope; if (this.lookupPath.IsGlobal) { this.initialScope = this.sessionState.GlobalScope; this.isSingleScopeLookup = true; } else if (this.lookupPath.IsLocal || this.lookupPath.IsPrivate) { this.initialScope = this.sessionState.CurrentScope; this.isSingleScopeLookup = true; } else if (this.lookupPath.IsScript) { this.initialScope = this.sessionState.ScriptScope; this.isSingleScopeLookup = true; } this.scopeEnumerable = new SessionStateScopeEnumerator(this.sessionState, this.initialScope); this.isInitialized = true; }
/// <summary> /// Removes the specified alias. /// </summary> /// /// <param name="aliasName"> /// The name of the alias to remove. /// </param> /// /// <param name="force"> /// If true the alias will be removed even if its ReadOnly. /// </param> /// /// <exception cref="ArgumentException"> /// If <paramref name="aliasName"/> is null or empty. /// </exception> /// /// <exception cref="SessionStateUnauthorizedAccessException"> /// If the alias is constant. /// </exception> /// internal void RemoveAlias(string aliasName, bool force) { if (String.IsNullOrEmpty(aliasName)) { throw PSTraceSource.NewArgumentException("aliasName"); } // Use the scope enumerator to find an existing function SessionStateScopeEnumerator scopeEnumerator = new SessionStateScopeEnumerator(_currentScope); foreach (SessionStateScope scope in scopeEnumerator) { AliasInfo alias = scope.GetAlias(aliasName); if (alias != null) { // Make sure the alias isn't private or if it is that the current // scope is the same scope the alias was retrieved from. if ((alias.Options & ScopedItemOptions.Private) != 0 && scope != _currentScope) { alias = null; } else { scope.RemoveAlias(aliasName, force); break; } } } } // RemoveAlias