protected virtual void GetChildNames(string path, ReturnContainers returnContainers)
 {
     using (PSTransactionManager.GetEngineProtectionScope())
     {
         throw PSTraceSource.NewNotSupportedException("SessionStateStrings", "CmdletProvider_NotSupported", new object[0]);
     }
 }

 public Collection<string> GetNames(string[] path, ReturnContainers returnContainers, bool recurse, bool force,
                                    bool literalPath)
 {
     var runtime = new ProviderRuntime(SessionState, force, literalPath);
     GetNames(path, returnContainers, recurse, runtime);
     var packedResults = runtime.ThrowFirstErrorOrReturnResults();
     var results = (from r in packedResults select r.ToString()).ToList();
     return new Collection<string>(results);
 }

 protected override void GetChildNames(string path, ReturnContainers returnContainers)
 {
     if (PathIsDrive(path))
     {
         foreach (var repository in gitConfigManager.GetTrackedRepositories())
         {
             WriteItemObject(repository.Name, path, true);
         }
         return;
     }
     var trackedRepository = gitConfigManager.GetTrackedRepository(path);
     if (trackedRepository != null)
     {
         WriteItemObject("Git repo", path, false);
     }
 }

        protected override void GetChildNames(string path, ReturnContainers returnContainers)
        {
            using (new CurrentContextSession(this))
            {
                var children = GetChildNodesOfPath(path);
                if (String.IsNullOrEmpty(path))
                {
                    path = "/";
                }

                foreach (var child in children)
                {
                    WriteItemObject(child.Name, path, child.GetNodeChildren().Any());
                }
            }
        }

 protected override void GetChildNames(string path, ReturnContainers returnContainers)
 {
     path = NormalizePath(path);
     if (path.Length == 0)
     {
         foreach (var key in GetFilteredItems().Keys)
         {
             WriteItemObject(key, key, false);
         }
         return;
     }
     if (ItemExists(path))
     {
         WriteItemObject(path, path, false);
     }
 }

        protected override void GetChildNames(string path, ReturnContainers returnContainers)
        {
            path = NormalizePath(path);

            // check for a named child
            if (path.Length > 0)
            {
                object item = GetSessionStateItem(path);
                if (item != null)
                {
                    WriteItemObject(path, path, false);
                }
                return;
            }
            // otherwise names of all children
            IDictionary sessionStateTable = GetSessionStateTable();
            foreach (DictionaryEntry entry in sessionStateTable)
            {
                var name = (string)entry.Key;
                WriteItemObject(name, name, false);
            }
        }

 //internal object GetChildItemsDynamicParameters(Path path, bool recurse, CmdletProviderContext context);
 internal void GetChildNames(Path path, ReturnContainers returnContainers, ProviderRuntime runtime)
 {
     ProviderRuntime = runtime;
     GetChildNames(path, returnContainers);
 }

 protected override void GetChildNames(string path, ReturnContainers returnContainers)
 {
     if (TransactionAvailable())
     {
         using (CurrentPSTransaction)
         {
             base.GetChildNames(path, returnContainers);
             return;
         }
     }
     base.GetChildNames(path, returnContainers);
 }

 /// <summary>
 /// Gets names of the children of the specified path.
 /// </summary>
 /// 
 /// <param name="path">
 /// The path to the item from which to retrieve the child names.
 /// </param>
 /// 
 /// <param name="returnAllContainers">
 /// If true, the provider should return all containers, even if they
 /// don't match the filter.  If false, the provider should only return
 /// containers that do match the filter.
 /// </param>
 /// 
 /// <remarks>
 /// Providers override this method to give the user access to the 
 /// provider objects using the get-childitem -name cmdlet.
 /// 
 /// Providers that declare 
 /// <see cref="System.Management.Automation.Provider.ProviderCapabilities"/>
 /// of ExpandWildcards, Filter, Include, or Exclude should ensure that
 /// the path passed meets those requirements by accessing the 
 /// appropriate property from the base class. The exception to this is
 /// if <paramref name="returnAllContainers"/> is true, then any child 
 /// name for a container should be returned even if it doesn't match 
 /// the Filter, Include, or Exclude.
 /// 
 /// By default overrides of this method should not write the names of
 /// objects that are generally hidden from the user unless the Force 
 /// property is set to true. For instance, the FileSystem provider 
 /// should not call WriteItemObject for hidden or system files unless 
 /// the Force property is set to true. 
 /// 
 /// The provider implementation is responsible for preventing infinite 
 /// recursion when there are circular links and the like. An 
 /// appropriate terminating exception should be thrown if this
 /// situation occurs.
 /// 
 /// The child names are the leaf portion of the path. Example, for the
 /// file system the name for the path c:\windows\system32\foo.dll would
 /// be foo.dll or for the directory c:\windows\system32 would be
 /// system32.  For Active Directory the child names would be RDN values
 /// of the child objects of the container.
 /// 
 /// All names should be written to the WriteItemObject method.
 /// </remarks>
 protected override void GetChildNames( string path,
                             ReturnContainers returnAllContainers )
 {
     // Get the names of children at the specified path
     // and writing them
     // WriteItemObject( item, path, isContainer );
 }

        } // GetChildItems

        /// <summary>
        /// Return the names of all child items.
        /// </summary>
        /// <param name="path">The root path.</param>
        /// <param name="returnContainers">Not used.</param>
        protected override void GetChildNames(string path,
                                      ReturnContainers returnContainers)
        {
            // If the path represented is a drive, then the child items are
            // tables. get the names of all the tables in the drive.
            if (PathIsDrive(path))
            {
                foreach (DatabaseTableInfo table in GetTables())
                {
                    WriteItemObject(table.Name, path, true);
                } // foreach (DatabaseTableInfo...
            } // if (PathIsDrive...
            else
            {
                // Get type, table name and row number from path specified
                string tableName;
                int rowNumber;

                PathType type = GetNamesFromPath(path, out tableName, out rowNumber);

                if (type == PathType.Table)
                {
                    // Get all the rows in the table and then write out the 
                    // row numbers.
                    foreach (DatabaseRowInfo row in GetRows(tableName))
                    {
                        WriteItemObject(row.RowNumber, path, false);
                    } // foreach (DatabaseRowInfo...
                }
                else if (type == PathType.Row)
                {
                    // In this case the user has directly specified a row, hence
                    // just give that particular row
                    DatabaseRowInfo row = GetRow(tableName, rowNumber);

                    WriteItemObject(row.RowNumber, path, false);
                }
                else
                {
                    ThrowTerminatingInvalidPathException(path);
                }
            } // else
        } // GetChildNames

 protected override void GetChildNames(string path, ReturnContainers returnContainers)
 {
     base.GetChildNames(path, returnContainers);
 }

        protected override void GetChildNames(string path, ReturnContainers returnContainers)
        {
            var nodeFactory = GetNodeFactoryFromPath(path, false);
            if (null == nodeFactory)
            {
                return;
            }

            nodeFactory.ToList().ForEach(f => GetChildNames(path, f, returnContainers));
        }

 protected override void GetChildNames(string path, ReturnContainers returnContainers)
 {
     GetPathItems(path, false, true, returnContainers);
 }

 public Collection<string> GetNames(string[] path, ReturnContainers returnContainers, bool recurse, bool force, bool literalPath)
 {
     return this.sessionState.GetChildNames(path, returnContainers, recurse, force, literalPath);
 }

 protected override void GetChildNames(string path, ReturnContainers returnContainers)
 {
     foreach (var subItem in this.ZookeeperDriver.Zookeeper.GetChildren(path))
     {
         this.WriteNodeName( path, subItem );
     }
 }

 private void GetPathItems(string path, bool recurse, bool nameOnly, ReturnContainers returnContainers)
 {
     using (EnterContext(path))
     {
         DirectoryEntryInfo parent = GetEntryInfoFromPSPath(path);
         
         if (parent.IsContainer)
         {
             using (parent)
             {
                 GetPathItems(parent, recurse, nameOnly, returnContainers);
             }
         }
         else
         {
             WriteEntryInfo(parent, nameOnly);
         }
     }
 }

 protected override void GetChildNames(string path, ReturnContainers returnContainers)
 {
     // TODO: returnContainers
     GetChildren(Utilities.NormalizePath(path), false, true);
 }

        protected override void GetChildNames(string path, ReturnContainers returnContainers)
        {
            WriteVerbose(string.Format("SPOProvider::GetChildNames (Path = ’{0}’)", path));

            var folder = GetFileOrFolder(path) as Folder;
            if (folder != null)
            {
                var folderAndFiles = GetFolderItems(folder).ToArray();
                var serverRelaitivePath = GetServerRelativePath(path);
                foreach (var subFolder in folderAndFiles.OfType<Folder>().ToList())
                {
                    string name;
                    if (string.IsNullOrEmpty(subFolder.Name))
                    {
                        var serverRelativeUrl = IsPropertyAvailable(subFolder, "ServerRelativeUrl") ? subFolder.ServerRelativeUrl : subFolder.EnsureProperty(s => s.ServerRelativeUrl);
                        name = serverRelativeUrl.Split(PathSeparator.ToCharArray(), StringSplitOptions.RemoveEmptyEntries).Last();
                    }
                    else
                    {
                        name = subFolder.Name;
                    }
                    WriteItemObject(name, serverRelaitivePath, true);
                }
                foreach (var file in folderAndFiles.OfType<File>().ToList())
                {
                    WriteItemObject(file.Name, serverRelaitivePath, false);
                }
            }
            else
            {
                WriteErrorInternal("No folder at end of path", path, ErrorCategory.InvalidOperation);
            }
        }

 protected override void GetChildNames(string path, ReturnContainers returnContainers)
 {
     foreach (var childItem in CurrentChildItems.Where(ci => ci.LinkSelf == path))
     {
         WriteItemObject(childItem.Title, path, childItem.IsContainer);
     }
 }

        protected override void GetChildNames(string path, ReturnContainers returnContainers)
        {
            try
            {
                LogInfo("Executing GetChildNames(string path='{0}', string returnContainers='{1}')", path,
                    returnContainers);
                path = path.Replace("\\", "/");
                if (path.Contains("../"))
                {
                    path = path.Substring(path.LastIndexOf("../", StringComparison.Ordinal) + 2);
                }

                // apply filter
                WildcardPattern wildcard = null;

                if (!string.IsNullOrEmpty(Filter))
                {
                    wildcard = new WildcardPattern(Filter, WildcardOptions.IgnoreCase | WildcardOptions.Compiled);
                }

                var pageRef = GetItemForPath(path);
                if (pageRef != null)
                {
                    var children = pageRef.GetChildren();
                    foreach (Item child in children)
                    {
                        if (returnContainers == ReturnContainers.ReturnAllContainers || wildcard == null ||
                            wildcard.IsMatch(child.Name))
                        {
                            WriteItemObject(child.Name, child.GetProviderPath(), child.HasChildren);
                        }
                        if (Stopping)
                            return;
                    }
                }
                else
                {
                    Exception exception =
                        new IOException(string.Format("Cannot find path '{0}' because it does not exist.", path));
                    WriteError(new ErrorRecord(exception, "ItemDoesNotExist", ErrorCategory.ObjectNotFound, path));
                }
            }
            catch (Exception ex)
            {
                LogError(ex,
                    "Error while executing GetChildNames(string path='{0}', string returnContainers='{1}')",
                    path, returnContainers);
                throw;
            }
        }