public unsafe void Enumerate(GitConfigurationEnumerationCallback cb)
        {
            ThrowIfDisposed();

            int native_cb(git_config_entry entry, void *payload)
            {
                if (entry != null)
                {
                    string name  = entry.GetName();
                    string value = entry.GetValue();

                    if (!cb(name, value))
                    {
                        return(GIT_ITEROVER);
                    }
                }

                return(GIT_OK);
            }

            _trace.WriteLine("Enumerating Git configuration entries...");
            var result = git_config_foreach(_config, native_cb, (void *)IntPtr.Zero);

            switch (result)
            {
            case GIT_OK:
            case GIT_ITEROVER:
                _trace.WriteLine("Enumeration complete.");
                break;

            default:
                ThrowIfError(result, nameof(git_config_foreach));
                break;
            }
        }
        public void Enumerate(GitConfigurationEnumerationCallback cb)
        {
            string level = GetLevelFilterArg();

            using (Process git = _git.CreateProcess($"config --null {level} --list"))
            {
                git.Start();
                // To avoid deadlocks, always read the output stream first and then wait
                // TODO: don't read in all the data at once; stream it
                string data = git.StandardOutput.ReadToEnd();
                git.WaitForExit();

                switch (git.ExitCode)
                {
                case 0:     // OK
                    break;

                default:
                    throw new Exception(
                              $"Failed to enumerate all Git configuration entries. Exit code '{git.ExitCode}' (level={_filterLevel})");
                }

                IEnumerable <string> entries = data.Split('\0').Where(x => !string.IsNullOrWhiteSpace(x));
                foreach (string entry in entries)
                {
                    string[] kvp = entry.Split(new[] { '\n' }, count: 2);

                    if (kvp.Length == 2 && !cb(kvp[0], kvp[1]))
                    {
                        break;
                    }
                }
            }
        }
 public void Enumerate(GitConfigurationLevel level, GitConfigurationEnumerationCallback cb)
 {
     foreach (var(dictLevel, dict) in GetDictionaries(level))
     {
         foreach (var kvp in dict)
         {
             foreach (var value in kvp.Value)
             {
                 var entry = new GitConfigurationEntry(kvp.Key, value);
                 if (!cb(entry))
                 {
                     break;
                 }
             }
         }
     }
 }
        public void Enumerate(GitConfigurationLevel level, GitConfigurationEnumerationCallback cb)
        {
            string levelArg = GetLevelFilterArg(level);

            using (Process git = _git.CreateProcess($"config --null {levelArg} --list"))
            {
                git.Start();
                // To avoid deadlocks, always read the output stream first and then wait
                // TODO: don't read in all the data at once; stream it
                string data = git.StandardOutput.ReadToEnd();
                git.WaitForExit();

                switch (git.ExitCode)
                {
                case 0:     // OK
                    break;

                default:
                    _trace.WriteLine($"Failed to enumerate config entries (exit={git.ExitCode}, level={level})");
                    throw GitProcess.CreateGitException(git, "Failed to enumerate all Git configuration entries");
                }

                var name  = new StringBuilder();
                var value = new StringBuilder();
                int i     = 0;
                while (i < data.Length)
                {
                    name.Clear();
                    value.Clear();

                    // Read key name (LF terminated)
                    while (i < data.Length && data[i] != '\n')
                    {
                        name.Append(data[i++]);
                    }

                    if (i >= data.Length)
                    {
                        _trace.WriteLine("Invalid Git configuration output. Expected newline terminator (\\n) after key.");
                        break;
                    }

                    // Skip the LF terminator
                    i++;

                    // Read value (null terminated)
                    while (i < data.Length && data[i] != '\0')
                    {
                        value.Append(data[i++]);
                    }

                    if (i >= data.Length)
                    {
                        _trace.WriteLine("Invalid Git configuration output. Expected null terminator (\\0) after value.");
                        break;
                    }

                    // Skip the null terminator
                    i++;

                    var entry = new GitConfigurationEntry(name.ToString(), value.ToString());

                    if (!cb(entry))
                    {
                        break;
                    }
                }
            }
        }