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
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.