def build_directive(cls, options):
        if not options.lb_listener:
            print('error: listener should be specified')
            return None

        forwardfor = options.forwardfor
        if forwardfor:
            mapper = {
                    'X_FORWARD_FOR': 1,
                    'QC_LB_ID': 2,
                    'QC_LB_IP': 4,
                    }
            headers = [h for h in explode_array(forwardfor) if h in mapper]
            forwardfor = 0
            for header in headers:
                forwardfor |= mapper[header]

        return {
                'loadbalancer_listener': options.lb_listener,
                'loadbalancer_listener_name': options.lb_listener_name,
                'balance_mode': options.balance_mode,
                'forwardfor': forwardfor,
                'healthy_check_method': options.healthy_check_method,
                'healthy_check_option': options.healthy_check_option,
                'session_sticky': options.session_sticky,
                'server_certificate_id': explode_array(options.server_certificate_id),
                }

    def build_directive(cls, options):
        directive = {
            "group_role_rules": explode_array(options.group_role_rules),
            "group_roles": explode_array(options.group_roles),
        }

        return directive

 def build_directive(cls, options):
     return {
             'jobs': explode_array(options.jobs),
             'status': explode_array(options.status),
             'job_action': options.job_action,
             'offset':options.offset,
             'limit': options.limit,
             }

 def build_directive(cls, options):
     return {
             'routers': explode_array(options.routers),
             'status': explode_array(options.status),
             'verbose': options.verbose,
             'search_word': options.search_word,
             'offset':options.offset,
             'limit': options.limit,
             }

 def build_directive(cls, options):
     return {
             'keypairs': explode_array(options.keypairs),
             'encrypt_method': explode_array(options.encrypt_method),
             'search_word': options.search_word,
             'verbose': options.verbose,
             'offset':options.offset,
             'limit': options.limit,
             }

 def build_directive(cls, options):
     return {
             'volumes': explode_array(options.volumes),
             'instance_id': explode_array(options.instance_id),
             'status': explode_array(options.status),
             'search_word': options.search_word,
             'offset':options.offset,
             'limit': options.limit,
             }

    def build_directive(cls, options):
        keypairs = explode_array(options.keypairs)
        instances = explode_array(options.instances)
        if not keypairs or not instances:
            return None

        return {
                'keypairs': keypairs,
                'instances': instances,
                }

 def build_directive(cls, options):
     return {
             'eips': explode_array(options.eips),
             'status': explode_array(options.status),
             'eip_group': explode_array(options.eip_group),
             'instance_id': options.instance_id,
             'search_word': options.search_word,
             'offset':options.offset,
             'limit': options.limit,
             }

 def build_directive(cls, options):
     return {
             'loadbalancers': explode_array(options.loadbalancers),
             'status': explode_array(options.status),
             'verbose': options.verbose,
             'search_word': options.search_word,
             'offset':options.offset,
             'limit': options.limit,
             'tags': explode_array(options.tags),
             }

 def build_directive(cls, options):
     return {
             'vxnets': explode_array(options.vxnets),
             'vxnet_type': options.vxnet_type,
             'search_word': options.search_word,
             'verbose': options.verbose,
             'offset': options.offset,
             'limit': options.limit,
             'tags': explode_array(options.tags),
             }

 def build_directive(cls, options):
     return {
         'nics': explode_array(options.nics),
         'status': explode_array(options.status),
         'nic_name': options.nic_name,
         'vxnets': explode_array(options.vxnets),
         'vxnet_type': explode_array(options.vxnet_type),
         'offset': options.offset,
         'limit': options.limit,
     }

 def build_directive(cls, options):
     directive = {
         "s2_accounts": explode_array(options.s2_accounts),
         "account_types": explode_array(options.account_types),
         "account_name": options.account_name,
         "search_word": options.search_word,
         "verbose": options.verbose,
     }
     
     return directive

 def build_directive(cls, options):
     return {
             'instances': explode_array(options.instances),
             'status': explode_array(options.status),
             'image_id': explode_array(options.image_id),
             'instance_type': explode_array(options.instance_type),
             'search_word': options.search_word,
             'verbose': options.verbose,
             'offset':options.offset,
             'limit': options.limit,
             }

    def build_directive(cls, options):
        resource_tag_pairs = explode_array(options.resource_tag_pairs, ";")

        for i, p in enumerate(resource_tag_pairs):
            tag_id, resource_type, resource_id = explode_array(p, ":")
            resource_tag_pairs[i] = {"tag_id": tag_id,
                                     "resource_type": resource_type,
                                     "resource_id": resource_id}

        directive = {"resource_tag_pairs": resource_tag_pairs}
        return directive

 def build_directive(cls, options):
     keypairs = explode_array(options.keypairs)
     instances = explode_array(options.instances)
     if not keypairs or not instances:
         print 'note: [keypairs] and [instances] should be specified'
         return None
         
     return {
             'keypairs': keypairs,
             'instances': instances,
             }

 def build_directive(cls, options):
     directive = {
         "s2_servers": explode_array(options.s2_servers),
         "service_types": explode_array(options.service_types),
         "status": explode_array(options.status),
         "search_word": options.search_word,
         "tags": explode_array(options.tags),
         "verbose": options.verbose,
     }
     
     return directive

    def build_directive(cls, options):
        directive = {
            "resource_groups": explode_array(options.resource_groups),
            "resources": explode_array(options.resources),
            "verbose": options.verbose,
            "sort_key": options.sort_key,
            "reverse": options.reverse,
            "limit": options.limit,
            "offset": options.offset
        }

        return directive

 def build_directive(cls, options):
     for key in ['s2_groups', 's2_accounts']:
         if not hasattr(options, key):
             print("error: [%s] should be specified." % key)
             return None
     
     directive = {
         "s2_groups": explode_array(options.s2_groups),
         "s2_accounts": explode_array(options.s2_accounts),
     }
     
     return directive

 def build_directive(cls, options):
     directive = {
         "alarm_policies": explode_array(options.alarm_policies),
         "alarm_policy_name": options.alarm_policy_name,
         "alarm_policy_type": options.alarm_policy_type,
         "search_word": options.search_word,
         "resource": options.resource,
         "status": explode_array(options.status),
         "verbose": options.verbose,
     }
     
     return directive

 def build_directive(cls, options):
     return {
             'snapshots': explode_array(options.snapshots),
             'snapshot_type': options.snapshot_type,
             'resource_id': options.resource_id,
             'status': explode_array(options.status),
             'search_word': options.search_word,
             'verbose': options.verbose,
             'offset':options.offset,
             'limit': options.limit,
             'tags': explode_array(options.tags),
             }