For non-specific queries, this will return the actual name in the
        result.
179804
def get_name(self, data):
        
        if self.node.specific_attribute:
            return self.node.name
        name = data.get(self.predicate_var)
        if str(RDF.type) in [self.node.name, name]:
            return '$schema'
        if name.startswith(PRED):
            name = name[len(PRED):]
        return name
1272818
def name(self, name=None):
        ''''''
        if name:
            self._name = name
            return self
        return self._name
355215
def name(self):
        
        if self.site_name:
            return "Int_{}_{}_mult{}".format(self.site.specie, self.site_name, self.multiplicity)
        else:
            return "Int_{}_mult{}".format(self.site.specie, self.multiplicity)
325578
def query_names(self, pat):
        """"""

        for item in self.chnames.items():
            if fnmatch.fnmatchcase(item[1], pat):
                print item
162550
def get_unique_name(self, name):
        

        if name not in self._db:
            self._db[name] = 0
            return name
        else:
            index = self._db[name]
            self._db[name] = index + 1
            return f"{name}_{index}"
319863
def name():
        
        result = ""

        if RandomBoolean.chance(3, 5):
            result += random.choice(_name_prefixes) + " "

        result += random.choice(_first_names) + " " + random.choice(_last_names)

        if RandomBoolean.chance(5, 10):
            result += " " + random.choice(_name_suffixes)

        return result
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
670172
def _get_name(self):
        
        if self._name is None:
            self._name = self._generate_name()
        return self._name
394199
def get_name_history( self, name, offset=None, count=None, reverse=False):
        
        cur = self.db.cursor()
        name_hist = namedb_get_history( cur, name, offset=offset, count=count, reverse=reverse )
        return name_hist
1198909
def getProjectionForQueryName(self, query_name):
        
        projectionFileName = query_name + '.pyql'
        projectionText = self._getText(projectionFileName)
        return projectionText
1012858
def _maybe_get_default_name(self, name):
        
        if name is None and self.uri.fragment:
            name = self.uri.fragment
        return name
1013864
def name(self):
        """"""
        return self.TYPES.get(self._type, self.TYPES[idaapi.o_idpspec0])
319159
def full_name(self):
        
        full_name = self.first_name
        if self.last_name:
            full_name += ' ' + self.last_name
        return full_name
1069201
public String getName() {
		String name = this.getNodeName();
		if (this.isLeaf()) {
			int colonIndex = name.indexOf(":");
			if (colonIndex > 0) {
				// Strip the GET/POST etc off
				name = name.substring(colonIndex+1);
			}
		}
		return name; 
	}
65232
def named(self, name):
        ''''''
        name = self.serialize(name)
        return self.get_by('name', name)
219985
def name(self):
    """"""
    row_index = getattr(self.path_spec, 'row_index', None)
    if row_index is not None:
      return 'OFFSET {0:d}'.format(row_index)

    row_condition = getattr(self.path_spec, 'row_condition', None)
    if row_condition is not None:
      if len(row_condition) > 2 and isinstance(
          row_condition[2], py2to3.STRING_TYPES):
        return 'WHERE {0:s} {1:s} \'{2:s}\''.format(*row_condition)
      return 'WHERE {0:s} {1:s} {2!s}'.format(*row_condition)

    # Directory name is full name of column: <table>.<column>
    table_name = getattr(self.path_spec, 'table_name', None)
    column_name = getattr(self.path_spec, 'column_name', None)
    if table_name and column_name:
      return '{0:s}.{1:s}'.format(table_name, column_name)

    return ''
308346
def getName(self, value, defaultName = None):
        '''
        
        '''
        for k,v in self._values.items():
            if v == value:
                return k
        return defaultName