"""
This type stub file was generated by pyright.
"""

from .object import object

class vtkUnicodeString(object):
    """
    vtkUnicodeString - String class that stores Unicode text.
    
    vtkUnicodeString provides storage for Unicode text.  Conceptually, it
    acts as a container for a sequence of Unicode characters, providing a
    public interface similar to basic_string.  For character-oriented
    operations, this means reading / writing 32-bit UTF-32 / UCS-4
    characters. Internally, characters may be stored using
    variable-length encodings for efficiency. Explicit conversions
    to-and-from other encodings are provided, and implicit conversions
    are deliberately avoided, to avoid confusion.
    
    Note that, because vtkUnicodeString uses variable-length encodings
    for storage, character-oriented operations will generally provide
    O(N) access instead of O(1).
    
    The current implementation stores the sequence with UTF-8 encoding,
    but this choice is subject to change and might become a compile-time
    or run-time option.
    
    @par Thanks: Developed by Timothy M. Shead (tshead@sandia.gov) at
    Sandia National Laboratories.
    
    vtkUnicodeString()
    vtkUnicodeString(const vtkUnicodeString &)
    """
    def append(self, unicode):
        """
        V.append(unicode)
        C++: void append(const vtkUnicodeString &value)
        
        Append Unicode to the current sequence.
        """
        ...
    
    def assign(self, unicode):
        """
        V.assign(unicode)
        C++: void assign(const vtkUnicodeString &value)
        
        Replace the current sequence with another.
        """
        ...
    
    def clear(self):
        """
        V.clear()
        C++: void clear()
        
        Resets the string to an empty sequence
        """
        ...
    
    def compare(self, unicode):
        """
        V.compare(unicode) -> int
        C++: int compare(const vtkUnicodeString &)
        
        Returns a negative value if the sequence compares less-than the
        operand sequence, zero if the two sequences compare equal, or a
        positive value otherwise.  Note that the definition of
        "less-than" is undefined, so you should use some other method if
        you wish to establish a specific ordering (such as alphabetical).
        """
        ...
    
    def empty(self):
        """
        V.empty() -> bool
        C++: bool empty()
        
        Returns true if the string contains an empty sequence.
        """
        ...
    
    def fold_case(self):
        """
        V.fold_case() -> unicode
        C++: vtkUnicodeString fold_case()
        
        Returns a copy of the current sequence, modified so that
        differences in case are eliminated.  Thus, you can run
        fold_case() on two strings and then comparse them to obtain a
        case-insensitive comparison.  Note that the string returned by
        fold_case() may be larger than the original source sequence,
        
        * See http://www.unicode.org/Public/UNIDATA/CaseFolding.txt for
          details.
        """
        ...
    
    def from_utf16(self, int_tuple):
        """
        V.from_utf16((int, ...)) -> unicode
        C++: static vtkUnicodeString from_utf16(const vtkTypeUInt16 *)
        
        Constructs a string from a null-terminated sequence of UTF-16
        encoded characters.
        """
        ...
    
    def from_utf8(self, string, string_1):
        """
        V.from_utf8(string, string) -> unicode
        C++: static vtkUnicodeString from_utf8(const char *begin,
            const char *end)
        V.from_utf8(string) -> unicode
        C++: static vtkUnicodeString from_utf8(const std::string &)
        """
        ...
    
    def is_utf8(self, string):
        """
        V.is_utf8(string) -> bool
        C++: static bool is_utf8(const std::string &)
        
        Tests a sequence of bytes, returning true iff they are a valid
        UTF-8 sequence.
        """
        ...
    
    def push_back(self, p_int):
        """
        V.push_back(int)
        C++: void push_back(value_type)
        
        Append a Unicode character to the end of the sequence.
        """
        ...
    
    def swap(self, unicode):
        """
        V.swap(unicode)
        C++: void swap(vtkUnicodeString &)
        
        Swap the sequences stored by two strings.
        """
        ...
    
    def utf16_str(self):
        """
        V.utf16_str() -> Stvector_ItE
        C++: std::vector<vtkTypeUInt16> utf16_str()
        V.utf16_str(Stvector_ItE)
        C++: void utf16_str(std::vector<vtkTypeUInt16> &result)
        
        Returns the sequence as a collection of UTF-16 encoded
        characters.
        """
        ...
    
    def utf8_str(self):
        """
        V.utf8_str() -> string
        C++: const char *utf8_str()
        V.utf8_str(string)
        C++: void utf8_str(std::string &result)
        
        Returns the sequence as a null-terminated sequence of UTF-8
        encoded characters.
        """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __hash__(self, *args, **kwargs) -> int:
        """ Return hash(self). """
        ...
    
    def __init__(self) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    


