Gets the name to reference the sorted field

        :return: the name to reference the sorted field
        :rtype: str
13531
def get_name(self, use_alias=True):
        
        if self.desc:
            direction = 'DESC'
        else:
            direction = 'ASC'

        if use_alias:
            return '{0} {1}'.format(self.field.get_identifier(), direction)
        return '{0} {1}'.format(self.field.get_select_sql(), direction)
212427
def get_name(self):
        
        if self.OP > 0xff:
            if self.OP >= 0xf2ff:
                return DALVIK_OPCODES_OPTIMIZED[self.OP][1][0]
            return DALVIK_OPCODES_EXTENDED_WIDTH[self.OP][1][0]
        return DALVIK_OPCODES_FORMAT[self.OP][1][0]
419937
def name(self):
        
        if not hasattr(self, '_name'):
            self._name = re.search('[a-z]+\.([a-z]+)\.([a-z]+)', str(self.__class__), re.IGNORECASE).group(2)

        return self._name
777868
def name(self):
        
        try:
            return self._name
        except AttributeError:
            if self.is_task:
                try:
                    return self.pos_str
                except:
                    return os.path.basename(self.workdir)
            else:
                return os.path.basename(self.workdir)
434279
def get_name(self):
        
        if self.name_idx_value == None:
            self.name_idx_value = self.CM.get_string(self.name_idx)

        return self.name_idx_value
304975
def name(self):
        
        if self._name:
            return self._name
        return [
            line.strip() for line in self.__doc__.split("\n")
            if line.strip()][0]
1351876
def get_name_for(self, dynamic_part):
        
        name = self.format % dynamic_part
        if not self._accept_name(name):
            raise ImplementationError('It seems that pattern and format do not '
                                      'match for the field "%s"' % self.name)
        return name
1227688
def attachment_name(self):
        
        if self.__attachment_name is not None:
            return self.__attachment_name
        if self.__attachment_name_property:
            return getattr(self, self.__attachment_name_property, '')
        else:
            # property order resolution:
            # 1) try property 'subject'
            # 2) try property 'name'
            try:
                attachment_name = getattr(self, 'subject')
            except AttributeError:
                attachment_name = getattr(self, 'name', '')
            return attachment_name
42103
def get_next_sort_string(self, field):
        
        # self.sort_field is the currect sort field
        if field == self.sort_field:
            next_sort = self.toggle_sort_order() + field
        else:
            default_order_for_field = \
                self._allowed_sort_fields[field]['default_direction']
            next_sort = default_order_for_field + field
        return self.get_sort_string(next_sort)
1066939
def _descriptor_names(self):
        

        descriptor_names = []

        for name in dir(self):
            try:
                attr = getattr(type(self), name)

                if isinstance(attr, DJANGO_RELATED_FIELD_DESCRIPTOR_CLASSES):
                    descriptor_names.append(name)

            except AttributeError:
                pass

        return descriptor_names
1156769
def qualified_name(self):
        

        parent = self.full_parent_name
        if parent:
            return parent + ' ' + self.name
        else:
            return self.name
1300047
def getNamedItem(self, name: str) -> Optional[Attr]:
        
        return self._dict.get(name, None)
845548
def get_field_names(self, declared_fields, info):
        
        meta_fields = getattr(self.Meta, 'meta_fields', [])

        declared = OrderedDict()
        for field_name in set(declared_fields.keys()):
            field = declared_fields[field_name]
            if field_name not in meta_fields:
                declared[field_name] = field
        fields = super(ModelSerializer, self).get_field_names(declared, info)
        return list(fields) + list(getattr(self.Meta, 'meta_fields', list()))
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
708488
def latitude_field_name(self):
        
        if self._lat_field_name is None:
            self._lat_field_name = self.name + '_lat'
        return self._lat_field_name
200770
public String getSortName() {

        if (m_sort == SORT_DATE_CREATED) {
            return SORT_NAMES[1];
        }
        if (m_sort == SORT_DATE_LASTMODIFIED) {
            return SORT_NAMES[2];
        }
        if (m_sort == SORT_TITLE) {
            return SORT_NAMES[3];
        }
        return SORT_NAMES[0];
    }
1182503
def names(self):
        
        # We must sort to preserve the order between calls.
        # The set comprehension is to drop the duplicates.
        return tuple(sorted({
            instr.arg for instr in self.instrs if instr.uses_name
        }))