Returns the normalized version of this name.
197708
public String getNormal ()
    {
        if (_normal == null) {
            _normal = normalize(_name);
            // if _normal is an equals() String, ensure both point to the
            // same string for efficiency
            if (_normal.equals(_name)) {
                _normal = _name;
            }
        }
        return _normal;
    }
601158
def _normalize_name(name):
    # type: (str) -> str
    
    name = name.lower().replace('_', '-')
    if name.startswith('--'):
        name = name[2:]  # only prefer long opts
    return name
880999
static String normalizeHostname(String hostname) {
        if (needsNormalization(hostname)) {
            hostname = IDN.toASCII(hostname, IDN.ALLOW_UNASSIGNED);
        }
        return hostname.toLowerCase(Locale.US);
    }
637001
protected String normalizeName(String originalName) {
        if (originalName == null || originalName.endsWith(".js")) {
            return originalName;
        }
        return originalName + ".js";
    }
1223887
def name(self):
        
        return self.NAME_SEPARATOR.join([super(InfinityVertex, self).name, self.NAME_SUFFIX])
516307
private function normalizeHeaderName($name)
    {
        $name = str_replace(array('-', '_'), ' ', (string) $name);
        $name = ucwords(strtolower($name));
        $name = str_replace(' ', '-', $name);
        return $name;
    }
793673
def normalize_header(name, existing=[]):
    
    name = re.sub('\W+', '', name, flags=re.UNICODE).lower()
    # TODO handle multiple columns with the same name.
    return name
337103
private String getNamePattern() {

        String niceName = m_typeShortName.getValue();
        if (m_typeShortName.getValue().contains("-")) {
            int maxLength = 0;
            String[] nameParts = niceName.split("-");
            for (int i = 0; i < nameParts.length; i++) {
                if (nameParts[i].length() > maxLength) {
                    maxLength = nameParts[i].length();
                    niceName = nameParts[i];
                }
            }
        }
        return niceName + "_%(number).xml";
    }
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; 
	}
1034173
public static function normalizeName($name)
    {
        if (false !== ($pos = strrpos($name, '.'))) {
            $name = substr($name, $pos + 1);
	     $name = trim($name," \t\n\r\0\x0B`'()\"[]~!-{}%^&.");
        }

        return strtoupper($name);
    }
965010
private String computeGetterName(String name)
	{
		StringBuilder _result = new StringBuilder().append(PREFIX__GETTER);
		_result.append(Character.toUpperCase(name.charAt(0))).append(name.substring(1));
		return _result.toString();
	}
703148
def name_with_version(self):
        
        if self.version == 1:
            return self.name
        else:
            return '{}:{}'.format(self.name, self.version)
1336680
public String getName() {
        String name = super.getName();
        if (name != null) {
            if (name.equals(getParameterDescriptor().getDisplayName()) ||
                name.length() == 0) {
                name = null;
            }
        }
        
        return name;
    }
418463
def qualified_name(self):
        
        o = VersionedObject.construct(self.name, self.version)
        return str(o)
938071
def __normalize_name(self, name):
        

        if not name.startswith(self.__root_namespace):
            name = foundations.namespace.set_namespace(self.__root_namespace,
                                                       foundations.namespace.set_namespace(self.__default_namespace,
                                                                                           name))
            LOGGER.debug("> Normalized name: '{0}'.".format(name))
            return name
        else:
            LOGGER.debug("> Name '{0}' is already normalized!".format(name))
            return name
240753
def normalize_codec_name(name):
    '''
    '''
    name = UnicodeDammit.CHARSET_ALIASES.get(name.lower(), name)

    try:
        return codecs.lookup(name).name
    except (LookupError, TypeError, ValueError):
        # TypeError occurs when name contains \x00 (ValueError in Py3.5)
        pass
439967
def raw_name(self):
        """"""
        parts = self.raw_parts
        if self.is_absolute():
            parts = parts[1:]
            if not parts:
                return ""
            else:
                return parts[-1]
        else:
            return parts[-1]