如何在同一级别的大括号之间提取字符串

想象一下，我有一个未知字符串，它遵循以下格式：

Blablabla
{
    "Some Text"
    2
    {
        "Sub Text"
         99
    }
    2
    {
        "Sub Text"
         99
    }
}
Blablabla2
{
    "Some Text"
    2
    {
        "Sub Text"
         99
    }
}

我需要能够从这个字符串中提取第一层分隔符（{和}）之间的每个子字符串。因此，在本例中，运行以下函数：

ExtractStringBetweenDelimitersOnSameLevel(string, "{", "}")

应该从原始字符串中提取以下子字符串，然后返回：

    "Some Text"
    2
    {
        "Sub Text"
         99
    }

问题是，由于第二层分隔符，它返回了一个较短的字符串。

这是我的代码：

const int Count(
   const std::string& haystack,
   const std::string& needle,
   const int starting_index,
   const int maximum_index)
{
   int total = 0;
   int offset = starting_index;
   size_t current_index = std::string::npos;
   while ((current_index = haystack.find(needle, offset)) != std::string::npos)
   {
      if (current_index >= maximum_index)
      {
         break;
      }
      total++;
      offset = static_cast<int>(current_index + needle.size());
   }
   return total;
}
const size_t FindNthDelimiter(
   const std::string& haystack,
   const std::string& needle,
   const int nth)
{
   int total_found = 0;
   int offset = 0;
   size_t current_index = std::string::npos;
   while ((current_index = haystack.find(needle, offset)) != std::string::npos)
   {
      total_found++;
      offset = static_cast<int>(current_index) + 1;
      if (total_found == nth)
      {
         return offset;
      }
   }
   std::cout << "String does not have nth element." << std::endl;
   return offset;
}
std::string ExtractStringBetweenDelimitersOnSameLevel(
   std::string& original_string,
   const std::string& opening_delimiter,
   const std::string& closing_delimiter)
{
   // Find the first delimiter...
   const size_t first_delimiter = original_string.find(opening_delimiter);
   if (first_delimiter != std::string::npos)
   {
      const size_t second_delimiter = original_string.find(closing_delimiter);
      if (second_delimiter != std::string::npos)
      {
         // Total first delimiters found until first closed delimiter...
         int total_first_delimiters = Count(original_string, opening_delimiter, static_cast<int>(first_delimiter), static_cast<int>(second_delimiter));
         const size_t index_of_nth_closer = FindNthDelimiter(original_string, closing_delimiter, total_first_delimiters);
         std::string needle = original_string.substr(first_delimiter + opening_delimiter.size(), index_of_nth_closer - opening_delimiter.size() - 1);
         original_string.erase(first_delimiter, index_of_nth_closer + closing_delimiter.size());
         return needle;
      }
   }
   return "";
}