void CopyContainerToContainer(ContainerCmdletProvider provider, string srcPath, string destPath, bool recurse, CopyContainers copyContainers, ProviderRuntime runtime) { // the "usual" case: if we don't use recursion (empty container is copied) or we want to maintain the // original hierarchy if (!recurse || copyContainers.Equals(CopyContainers.CopyTargetContainer)) { provider.CopyItem(srcPath, destPath, recurse, runtime); return; } // Otherwise we want a flat-hierachy copy of a folder (because copyContainers is CopyChildrenOfTargetContainer) // Make sure recurse is set if (!recurse) { var error = new PSArgumentException("Cannot copy container to existing leaf", "CopyContainerItemToLeafError", ErrorCategory.InvalidArgument).ErrorRecord; runtime.WriteError(error); return; } // otherwise do the flat copy. To do this: get all child names (recursively) and invoke copying without recursion var childNames = ChildItem.GetNames(srcPath, ReturnContainers.ReturnMatchingContainers, true); foreach (var child in childNames) { var childPath = Path.Combine(provider, srcPath, child, runtime); provider.CopyItem(childPath, destPath, false, runtime); } }
internal Collection <PSObject> GetChildItems(string path, bool recurse, ProviderRuntime providerRuntime) { if (string.IsNullOrEmpty(path)) { path = CurrentLocation.Path; } CmdletProvider provider = GetProviderByPath(path); if ((path != null) && (ItemExists(provider, path, providerRuntime))) { if (IsItemContainer(provider, path, providerRuntime)) { ContainerCmdletProvider containerProvider = provider as ContainerCmdletProvider; if (containerProvider != null) { containerProvider.GetChildItems(path, recurse, providerRuntime); } } else { ItemCmdletProvider itemProvider = provider as ItemCmdletProvider; if (itemProvider != null) { itemProvider.GetItem(path, providerRuntime); } } } return(providerRuntime.RetreiveAllProviderData()); }
private void ManuallyGetChildItemsFromContainer(ContainerCmdletProvider provider, string path, bool recurse, IncludeExcludeFilter filter, ProviderRuntime runtime) { // we deal with a container: get all child items (all containers if we recurse) Dictionary <string, bool> matches = null; // When a provider specific filter is set, and we need to recurse, we need to check recurse into all // containers, but just get those that match the internal filter. Therefore we construct a lookup dict. // Looking up in a dictionary whether or not the itemis a match should be faster than using a list // If there is no filter, then ReturnAllContainers and ReturnMatchingContainers don't differ if (!String.IsNullOrEmpty(runtime.Filter)) { matches = GetValidChildNames(provider, path, ReturnContainers.ReturnMatchingContainers, runtime).ToDictionary(c => c, c => true); } var childNames = GetValidChildNames(provider, path, ReturnContainers.ReturnAllContainers, runtime); foreach (var childName in childNames) { var childPath = Path.Combine(provider, path, childName, runtime); // if the filter accepts the child (leaf or container) and it's potentially a filter match, get it if (filter.Accepts(childName) && (matches == null || matches.ContainsKey(childName))) { provider.GetItem(childPath, runtime); } // if we need to recurse and deal with a container, dive into it if (recurse && Item.IsContainer(childPath, runtime)) { ManuallyGetChildItemsFromContainer(provider, childPath, true, filter, runtime); } } }
private void GetItemOrChildItems(ContainerCmdletProvider provider, string path, bool recurse, ProviderRuntime runtime) { // If path identifies a container it gets all child items (recursively or not). Otherwise it returns the leaf if (Item.IsContainer(provider, path, runtime)) { provider.GetChildItems(path, recurse, runtime); return; } provider.GetItem(path, runtime); }
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()); }
internal bool IsContainer(ContainerCmdletProvider provider, string path, ProviderRuntime runtime) { var navProvider = provider as NavigationCmdletProvider; // path is an expanded path to a single location. no globbing and filtering is performed if (navProvider != null) { return(navProvider.IsItemContainer(path, runtime)); } // otherwise it's just a ContainerCmdletProvider. It doesn't support hierarchies, // only drives can be containers // an empty path means "root" path in a drive return(path.Length == 0 || path.Equals(runtime.PSDriveInfo.Root)); }
private void ManuallyGetChildItems(ContainerCmdletProvider provider, string path, bool recurse, IncludeExcludeFilter filter, ProviderRuntime runtime) { // recursively get child names of containers or just the current child if the filter accepts it if (recurse && Item.IsContainer(path, runtime)) { ManuallyGetChildItemsFromContainer(provider, path, recurse, filter, runtime); return; } var childName = Path.ParseChildName(provider, path, runtime); if (filter.Accepts(childName)) { provider.GetItem(path, runtime); } }
private Stack <string> PathToStack(ContainerCmdletProvider provider, string path, ProviderRuntime runtime) { var componentStack = new Stack <string>(); while (!String.IsNullOrEmpty(path)) { var child = Path.ParseChildName(provider, path, runtime); componentStack.Push(child); var parentPath = Path.ParseParent(provider, path, "", runtime); if (parentPath.Equals(path)) { throw new PSInvalidOperationException("Provider's implementation of GetParentPath is inconsistent", "ParentOfPathIsPath", ErrorCategory.InvalidResult); } path = parentPath; } return(componentStack); }
private void ManuallyGetChildNames(ContainerCmdletProvider provider, string providerPath, string relativePath, ReturnContainers returnContainers, bool recurse, IncludeExcludeFilter filter, ProviderRuntime runtime) { // Affected by #trailingSeparatorAmbiguity // Sometimes, PS removes or appends a trailing slash to the providerPath // E.g. when the recurse == true, there is a trailing slash, but not when recurse == false. // As it calls the method with the slash being appended and not appended, PS doesn't seem to make // promises to the provider implementation whether or not the path has a trailing slash var childNames = GetValidChildNames(provider, providerPath, returnContainers, runtime); foreach (var childName in childNames) { // add the child only if the filter accepts it if (!filter.Accepts(childName)) { continue; } var path = Path.Combine(provider, relativePath, childName, runtime); runtime.WriteObject(path); } // check if we need to handle this recursively if (!recurse) { return; } // okay, we should use recursion, so get all child containers and call this function again childNames = GetValidChildNames(provider, providerPath, ReturnContainers.ReturnAllContainers, runtime); foreach (var childName in childNames) { var providerChildPath = Path.Combine(provider, providerPath, childName, runtime); if (Item.IsContainer(providerChildPath, runtime)) { // recursive call wirth child's provider path and relative path var relativeChildPath = Path.Combine(provider, relativePath, childName, runtime); ManuallyGetChildNames(provider, providerChildPath, relativeChildPath, returnContainers, true, filter, runtime); } } }