def create(self, name, action='permit', goto=None, finish=False,
               call=None, comment=None, add_pos=None, after=None,
               before=None, **match_condition):
        """
        Create a route map rule. You can provide match conditions
        by using keyword arguments specifying the required types.
        You can also create the route map rule and add match conditions
        after.
        
        :param str name: name for this rule
        :param str action: permit or deny
        :param str goto: specify a rule section to goto after if there
            is a match condition. This will override the finish parameter
        :param bool finish: finish stops the processing after a match condition.
            If finish is False, processing will continue to the next rule.
        :param RouteMap call: call another route map after matching. 
        :param str comment: optional comment for the rule
        :param int add_pos: position to insert the rule, starting with position 1. If
            the position value is greater than the number of rules, the rule is inserted at
            the bottom. If add_pos is not provided, rule is inserted in position 1. Mutually
            exclusive with ``after`` and ``before`` params.
        :param str after: Rule tag to add this rule after. Mutually exclusive with ``add_pos``
            and ``before`` params.
        :param str before: Rule tag to add this rule before. Mutually exclusive with ``add_pos``
            and ``after`` params.
        :param match_condition: keyword values identifying initial
            values for the match condition. Valid keyword arguments
            are 'access_list', 'next_hop', 'metric' and 'peer_address'.
            You can also optionally pass the keyword 'match_condition'
            with an instance of MatchCondition.
        :raises CreateRuleFailed: failure to insert rule with reason
        :raises ElementNotFound: if references elements in a match condition
            this can be raised when the element specified is not found.
        
        .. seealso:: :class:`~MatchCondition` for valid elements and
            expected values for each type.
        """
        json = {'name': name,
                'action': action,
                'finish': finish,
                'goto': goto.href if goto else None,
                'call_route_map_ref': None if not call else call.href,
                'comment': comment}
        
        if not match_condition:
            json.update(match_condition=[])
        else:
            if 'match_condition' in match_condition:
                conditions = match_condition.pop('match_condition')
            else:
                conditions = MatchCondition()
                if 'peer_address' in match_condition:
                    conditions.add_peer_address(
                        match_condition.pop('peer_address'))
                if 'next_hop' in match_condition:
                    conditions.add_next_hop(
                        match_condition.pop('next_hop'))
                if 'metric' in match_condition:
                    conditions.add_metric(
                        match_condition.pop('metric'))
                if 'access_list' in match_condition:
                    conditions.add_access_list(
                        match_condition.pop('access_list'))
            
            json.update(match_condition=conditions.conditions)
        
        params = None
        href = self.href 
        if add_pos is not None: 
            href = self.add_at_position(add_pos) 
        elif before or after: 
            params = self.add_before_after(before, after)
        
        return ElementCreator(
            self.__class__,
            exception=CreateRuleFailed, 
            href=href,
            params=params, 
            json=json)