docs: def args(self, decl_string):
          """
          Extracts a list of arguments from the provided declaration string.
  
          Implementation detail. Example usages:
          Input: myClass<std::vector<int>, std::vector<double>>
          Output: [std::vector<int>, std::vector<double>]
  
          Args:
             decl_string (str): the full declaration string
  
          Returns:
              list: list of arguments as strings
  
          """
          args_begin = decl_string.find(self.__begin)
          args_end = decl_string.rfind(self.__end)
          if -1 in (args_begin, args_end) or args_begin == args_end:
              raise RuntimeError(
                  "%s doesn't validate template instantiation string" %
                  decl_string)
  
          args_only = decl_string[args_begin + 1: args_end].strip()
  
          # The list of arguments to be returned
          args = []
  
          parentheses_blocks = []
          prev_span = 0
          if self.__begin == "<":
              # In case where we are splitting template names, there
              # can be parentheses blocks (for arguments) that need to be taken
              # care of.
  
              # Build a regex matching a space (\s)
              # + something inside parentheses
              regex = re.compile("\\s\\(.*?\\)")
              for m in regex.finditer(args_only):
                  # Store the position and the content
                  parentheses_blocks.append([m.start() - prev_span, m.group()])
                  prev_span = m.end() - m.start()
                  # Cleanup the args_only string by removing the parentheses and
                  # their content.
                  args_only = args_only.replace(m.group(), "")
  
          # Now we are trying to split the args_only string in multiple arguments
          previous_found, found = 0, 0
          while True:
              found = self.__find_args_separator(args_only, previous_found)
              if found == -1:
                  args.append(args_only[previous_found:].strip())
                  # This is the last argument. Break out of the loop.
                  break
              else:
                  args.append(args_only[previous_found: found].strip())
              previous_found = found + 1  # skip found separator
  
          # Get the size and position for each argument
          absolute_pos_list = []
          absolute_pos = 0
          for arg in args:
              absolute_pos += len(arg)
              absolute_pos_list.append(absolute_pos)
  
          for item in parentheses_blocks:
              # In case where there are parentheses blocks we add them back
              # to the right argument
              parentheses_block_absolute_pos = item[0]
              parentheses_block_string = item[1]
  
              current_arg_absolute_pos = 0
              for arg_index, arg_absolute_pos in enumerate(absolute_pos_list):
                  current_arg_absolute_pos += arg_absolute_pos
                  if current_arg_absolute_pos >= parentheses_block_absolute_pos:
                      # Add the parentheses block back and break out of the loop.
                      args[arg_index] += parentheses_block_string
                      break
  
          return args