Get a list containing the names of the fields that are used in the
    xso.Query.

    :param payload: Query object o be
    :type payload: :class:`~aioxmpp.ibr.Query`
    :return: :attr:`list`
176800
def get_used_fields(payload):
    
    return [
        tag
        for tag, descriptor in payload.CHILD_MAP.items()
        if descriptor.__get__(payload, type(payload)) is not None
    ]
645881
def get_field_names(ctx):
    """"""
    # this does not include labels and literals, only rule names and token names
    # TODO: check ANTLR parser template for full exclusion list
    fields = [
        field
        for field in type(ctx).__dict__
        if not field.startswith("__")
        and field not in ["accept", "enterRule", "exitRule", "getRuleIndex", "copyFrom"]
    ]
    return fields
468048
def getVals(self):
        
        return [(name, self._fieldValDict.get(name)) 
                for name in self._fieldNameList]
991148
public List<ADStructure> parse(byte[] payload)
    {
        if (payload == null)
        {
            return null;
        }

        return parse(payload, 0, payload.length);
    }
46643
def get_field_names(self):
        
        if self.add:
            return ['date', 'elem', 'value'] + [flag for flag in self.add]
        else:
            field_names = ['date']
            for elem in self.parameter:
                # namedtuple doesn't like numeric field names
                if elem.isdigit():
                    elem = "e%s" % elem
                field_names.append(elem)
            return field_names
92934
def get_fields(self):
        
        field_mapping = OrderedDict()
        for field, data in self.instance.items():
            field_mapping.update(
                {field: self.facet_dict_field_class(
                    child=self.facet_list_field_class(child=self.facet_field_serializer_class(data)), required=False)}
            )

        if self.serialize_objects is True:
            field_mapping["objects"] = serializers.SerializerMethodField()

        return field_mapping
39299
def get_vendor_extension_fields(mapping):
    
    return {k: v for k, v in mapping.items() if k.startswith('x-')}
960995
def _field_names_(self):
        
        ret = []
        for n in six.iterkeys(self.__swagger_fields__):
            new_n = self.__swagger_rename__.get(n, None)
            ret.append(new_n) if new_n else ret.append(n)
        
        return ret
792971
def getfieldnamesendswith(idfobject, endswith):
    """"""
    objls = idfobject.objls
    tmp = [name for name in objls if name.endswith(endswith)]
    if tmp == []:
        pass
    return [name for name in objls if name.endswith(endswith)]
1122357
def query(self):
        
        query_context = QueryContext(**json.loads(request.form.get('query_context')))
        security_manager.assert_datasource_permission(query_context.datasource)
        payload_json = query_context.get_payload()
        return json.dumps(
            payload_json,
            default=utils.json_int_dttm_ser,
            ignore_nan=True,
        )
1122670
def get_fields(self):
        
        fields = super(BaseHookSerializer, self).get_fields()
        fields['event_types'] = serializers.MultipleChoiceField(
            choices=loggers.get_valid_events(), required=False)
        fields['event_groups'] = serializers.MultipleChoiceField(
            choices=loggers.get_event_groups_keys(), required=False)
        return fields
430306
def fields(self):
        ''''''
        key = self.id + ':fields'
        encoding = self.client.encoding
        return tuple(sorted((f.decode(encoding)
                             for f in self.client.smembers(key))))
840079
def fields(self):
        ''''''
        out = dict()
        for operator in self.ops:
            out.update(**operator.fields)

        return out
790072
def p_object_field_list(self, p):
        
        obj = p[1].copy()
        obj.update(p[2])
        p[0] = obj
626468
def get_fields(self, strip_labels=False):
        
        if strip_labels:
            return [
                f[0] if type(f) in (tuple, list) else f for f in self.fields
            ]
        return self.fields
1276951
def get_displayable_field_names(self):
        
        return [
            f.name
            for f in self.model._meta.get_fields()
            if not f.one_to_many
        ]
481074
def payload(self):
        
        payload = {'type': self.resource_type(), 'attributes': self.attributes}
        if self.id:
            payload['id'] = self.id
        return payload