} // GenerateNewPathsWithGlobLeaf /// <summary> /// Gets the child names in the specified path by using the provider /// </summary> /// /// <param name="dir"> /// The path of the directory to get the child names from. If this is an Msh Path, /// dirIsProviderPath must be false, If this is a provider-internal path, /// dirIsProviderPath must be true. /// </param> /// /// <param name="leafElement"> /// The element that we are ultimately looking for. Used to set filters on the context /// if desired. /// </param> /// /// <param name="getAllContainers"> /// Determines if the GetChildNames call should get all containers even if they don't /// match the filter. /// </param> /// /// <param name="context"> /// The context to be used for the command. The context is copied to a new context, the /// results are accumulated and then returned. /// </param> /// /// <param name="dirIsProviderPath"> /// Specifies whether the dir parameter is a provider-internal path (true) or Msh Path (false). /// </param> /// /// <param name="drive"> /// The drive to use to qualify the Msh path if dirIsProviderPath is false. /// </param> /// /// <param name="provider"> /// The provider to use to get the child names. /// </param> /// /// <param name="modifiedDirPath"> /// Returns the modified dir path. If dirIsProviderPath is true, this is the unescaped dir path. /// If dirIsProviderPath is false, this is the unescaped resolved provider path. /// </param> /// /// <returns> /// A collection of PSObjects whose BaseObject is a string that contains the name of the child. /// </returns> /// /// <exception cref="ArgumentNullException"> /// If <paramref name="dir"/> or <paramref name="drive"/> is null. /// </exception> /// /// <exception cref="ProviderNotFoundException"> /// If the path is a provider-qualified path for a provider that is /// not loaded into the system. /// </exception> /// /// <exception cref="DriveNotFoundException"> /// If the <paramref name="path"/> refers to a drive that could not be found. /// </exception> /// /// <exception cref="ProviderInvocationException"> /// If the provider used to build the path threw an exception. /// </exception> /// /// <exception cref="NotSupportedException"> /// If the provider that the <paramref name="path"/> represents is not a NavigationCmdletProvider /// or ContainerCmdletProvider. /// </exception> /// /// <exception cref="InvalidOperationException"> /// If the <paramref name="path"/> starts with "~" and the home location is not set for /// the provider. /// </exception> /// /// <exception cref="ProviderInvocationException"> /// If the provider associated with the <paramref name="path"/> threw an /// exception when its GetParentPath or MakePath was called while /// processing the <paramref name="path"/>. /// </exception> /// /// <exception cref="PipelineStoppedException"> /// If <paramref name="context"/> has been signaled for /// StopProcessing. /// </exception> /// /// <exception> /// Any exception can be thrown by the provider that is called to build /// the provider path. /// </exception> /// private Collection<PSObject> GetChildNamesInDir( string dir, string leafElement, bool getAllContainers, CmdletProviderContext context, bool dirIsProviderPath, PSDriveInfo drive, ContainerCmdletProvider provider, out string modifiedDirPath) { // See if the provider wants to convert the path and filter string convertedPath = null; string convertedFilter = null; string originalFilter = context.Filter; bool changedPathOrFilter = provider.ConvertPath(leafElement, context.Filter, ref convertedPath, ref convertedFilter, context); if (changedPathOrFilter) { if (s_tracer.IsEnabled) { s_tracer.WriteLine("Provider converted path and filter."); s_tracer.WriteLine("Original path: {0}", leafElement); s_tracer.WriteLine("Converted path: {0}", convertedPath); s_tracer.WriteLine("Original filter: {0}", context.Filter); s_tracer.WriteLine("Converted filter: {0}", convertedFilter); } leafElement = convertedPath; context.Filter = convertedFilter; } ReturnContainers returnContainers = ReturnContainers.ReturnAllContainers; if (!getAllContainers) { returnContainers = ReturnContainers.ReturnMatchingContainers; } CmdletProviderContext getChildNamesContext = new CmdletProviderContext(context); // Remove the include/exclude filters from the new context getChildNamesContext.SetFilters( new Collection<string>(), new Collection<string>(), context.Filter); try { // Use the provider to get the children string unescapedDir = null; modifiedDirPath = null; if (dirIsProviderPath) { modifiedDirPath = unescapedDir = context.SuppressWildcardExpansion ? dir : RemoveGlobEscaping(dir); } else { Dbg.Diagnostics.Assert( drive != null, "Caller should verify that drive is not null when dirIsProviderPath is false"); // If the directory is an MSH path we must resolve it before calling GetChildNames() // -- If the path is passed in by LiteralPath (context.SuppressWildcardExpansion == false), we surely should use 'dir' unchanged. // -- If the path is passed in by Path (context.SuppressWildcardExpansion == true), we still should use 'dir' unchanged, in case that the special character // in 'dir' is escaped modifiedDirPath = GetMshQualifiedPath(dir, drive); ProviderInfo providerIgnored = null; CmdletProvider providerInstanceIgnored = null; Collection<string> resolvedPaths = GetGlobbedProviderPathsFromMonadPath( modifiedDirPath, false, getChildNamesContext, out providerIgnored, out providerInstanceIgnored); // After resolving the path, we unescape the modifiedDirPath if necessary. modifiedDirPath = context.SuppressWildcardExpansion ? modifiedDirPath : RemoveGlobEscaping(modifiedDirPath); if (resolvedPaths.Count > 0) { unescapedDir = resolvedPaths[0]; } else { // If there were no results from globbing but no // exception was thrown, that means there was filtering. // So return an empty collection and let the caller deal // with it. if (changedPathOrFilter) { context.Filter = originalFilter; } return new Collection<PSObject>(); } } if (provider.HasChildItems(unescapedDir, getChildNamesContext)) { provider.GetChildNames( unescapedDir, returnContainers, getChildNamesContext); } // First check to see if there were any errors, and write them // to the real context if there are. if (getChildNamesContext.HasErrors()) { Collection<ErrorRecord> errors = getChildNamesContext.GetAccumulatedErrorObjects(); if (errors != null && errors.Count > 0) { foreach (ErrorRecord errorRecord in errors) { context.WriteError(errorRecord); } } } Collection<PSObject> childNamesObjectArray = getChildNamesContext.GetAccumulatedObjects(); if (changedPathOrFilter) { context.Filter = originalFilter; } return childNamesObjectArray; } finally { getChildNamesContext.RemoveStopReferral(); } } // GetChildNamesInDir
private Collection<PSObject> GetChildNamesInDir(string dir, string leafElement, bool getAllContainers, CmdletProviderContext context, bool dirIsProviderPath, PSDriveInfo drive, ContainerCmdletProvider provider, out string modifiedDirPath) { string updatedPath = null; string updatedFilter = null; Collection<PSObject> collection4; string filter = context.Filter; bool flag = provider.ConvertPath(leafElement, context.Filter, ref updatedPath, ref updatedFilter, context); if (flag) { tracer.WriteLine("Provider converted path and filter.", new object[0]); tracer.WriteLine("Original path: " + leafElement, new object[0]); tracer.WriteLine("Converted path: " + updatedPath, new object[0]); tracer.WriteLine("Original filter: " + context.Filter, new object[0]); tracer.WriteLine("Converted filter: " + updatedFilter, new object[0]); leafElement = updatedPath; context.Filter = updatedFilter; } ReturnContainers returnAllContainers = ReturnContainers.ReturnAllContainers; if (!getAllContainers) { returnAllContainers = ReturnContainers.ReturnMatchingContainers; } CmdletProviderContext context2 = new CmdletProviderContext(context); context2.SetFilters(new Collection<string>(), new Collection<string>(), context.Filter); try { string path = null; modifiedDirPath = null; if (dirIsProviderPath) { modifiedDirPath = path = context.SuppressWildcardExpansion ? dir : RemoveGlobEscaping(dir); } else { modifiedDirPath = GetMshQualifiedPath(dir, drive); ProviderInfo info = null; CmdletProvider providerInstance = null; Collection<string> collection = this.GetGlobbedProviderPathsFromMonadPath(modifiedDirPath, false, context2, out info, out providerInstance); modifiedDirPath = context.SuppressWildcardExpansion ? modifiedDirPath : RemoveGlobEscaping(modifiedDirPath); if (collection.Count > 0) { path = collection[0]; } else { if (flag) { context.Filter = filter; } return new Collection<PSObject>(); } } if (provider.HasChildItems(path, context2)) { provider.GetChildNames(path, returnAllContainers, context2); } if (context2.HasErrors()) { Collection<ErrorRecord> accumulatedErrorObjects = context2.GetAccumulatedErrorObjects(); if ((accumulatedErrorObjects != null) && (accumulatedErrorObjects.Count > 0)) { foreach (ErrorRecord record in accumulatedErrorObjects) { context.WriteError(record); } } } Collection<PSObject> accumulatedObjects = context2.GetAccumulatedObjects(); if (flag) { context.Filter = filter; } collection4 = accumulatedObjects; } finally { context2.RemoveStopReferral(); } return collection4; }
internal List<string> GetValidChildNames(ContainerCmdletProvider provider, string providerPath, ReturnContainers returnContainers, ProviderRuntime runtime) { var subRuntime = new ProviderRuntime(runtime); subRuntime.PassThru = false; // so we can catch the results provider.GetChildNames(providerPath, returnContainers, subRuntime); var results = subRuntime.ThrowFirstErrorOrReturnResults(); return (from c in results where c.BaseObject is string select ((string)c.BaseObject)).ToList(); }