Class: Warning::buffer

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain: self, ::String
Instance Chain: self, ::String, ::Comparable
Inherits:	String ::Object String Warning::buffer
Defined in:	error.c

Class Method Summary

::String - Inherited

.new	Returns a new string object containing a copy of str.
.try_convert	Try to convert obj into a ::String, using to_str method.

Instance Attribute Summary

::String - Inherited

#ascii_only?	Returns true for a string which has only ASCII characters.
#empty?	Returns `true` if str has a length of zero.
#valid_encoding?	Returns true for a string which is encoded correctly.

Instance Method Summary

#write(*args)

::String - Inherited

#%	Format—Uses str as a format specification, and returns the result of applying it to arg.
#*	Copy — Returns a new ::String containing `integer` copies of the receiver.
#+	Concatenation—Returns a new ::String containing other_str concatenated to str.
#+@	If the string is frozen, then return duplicated mutable string.
#-@	If the string is frozen, then return the string itself.
#<<	Appends the given object to str.
#<=>	Comparison—Returns -1, 0, +1, or `nil` depending on whether `string` is less than, equal to, or greater than `other_string`.
#==	Equality—Returns whether `str` == `obj`, similar to `Object#==`.
#===	Alias for String#==.
#=~	Match—If obj is a ::Regexp, use it as a pattern to match against str,and returns the position the match starts, or `nil` if there is no match.
#[]	Element Reference — If passed a single `index`, returns a substring of one character at that index.
#[]=	Element Assignment—Replaces some or all of the content of str.
#b	Returns a copied string whose encoding is ASCII-8BIT.
#bytes	Returns an array of bytes in str.
#bytesize	Returns the length of `str` in bytes.
#byteslice	Byte Reference—If passed a single ::Integer, returns a substring of one byte at that position.
#capitalize	Returns a copy of str with the first character converted to uppercase and the remainder to lowercase.
#capitalize!	Modifies str by converting the first character to uppercase and the remainder to lowercase.
#casecmp	Case-insensitive version of String#<=>.
#casecmp?	Returns `true` if `str` and `other_str` are equal after Unicode case folding, `false` if they are not equal.
#center	Centers `str` in `width`.
#chars	Returns an array of characters in str.
#chomp	Returns a new ::String with the given record separator removed from the end of str (if present).
#chomp!	Modifies str in place as described for String#chomp, returning str, or `nil` if no modifications were made.
#chop	Returns a new ::String with the last character removed.
#chop!	Processes str as for String#chop, returning str, or `nil` if str is the empty string.
#chr	Returns a one-character string at the beginning of the string.
#clear	Makes string empty.
#codepoints	Returns an array of the ::Integer ordinals of the characters in str.
#concat	Concatenates the given object(s) to str.
#count	Each `other_str` parameter defines a set of characters to count.
#crypt	Applies a one-way cryptographic hash to str by invoking the standard library function `crypt(3)` with the given salt string.
#delete	Returns a copy of str with all characters in the intersection of its arguments deleted.
#delete!	Performs a `delete` operation in place, returning str, or `nil` if str was not modified.
#delete_prefix	Returns a copy of str with leading `prefix` deleted.
#delete_prefix!	Deletes leading `prefix` from str, returning `nil` if no change was made.
#delete_suffix	Returns a copy of str with trailing `suffix` deleted.
#delete_suffix!	Deletes trailing `suffix` from str, returning `nil` if no change was made.
#downcase	Returns a copy of str with all uppercase letters replaced with their lowercase counterparts.
#downcase!	Downcases the contents of str, returning `nil` if no changes were made.
#dump	Produces a version of `str` with all non-printing characters replaced by `\nnn` notation and all special characters escaped.
#each_byte	Passes each byte in str to the given block, or returns an enumerator if no block is given.
#each_char	Passes each character in str to the given block, or returns an enumerator if no block is given.
#each_codepoint	Passes the ::Integer ordinal of each character in str, also known as a codepoint when applied to Unicode strings to the given block.
#each_grapheme_cluster	Passes each grapheme cluster in str to the given block, or returns an enumerator if no block is given.
#each_line	Splits str using the supplied parameter as the record separator (`$/` by default), passing each substring in turn to the supplied block.
#encode	The first form returns a copy of `str` transcoded to encoding `encoding`.
#encode!	The first form transcodes the contents of str from str.encoding to `encoding`.
#encoding	Alias for Regexp#encoding.
#end_with?	Returns true if `str` ends with one of the `suffixes` given.
#eql?	Two strings are equal if they have the same length and content.
#force_encoding	Changes the encoding to `encoding` and returns self.
#freeze,
#getbyte	returns the indexth byte as an integer.
#grapheme_clusters	Returns an array of grapheme clusters in str.
#gsub	Returns a copy of str with all occurrences of pattern substituted for the second argument.
#gsub!	Performs the substitutions of String#gsub in place, returning str, or `nil` if no substitutions were performed.
#hash	Return a hash based on the string's length, content and encoding.
#hex	Treats leading characters from str as a string of hexadecimal digits (with an optional sign and an optional `0x`) and returns the corresponding number.
#include?	Returns `true` if str contains the given string or character.
#index	Returns the index of the first occurrence of the given substring or pattern (regexp) in str.
#initialize_copy	Alias for String#replace.
#insert	Inserts other_str before the character at the given index, modifying str.
#inspect	Returns a printable version of str, surrounded by quote marks, with special characters escaped.
#intern	Returns the ::Symbol corresponding to str, creating the symbol if it did not previously exist.
#length	Returns the character length of str.
#lines	Returns an array of lines in str split using the supplied record separator (`$/` by default).
#ljust	If integer is greater than the length of str, returns a new ::String of length integer with str left justified and padded with padstr; otherwise, returns str.
#lstrip	Returns a copy of str with leading whitespace removed.
#lstrip!	Removes leading whitespace from str, returning `nil` if no change was made.
#match	Converts pattern to a ::Regexp (if it isn't already one), then invokes its `match` method on str.
#match?	Converts pattern to a ::Regexp (if it isn't already one), then returns a `true` or `false` indicates whether the regexp is matched str or not without updating `$~` and other related variables.
#next	Returns the successor to str.
#next!	Equivalent to String#succ, but modifies the receiver in place.
#oct	Treats leading characters of str as a string of octal digits (with an optional sign) and returns the corresponding number.
#ord	Return the ::Integer ordinal of a one-character string.
#partition	Searches sep or pattern (regexp) in the string and returns the part before it, the match, and the part after it.
#prepend	Prepend—Prepend the given strings to str.
#replace	Replaces the contents and taintedness of str with the corresponding values in other_str.
#reverse	Returns a new string with the characters from str in reverse order.
#reverse!	Reverses str in place.
#rindex	Returns the index of the last occurrence of the given substring or pattern (regexp) in str.
#rjust	If integer is greater than the length of str, returns a new ::String of length integer with str right justified and padded with padstr; otherwise, returns str.
#rpartition	Searches sep or pattern (regexp) in the string from the end of the string, and returns the part before it, the match, and the part after it.
#rstrip	Returns a copy of str with trailing whitespace removed.
#rstrip!	Removes trailing whitespace from str, returning `nil` if no change was made.
#scan	Both forms iterate through str, matching the pattern (which may be a ::Regexp or a ::String).
#scrub	If the string is invalid byte sequence then replace invalid bytes with given replacement character, else returns self.
#scrub!	If the string is invalid byte sequence then replace invalid bytes with given replacement character, else returns self.
#setbyte	modifies the indexth byte as integer.
#size	Alias for String#length.
#slice	Alias for String#[].
#slice!	Deletes the specified portion from str, and returns the portion deleted.
#split	Divides str into substrings based on a delimiter, returning an array of these substrings.
#squeeze	Builds a set of characters from the other_str parameter(s) using the procedure described for String#count.
#squeeze!	Squeezes str in place, returning either str, or `nil` if no changes were made.
#start_with?	Returns true if `str` starts with one of the `prefixes` given.
#strip	Returns a copy of str with leading and trailing whitespace removed.
#strip!	Removes leading and trailing whitespace from str.
#sub	Returns a copy of `str` with the first occurrence of `pattern` replaced by the second argument.
#sub!	Performs the same substitution as String#sub in-place.
#succ	Alias for String#next.
#succ!	Alias for String#next!.
#sum	Returns a basic n-bit checksum of the characters in str, where n is the optional ::Integer parameter, defaulting to 16.
#swapcase	Returns a copy of str with uppercase alphabetic characters converted to lowercase and lowercase characters converted to uppercase.
#swapcase!	Equivalent to String#swapcase, but modifies the receiver in place, returning str, or `nil` if no changes were made.
#to_c	Returns a complex which denotes the string form.
#to_f	Returns the result of interpreting leading characters in str as a floating point number.
#to_i	Returns the result of interpreting leading characters in str as an integer base base (between 2 and 36).
#to_r	Returns the result of interpreting leading characters in `str` as a rational.
#to_s	Returns `self`.
#to_str	Alias for String#to_s.
#to_sym	Alias for String#intern.
#tr	Returns a copy of `str` with the characters in `from_str` replaced by the corresponding characters in `to_str`.
#tr!	Translates str in place, using the same rules as String#tr.
#tr_s	Processes a copy of str as described under String#tr, then removes duplicate characters in regions that were affected by the translation.
#tr_s!	Performs String#tr_s processing on str in place, returning str, or `nil` if no changes were made.
#undump	Produces unescaped version of `str`.
#unicode_normalize	Unicode Normalization—Returns a normalized form of `str`, using Unicode normalizations NFC, NFD, NFKC, or NFKD.
#unicode_normalize!	Destructive version of String#unicode_normalize, doing Unicode normalization in place.
#unicode_normalized?	Checks whether `str` is in Unicode normalization form `form`, which can be any of the four values `:nfc`, `:nfd`, `:nfkc`, or `:nfkd`.
#unpack	Decodes str (which may contain binary data) according to the format string, returning an array of each value extracted.
#unpack1	Decodes str (which may contain binary data) according to the format string, returning the first value extracted.
#upcase	Returns a copy of str with all lowercase letters replaced with their uppercase counterparts.
#upcase!	Upcases the contents of str, returning `nil` if no changes were made.
#upto	Iterates through successive values, starting at str and ending at other_str inclusive, passing each value in turn to the block.

::Comparable - Included

#<	Compares two objects based on the receiver's `<=>` method, returning true if it returns -1.
#<=	Compares two objects based on the receiver's `<=>` method, returning true if it returns -1 or 0.
#==	Compares two objects based on the receiver's `<=>` method, returning true if it returns 0.
#>	Compares two objects based on the receiver's `<=>` method, returning true if it returns 1.
#>=	Compares two objects based on the receiver's `<=>` method, returning true if it returns 0 or 1.
#between?	Returns `false` if obj `<=>` min is less than zero or if anObject `<=>` max is greater than zero, `true` otherwise.
#clamp	Returns min if obj `<=>` min is less than zero, max if obj `<=>` max is greater than zero and obj otherwise.

Constructor Details

This class inherits a constructor from String

Instance Method Details

#write(*args)

[ GitHub ]

# File 'error.c', line 300


static VALUE
warning_write(int argc, VALUE *argv, VALUE buf)
{
    while (argc-- > 0) {
	rb_str_append(buf, *argv++);
    }
    return buf;
}