operation_list : define_operation operation_list
                   | define_operation
357375
def p_operation_list(p):
    
    if len(p) == 3:
        p[0] = p[1] + p[2]
    elif len(p) == 2:
        p[0] = p[1]
    else:
        raise RuntimeError("Invalid production rules 'p_operation_list'")
980470
def print_operations
      ops = @operations.reverse.map do |op|
        attr_s = " #{op.attribute}" if op.attribute
        "#{op.type.to_s.capitalize_first} #{op.subject.qp}#{attr_s}"
      end
      ops.qp
    end
1271252
def do_list(self, line):
        
        path = self._split_args(line, 0, 1, pad=False)
        if len(path):
            path = path[0]
        self._command_processor.list_objects(path)
234253
def operation(self):
        
        if not self._operation_calculated:
            self._operation_calculated = True
            self._extract_operation_and_namespace()

        return self._operation
1164411
def DEFINE_list(self, name, default, help, constant=False):
    """"""
    self.AddOption(
        type_info.List(
            name=name,
            default=default,
            description=help,
            validator=type_info.String()),
        constant=constant)
63627
def define_operations
      @info.operations.each do |op| 
        self.class.__send__(:define_method, op.name) do |*params|
          jargs, jtypes = java_args(op.signature, params)
          @server.invoke @object_name, op.name, jargs, jtypes
        end
      end
    end
595286
def serialize_operations(self, operations):
        """"""

        serialized_ops = []
        for operation in operations:
            serializer = self.get_serializer_class(operation.__class__)
            serialized_ops.append(serializer(operation).data)
        return serialized_ops
70625
def write(operations)
      buf = ""
      operations.each do |operation|
        operation.request_id = (@request_id += 1)
        operation.serialize(buf)
      end
      with_connection do |socket|
        socket.write(buf)
      end
    end
421735
def group_list(auth=None, **kwargs):
    '''
    
    '''
    cloud = get_operator_cloud(auth)
    kwargs = _clean_kwargs(**kwargs)
    return cloud.list_groups(**kwargs)
302051
def parse_operations(self):
        
        resource_defs = {
            getmeta(resources.Error).resource_name: resource_definition(resources.Error),
            getmeta(resources.Listing).resource_name: resource_definition(resources.Listing),
        }

        paths = collections.OrderedDict()
        for path, operation in self.parent.op_paths():
            # Cut of first item (will be the parents path)
            path = '/' + path[1:]  # type: UrlPath

            # Filter out swagger endpoints
            if self.SWAGGER_TAG in operation.tags:
                continue

            # Add to resource definitions
            if operation.resource:
                resource_defs[getmeta(operation.resource).resource_name] = resource_definition(operation.resource)

            # Add any resource definitions from responses
            if operation.responses:
                for response in operation.responses:
                    resource = response.resource
                    # Ensure we have a resource
                    if resource and resource is not DefaultResource:
                        resource_name = getmeta(resource).resource_name
                        # Don't generate a resource definition if one has already been created.
                        if resource_name not in resource_defs:
                            resource_defs[resource_name] = resource_definition(resource)

            # Add path parameters
            path_spec = paths.setdefault(path.format(self.swagger_node_formatter), {})

            # Add parameters
            parameters = self.generate_parameters(path)
            if parameters:
                path_spec['parameters'] = parameters

            # Add methods
            for method in operation.methods:
                path_spec[method.value.lower()] = operation.to_swagger()

        return paths, resource_defs
1374034
def list_action(**kwargs):
    
    def decorator(func):
        func.action = True
        func.detail = False
        func.kwargs = kwargs
        return func
    return decorator
173137
def list_and_select_op_script
      puts "List of available operational scripts:"
      puts "------------------------------------------------------------"
      for i in 0..@op_scripts.length - 1
        puts "  %3d. #{@op_scripts[i][0]}" % i
      end
      puts "------------------------------------------------------------"
      while true
        printf "Type the number of the script to run and press Enter (Ctrl-C to quit): "
        script_id = Integer(gets.chomp) rescue -1
        if script_id >= 0 && script_id < @op_scripts.length
          puts "Script choice: #{script_id}. #{@op_scripts[ script_id ][0]}"
          break
        else
          puts "#{script_id < 0 ? 'Invalid input' : 'Input out of range'}."
        end
      end

      return script_id
    end
298971
def p_operation_definition3(self, p):
        
        p[0] = self.operation_cls(p[1])(
            selections=p[4],
            name=p[2],
            directives=p[3],
        )
399743
def as_list(cls, protocol=Protocol.http, *args, **kwargs):
        '''  '''
        return cls.as_view('list', protocol, *args, **kwargs)
346044
def add_operations(self, root, definitions):
        
        dsop = Element('operation', ns=soapns)
        for c in root.getChildren('operation'):
            op = Facade('Operation')
            op.name = c.get('name')
            sop = c.getChild('operation', default=dsop)
            soap = Facade('soap')
            soap.action = '"%s"' % sop.get('soapAction', default='')
            soap.style = sop.get('style', default=self.soap.style)
            soap.input = Facade('Input')
            soap.input.body = Facade('Body')
            soap.input.headers = []
            soap.output = Facade('Output')
            soap.output.body = Facade('Body')
            soap.output.headers = []
            op.soap = soap
            input = c.getChild('input')
            if input is None:
                input = Element('input', ns=wsdlns)
            body = input.getChild('body')
            self.body(definitions, soap.input.body, body)
            for header in input.getChildren('header'):
                self.header(definitions, soap.input, header)
            output = c.getChild('output')
            if output is None:
                output = Element('output', ns=wsdlns)
            body = output.getChild('body')
            self.body(definitions, soap.output.body, body)
            for header in output.getChildren('header'):
                self.header(definitions, soap.output, header)
            faults = []
            for fault in c.getChildren('fault'):
                sf = fault.getChild('fault')
                if sf is None:
                    continue
                fn = fault.get('name')
                f = Facade('Fault')
                f.name = sf.get('name', default=fn)
                f.use = sf.get('use', default='literal')
                faults.append(f)
            soap.faults = faults
            self.operations[op.name] = op
1326324
def supported_operations(self):
        
        return tuple(op for op in backend.DIR_OPS if self._dir_ops & op)
50057
def operations(custom_headers:nil)
      response = operations_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end