vcfstring.h

来自「这是VCF框架的代码」· C头文件 代码 · 共 1,240 行 · 第 1/3 页

		return data_.begin();
	}

	const_iterator begin() const {
		return data_.begin();
	}

	iterator end() {
		return data_.end();
	}

	const_iterator end() const {
		return data_.end();
	}

	reverse_iterator rbegin(){
		modified();
		return data_.rbegin();
	}

	const_reverse_iterator rbegin() const{
		return data_.rbegin();
	}

	reverse_iterator rend(){
		return data_.rend();
	}

	const_reverse_iterator rend() const {
		return data_.rend();
	}

	const_reference at(size_type pos) const {
		return data_.at(pos);
	}

	reference at(size_type pos) {
		modified();
		return data_.at(pos);
	}

	const_reference operator[](size_type pos) const {
		return data_[pos];
	}

	reference operator[](size_type pos) {
		modified();
		return data_[pos];
	}



	const UniChar* c_str() const {
		return data_.c_str();
	}

	const UniChar* data() const {
		return data_.data();
	}

	size_type length() const {
		return data_.length();
	}

	/**
	Returns the number of characters in the string. This is <b>not</b> the same
	as the number of bytes that make up the string.
	@see size_in_bytes()
	*/
	size_type size() const {
		return data_.size();
	}

	/**
	The number of bytes that make up this string. This is current the size of the
	string times the size of a single character (which is 16 bits, or 2 bytes).
	*/
	size_type size_in_bytes() const {
		return data_.size() * sizeof(VCFChar);
	}

	size_type max_size() const {
		return data_.max_size();
	}

	void resize(size_type n, UniChar c = UniChar()) {
		data_.resize( n, c );
	}

	size_type capacity() const {
		return data_.capacity();
	}

	void reserve(size_type n = 0) {
		modified();
		data_.reserve( n );
	}

	bool empty() const {
		return data_.empty();
	}

	UnicodeString& operator+=(const UnicodeString& rhs) {
		data_ += rhs.data_;
		modified();
		return *this;
	}

	UnicodeString& operator+=(const UniChar *s) {
		data_ += s;
		modified();
		return *this;
	}

	UnicodeString& operator+=(UniChar c) {
		data_ += c;
		modified();
		return *this;
	}

	UnicodeString& operator+=(AnsiChar c);

	UnicodeString& operator+=(const AnsiChar* rhs );

	UnicodeString& append(const UnicodeString& str) {
		data_.append( str.data_ );
		modified();
		return *this;
	}

	UnicodeString& append(const UnicodeString& str, size_type pos, size_type n) {
		data_.append( str.data_, pos, n );
		modified();
		return *this;
	}

	UnicodeString& append(const UniChar *s, size_type n) {
		data_.append( s, n );
		modified();
		return *this;
	}

	UnicodeString& append(const AnsiChar *s, size_type n);

	UnicodeString& append(const UniChar *s){
		data_.append( s );
		modified();
		return *this;
	}

	UnicodeString& append(const AnsiChar *s);

	UnicodeString& append( size_type n, UniChar c){
		data_.append( n, c );
		modified();
		return *this;
	}

	UnicodeString& append( size_type n, AnsiChar c);

	UnicodeString& append(const_iterator first, const_iterator last){
		data_.append( first, last );
		modified();
		return *this;
	}

	UnicodeString& assign(const UnicodeString& str){
		data_.assign( str.data_ );
		modified();
		return *this;
	}

	UnicodeString& assign(const UnicodeString& str, size_type pos, size_type n) {
		data_.assign( str.data_, pos, n );
		modified();
		return *this;
	}

	UnicodeString& assign(const UniChar *s, size_type n) {
		data_.assign( s, n );
		modified();
		return *this;
	}

	UnicodeString& assign(const UniChar *s) {
		data_.assign( s );
		modified();
		return *this;
	}

	UnicodeString& assign( size_type n, UniChar c)  {
		data_.assign( n, c );
		modified();
		return *this;
	}

	UnicodeString& assign(const AnsiChar *s, size_type n);

	UnicodeString& assign(const AnsiChar *s);

	UnicodeString& assign( size_type n, AnsiChar c);

	UnicodeString& assign(const_iterator first, const_iterator last) {
		data_.assign( first, last );
		modified();
		return *this;
	}

	UnicodeString& insert(size_type p0, const UnicodeString& str) {
		data_.insert( p0, str.data_ );
		modified();
		return *this;
	}

	UnicodeString& insert(size_type p0, const UnicodeString& str, size_type pos, size_type n) {
		data_.insert( p0, str.data_, pos, n );
		modified();
		return *this;
	}

	UnicodeString& insert(size_type p0, const AnsiChar *s, size_type n);

	UnicodeString& insert(size_type p0, const UniChar *s, size_type n) {
		data_.insert( p0, s, n );
		modified();
		return *this;
	}

	UnicodeString& insert(size_type p0, const AnsiChar *s);

	UnicodeString& insert(size_type p0, const UniChar *s) {
		data_.insert( p0, s );
		modified();
		return *this;
	}

	UnicodeString& insert(size_type p0, size_type n, AnsiChar c);

	UnicodeString& insert(size_type p0, size_type n, UniChar c) {
		data_.insert( p0, n, c );
		modified();
		return *this;
	}

	iterator insert(iterator it, AnsiChar c) ;

	iterator insert(iterator it, UniChar c) {
		modified();
		return data_.insert( it, c );
	}

	void insert(iterator it, size_type n, AnsiChar c) ;

	void insert(iterator it, size_type n, UniChar c)  {
		data_.insert( it, n, c );
		modified();
	}

	void insert(iterator it, const_iterator first, const_iterator last){
		data_.insert( it, first, last );
		modified();
	}

	UnicodeString& erase(size_type p0 = 0, size_type n = npos) {
		data_.erase( p0, n );
		modified();
		return *this;
	}

	iterator erase(iterator it) {
		modified();
		return data_.erase( it );
	}

	iterator erase(iterator first, iterator last) {
		modified();
		return data_.erase( first, last );
	}

	UnicodeString& replace(size_type p0, size_type n0, const UnicodeString& str) {
		data_.replace( p0, n0, str.data_ );
		modified();
		return *this;
	}

	UnicodeString& replace(size_type p0, size_type n0, const UnicodeString& str, size_type pos, size_type n) {
		data_.replace( p0, n0, str.data_, pos, n );
		modified();
		return *this;
	}

	UnicodeString& replace(size_type p0, size_type n0, const AnsiChar *s, size_type n);

	UnicodeString& replace(size_type p0, size_type n0, const UniChar *s, size_type n) {
		data_.replace( p0, n0, s, n );
		modified();
		return *this;
	}

	UnicodeString& replace(size_type p0, size_type n0, const AnsiChar *s);

	UnicodeString& replace(size_type p0, size_type n0, const UniChar *s) {
		data_.replace( p0, n0, s );
		modified();
		return *this;
	}

	UnicodeString& replace(size_type p0, size_type n0, size_type n, AnsiChar c);

	UnicodeString& replace(size_type p0, size_type n0, size_type n, UniChar c) {
		data_.replace( p0, n0, n, c );
		modified();
		return *this;
	}

	UnicodeString& replace(iterator first0, iterator last0, const UnicodeString& str) {
		data_.replace( first0, last0, str.data_ );
		modified();
		return *this;
	}

	UnicodeString& replace(iterator first0, iterator last0, const AnsiChar *s, size_type n);

	UnicodeString& replace(iterator first0, iterator last0, const UniChar *s, size_type n)  {
		data_.replace( first0, last0, s, n );
		modified();
		return *this;
	}

	UnicodeString& replace(iterator first0, iterator last0, const AnsiChar *s);

	UnicodeString& replace(iterator first0, iterator last0, const UniChar *s) {
		data_.replace( first0, last0, s );
		modified();
		return *this;
	}

	UnicodeString& replace(iterator first0, iterator last0, size_type n, AnsiChar c);

	UnicodeString& replace(iterator first0, iterator last0, size_type n, UniChar c) {
		data_.replace( first0, last0, n, c );
		modified();
		return *this;
	}

	UnicodeString& replace(iterator first0, iterator last0, const_iterator first, const_iterator last) {
		data_.replace( first0, last0, first, last );
		modified();
		return *this;
	}

	size_type copy(AnsiChar *s, size_type n, size_type pos = 0) const;

	size_type copy(UniChar *s, size_type n, size_type pos = 0) const {
		return data_.copy( s, n, pos );
	}

	void swap(UnicodeString& str) {
		data_.swap( str.data_ );
		modified();
		str.modified();
	}

	size_type find(const UnicodeString& str, size_type pos = 0) const {
		return data_.find( str.data_, pos );
	}

	size_type find(const AnsiChar *s, size_type pos, size_type n) const;

	size_type find(const UniChar *s, size_type pos, size_type n) const {
		return data_.find( s, pos, n );
	}


	size_type find(const AnsiChar *s, size_type pos = 0) const;

	size_type find(const UniChar *s, size_type pos = 0) const {
		return data_.find( s, pos );
	}

	size_type find(AnsiChar c, size_type pos = 0) const;

	size_type find(UniChar c, size_type pos = 0) const {
		return data_.find( c, pos );
	}

	size_type rfind(const UnicodeString& str, size_type pos = npos) const {
		return data_.rfind( str.data_, pos );
	}

	size_type rfind(const AnsiChar *s, size_type pos, size_type n = npos) const;

	size_type rfind(const UniChar *s, size_type pos, size_type n = npos) const {
		return data_.rfind( s, pos, n );
	}

	size_type rfind(const AnsiChar *s, size_type pos = npos) const;

	size_type rfind(const UniChar *s, size_type pos = npos) const {
		return data_.rfind( s, pos );
	}

	size_type rfind(AnsiChar c, size_type pos = npos) const;

	size_type rfind(UniChar c, size_type pos = npos) const {
		return data_.rfind( c, pos );
	}

	size_type find_first_of(const UnicodeString& str, size_type pos = 0) const {
		return data_.find_first_of( str.data_, pos );
	}

	size_type find_first_of(const AnsiChar *s, size_type pos, size_type n) const ;