docs: def get_values(self, config_manager, ignore_mismatches, obj_hook=DotDict):
          """This is the black sheep of the crowd of ValueSource implementations.
          It needs to know ahead of time all of the parameters that it will need,
          but we cannot give it.  We may not know all the parameters because
          not all classes may have been expanded yet.  The two parameters allow
          this ValueSource implementation to know what the parameters  have
          already been defined.  The 'ignore_mismatches' parameter tells the
          implementation if it can or cannot ignore extraneous commandline
          options.  The last time this function is called, it will be required
          to test for illegal commandline options and respond accordingly.
  
          Unlike many of the Value sources, this method cannot be "memoized".
          The return result depends on an internal state within the parameter
          'config_manager'.  Any memoize decorator for this method would requrire
          capturing that internal state in the memoize cache key.
          """
          short_options_str, long_options_list = self.getopt_create_opts(
              config_manager.option_definitions
          )
          try:
              if ignore_mismatches:
                  fn = ValueSource.getopt_with_ignore
              else:
                  fn = getopt.gnu_getopt
              # here getopt looks through the command line arguments and
              # consumes the defined switches.  The things that are not
              # consumed are then offered as the 'args' variable of the
              # parent configuration_manager
              getopt_options, config_manager.args = fn(self.argv_source,
                                                       short_options_str,
                                                       long_options_list)
          except getopt.GetoptError as x:
              raise NotAnOptionError(str(x))
          command_line_values = obj_hook()
          for opt_name, opt_val in getopt_options:
              if opt_name.startswith('--'):
                  name = opt_name[2:]
              else:
                  name = self.find_name_with_short_form(
                      opt_name[1:],
                      config_manager.option_definitions,
                      ''
                  )
                  if not name:
                      raise NotAnOptionError(
                          '%s is not a valid short form option' % opt_name[1:]
                      )
              option_ = config_manager._get_option(name)
              if option_.from_string_converter == boolean_converter:
                  command_line_values[name] = not option_.default
              else:
                  command_line_values[name] = opt_val
          for name, value in zip(
              self._get_arguments(
                  config_manager.option_definitions,
                  command_line_values
              ),
              config_manager.args
          ):
              command_line_values[name] = value
          return command_line_values