Immutable sequence of characters.

# Immutable sequence of characters.
#
# String objects may be created using literals.
#
# ~~~
# assert "Hello World!" isa String
# ~~~
abstract class String
	super Text

	redef type SELFTYPE: String is fixed

	redef fun to_s do return self

	redef fun clone do return self

	redef fun to_buffer do return new Buffer.from_text(self)

	redef fun to_camel_case do
		if self.is_upper then return self

		var new_str = new Buffer.with_cap(length)
		new_str.append self
		new_str.camel_case
		return new_str.to_s
	end

	redef fun to_snake_case do
		if self.is_lower then return self

		var new_str = new Buffer.with_cap(self.length)
		new_str.append self
		new_str.snake_case
		return new_str.to_s
	end
end

lib/core/text/abstract_text.nit:1481,1--1516,3

core :: environ $ String

redef class String
	# Return environment value for the symbol.
	# If there is no such environment variable, then return ""
	#
	#     assert "PATH".environ     != ""
	#     assert "NIT %\n".environ  == ""
	fun environ: String
	do
		var res = self.to_cstring.get_environ
		# FIXME: There is no proper way to handle NULL C string yet. What a pitty.
		var nulstr = once ("".to_cstring.get_environ)
		if res != nulstr then
			return res.to_s
		else
			return ""
		end
	end

	# Set the enviroment value of a variable.
	#
	#     "NITis".setenv("fun")
	#     assert "NITis".environ  == "fun"
	fun setenv(v: String) do to_cstring.setenv( v.to_cstring )

	# Search for the program `self` in all directories from `PATH`
	fun program_is_in_path: Bool
	do
		var sep = if is_windows then ";" else ":"
		var full_path = "PATH".environ
		var paths = full_path.split(sep)
		for path in paths do if path.file_exists then
			if path.join_path(self).file_exists then return true
			if is_windows and (path / self + ".exe").file_exists then return true
		end

		return false
	end
end

lib/core/environ.nit:22,1--59,3

core :: u16_string $ String

redef class String
	# Returns a UTF-16 encoded version of `self`
	fun to_u16string: U16String do return new U16String.from_string(self)

	# Returns the number of UTF-16 code units in `self`
	fun u16_length: Int do
		var n = 0
		for c in chars do
			if c.to_i > 0xFFFF then n += 2 else n += 1
		end
		return n
	end
end

lib/core/text/u16_string.nit:233,1--245,3

gettext :: gettext $ String

redef class String
	# Gets the translation of `self` via gettext from `dir` using `domain`
	#
	# `domain`: Gettext domain, i.e. file/module name
	# `dir`: Where the locale/LC_MESSAGES folder for this domain is located
	fun get_translation(domain, dir: String): String do
		bindtextdomain(domain, dir)
		return dgettext(domain)
	end

	# Gettext `gettext`, SEE gettext manual for further info
	fun gettext: String
	import String.to_cstring, CString.to_s `{
		return CString_to_s(gettext(String_to_cstring(self)));
	`}

	# Gettext `dgettext`, SEE gettext manual for further info
	fun dgettext(domain: String): String
	import String.to_cstring, CString.to_s `{
		return CString_to_s(dgettext(String_to_cstring(domain), String_to_cstring(self)));
	`}
end

lib/gettext/gettext.nit:45,1--66,3

symbol :: symbol $ String

redef class String
	# Get the unique corresponding to the string
	fun to_symbol: Symbol
	do
		var symbol_dictionary = once new HashMap[String, Symbol]
		if symbol_dictionary.has_key(self) then
			return symbol_dictionary[self]
		else
			var symbol = new Symbol(self)
			symbol_dictionary[self] = symbol
			return symbol
		end
	end
end

lib/symbol/symbol.nit:16,1--29,3

markdown2 :: markdown_inline_parsing $ String

redef class String

	# Remove escape backslash from string
	fun unescape_string: String do
		if not has(re_escaped) then return self

		var buffer = new Buffer
		var match = search(re_escaped)
		var last_end = 0
		while match != null do
			buffer.append substring(last_end, match.from - last_end)
			buffer.append substring(match.from + 1, 1)
			last_end = match.after
			match = search_from(re_escaped, last_end)
		end
		if last_end < length then
			buffer.append substring(last_end, length - last_end)
		end
		return buffer.to_s
	end

	# Normalize link reference names
	private fun normalize_reference: String do
		var stripped = self.substring(1, length - 2).trim
		var lowercase = stripped.to_lower # TODO utf-8
		return lowercase.replace(re_whitespace, " ")
	end
end

lib/markdown2/markdown_inline_parsing.nit:1368,1--1395,3

template :: macro $ String

redef class String
	# Reads `self` from pos `from` to pos `to` and store result in `buffer`.
	private fun read_until_pos(from, to: Int, buffer: Buffer): Int do
		if from < 0 or from >= length or
		   to < 0 or to >= length or
	       from >= to then return -1
		var pos = from
		while pos < to do
			buffer.add self[pos]
			pos += 1
		end
		return pos
	end

	# Reads `self` until `to` is encountered and store result in `buffer`.
	#
	# Returns `to` position or `-1` if not found.
	private fun read_until_char(from: Int, char: Char, buffer: Buffer): Int do
		if from < 0 or from >= length then return -1
		var pos = from
		while pos > -1 and pos < length do
			var c = self[pos]
			if c == char then return pos
			buffer.add c
			pos += 1
		end
		return -1
	end

	# Is `self` a valid macro identifier?
	#
	# A macro identifier is valid if:
	#
	# * starts with an uppercase letter
	# * contains only numers, uppercase letters or '_'
	#
	#     # valid
	#     assert "NAME".is_valid_macro_name
	#     assert "FIRST_NAME".is_valid_macro_name
	#     assert "BLOCK1".is_valid_macro_name
	#     # invalid
	#     assert not "1BLOCK".is_valid_macro_name
	#     assert not "_BLOCK".is_valid_macro_name
	#     assert not "FIRST NAME".is_valid_macro_name
	#     assert not "name".is_valid_macro_name
	fun is_valid_macro_name: Bool do
		if not first.is_upper then return false
		for c in self do
			if not c.is_upper and c != '_' and not c.is_digit then return false
		end
		return true
	end
end

lib/template/macro.nit:307,1--359,3

jvm :: jvm $ String

redef class String
	redef fun to_jvalue(env) do
		return self.to_cstring.to_jvalue(env)
	end
end

lib/jvm/jvm.nit:541,1--545,3

markdown :: markdown $ String

redef class String

	# Parse `self` as markdown and return the HTML representation
	#.
	#    var md = "**Hello World!**"
	#    var html = md.md_to_html
	#    assert html == "<p><strong>Hello World!</strong></p>\n"
	fun md_to_html: Writable do
		var processor = new MarkdownProcessor
		return processor.process(self)
	end
end

lib/markdown/markdown.nit:2603,1--2614,3

markdown2 :: markdown_block_parsing $ String

redef class String

	# Is this string blank?
	#
	# i.e. contains only spacing characters.
	private fun is_blank: Bool do
		for i in [0 .. length[ do
			var c = chars[i]
			if c == ' ' or c == '\t' or c == '\n' or c == '\r' then
				continue
			else
				return false
			end
		end
		return true
	end

	# Is the character at `index` a space or a tab
	#
	# Return false if `index > self.length`.
	private fun is_space_or_tab(index: Int): Bool do
		if index >= length then return false
		var c = chars[index]
		return c == ' ' or c == '\t'
	end
end

lib/markdown2/markdown_block_parsing.nit:1478,1--1503,3

sqlite3 :: sqlite3 $ String

redef class String super Sqlite3Data end

lib/sqlite3/sqlite3.nit:321,1--40

markdown2 :: markdown2 $ String

redef class String
	fun md_to_html2: String do
		var parser = new MdParser
		var doc = parser.parse(self)
		var renderer = new HtmlRenderer
		return renderer.render(doc)
	end
end

lib/markdown2/markdown2.nit:20,1--27,3

serialization :: engine_tools $ String

redef class String
	redef fun serialization_hash do return hash
	redef fun is_same_serialized(o) do return self == o
end

lib/serialization/engine_tools.nit:62,1--65,3

nitcorn :: file_server $ String

redef class String
	# Returns a `String` copy of `self` without any of the prefixed '/'s
	#
	# Examples:
	#
	#     assert "/home/".strip_start_slashes == "home/"
	#     assert "////home/".strip_start_slashes == "home/"
	#     assert "../home/".strip_start_slashes == "../home/"
	fun strip_start_slashes: String
	do
		for i in chars.length.times do if chars[i] != '/' then return substring_from(i)
		return ""
	end
end

lib/nitcorn/file_server.nit:26,1--39,3

android :: bundle $ String

redef class String
	redef fun add_to_bundle(bundle, key)
	do
		bundle.put_string(key, self.to_java_string)
	end
end

lib/android/bundle/bundle.nit:714,1--719,3

abstract class String

Summary

Immutable sequence of characters.

Introduced properties

defaultinit

dgettext

environ

get_translation

gettext

is_valid_macro_name

md_to_html

md_to_html2

program_is_in_path

setenv

strip_start_slashes

to_symbol

to_u16string

u16_length

unescape_string

Redefined properties

SELF

SELFTYPE

add_to_bundle

clone

is_same_serialized

serialization_hash

to_buffer

to_camel_case

to_jvalue

to_s

to_snake_case

Immutable sequence of characters.

Introduced properties

init defaultinit

fun dgettext(domain: String): String

fun environ: String

fun get_translation(domain: String, dir: String): String

fun gettext: String

fun is_valid_macro_name: Bool

fun md_to_html: Writable

fun md_to_html2: String

fun program_is_in_path: Bool

fun setenv(v: String)

fun strip_start_slashes: String

fun to_symbol: Symbol

fun to_u16string: U16String

fun u16_length: Int

fun unescape_string: String

Redefined properties

redef type SELF: String

redef type SELFTYPE: String

redef fun add_to_bundle(bundle: NativeBundle, key: JavaString)

redef fun clone: SELF

redef fun is_same_serialized(o: nullable Object): Bool

redef fun serialization_hash: Int

redef fun to_buffer: Buffer

redef fun to_camel_case: SELFTYPE

redef fun to_jvalue(env: JniEnv): JValue

redef fun to_s: String

redef fun to_snake_case: SELFTYPE

Summary

All properties

!=

*

+

/

<

<=

<=>

==

>

>=

CLASS

OTHER

SELF

SELFTYPE

[]

a_to

accept_json_serializer

accept_msgpack_attribute_counter