| /********************************************************************** |
| // @@@ START COPYRIGHT @@@ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| // @@@ END COPYRIGHT @@@ |
| **********************************************************************/ |
| /* -*-C++-*- |
| **************************************************************************** |
| * |
| * File: NAStringDef.h (previously under /common) |
| * RCS: $Id: NAStringDef.h,v 1.2 1998/07/30 06:44:34 Exp $ |
| * Description: This file contains the class definition for class NAString |
| * |
| * Created: 5/6/98 |
| * Modified: $ $Date: 1998/07/30 06:44:34 $ (GMT) |
| * Language: C++ |
| * Status: $State: Exp $ |
| * |
| * |
| * |
| **************************************************************************** |
| */ |
| |
| #ifndef __NASTRING_DEF_H__ |
| #define __NASTRING_DEF_H__ |
| |
| #include "Platform.h" |
| |
| #include <iosfwd> |
| using namespace std; |
| |
| // ----------------------------------------------------------------------- |
| // |
| // class NAString : derived from the source for Facebook's FBString |
| // --> adapted to take a NAMemory* in every ctor |
| // |
| // ----------------------------------------------------------------------- |
| |
| // $$$ NB: if we write our own (simple) c-string functionality, we can |
| // (almost) use NAString in the executor (see the bottom of this file |
| // for the two functions we need to #ifdef to allow this) |
| // --> goal : someday (soon?) we will no longer include the following file: |
| #include <string.h> |
| |
| #include "NABasicObject.h" |
| #include "NAStringDefGlobals.h" /* NAReference, NAStringRef */ |
| #include "NAAssert.h" |
| |
| #include "FBString.h" |
| |
| #include "ComGuardianFileNameParts.h" |
| #include "Collections.h" |
| |
| // ----------------------------------------------------------------------- |
| // definitions we use to stay as compatible with the RWCString class, and |
| // usage of the RWCString class, as possible |
| // ----------------------------------------------------------------------- |
| #define NASize_T size_t |
| const size_t NA_NPOS = ~(size_t)0; // rw/defs.h : RW_NPOS ; |
| #define nanil 0 // rw/defs.h : rwnil |
| |
| // ----------------------------------------------------------------------- |
| // index into a string |
| // ----------------------------------------------------------------------- |
| typedef size_t StringPos; |
| |
| // ----------------------------------------------------------------------- |
| // redundant defn (see BaseTypes.h) in order to reduce NAString's |
| // dependencies ... |
| // ----------------------------------------------------------------------- |
| #ifndef MAXOF |
| #define MAXOF(X,Y) (X >= Y ? X : Y) |
| #endif |
| #ifndef MINOF |
| #define MINOF(X,Y) (X <= Y ? X : Y) |
| #endif |
| #ifndef MIN_ONE /* denoting "at least one ..." */ |
| #define MIN_ONE(X) MAXOF(X,1) |
| #endif |
| |
| |
| |
| |
| // the source someday should be changed to use only one of these -- |
| // for now, we fudge it |
| #define NAPRECONDITION2(b,s) NAPRECONDITION(b,s) |
| #define NAPOSTCONDITION(b) NAPRECONDITION(b,"" #b "") |
| #define NAASSERT(b) NAPRECONDITION(b,"" #b "") |
| |
| #define NAPRECONDITION(b,s) \ |
| { if (!(b)) NAAssert(s, __FILE__, __LINE__); } |
| |
| // Number of bits per byte |
| const size_t BITSPERBYTE = 8; |
| |
| // classes in this file: |
| class NASubString ; // rewrite of RWCSubString, from cstring.h/cstring.cpp |
| class NAString ; // rewrite of RWCString, from cstring.h/cstring.cpp |
| |
| |
| ////////////////////////////////////////////////////////////////////////// |
| // // |
| // NASubString // |
| // // |
| ////////////////////////////////////////////////////////////////////////// |
| |
| /* |
| * The NASubString class allows selected elements to be addressed. |
| * There are no public constructors. |
| */ |
| |
| |
| class NASubString |
| { |
| public: |
| NASubString(const NASubString& sp) |
| : str_(sp.str_), begin_(sp.begin_), extent_(sp.extent_) {;} |
| |
| NASubString& operator=(const char*); // Assignment to char* |
| NASubString& operator=(const NAString&); // Assignment to NAString |
| NASubString& operator=(const NASubString&); // Assignment to NASubString |
| char& operator()(size_t i); // Index with optional bounds checking |
| char& operator[](size_t i); // Index with bounds checking |
| |
| char operator()(size_t i) const ; |
| |
| char operator[](size_t i) const ; |
| |
| |
| const char* startData() const; // Replaces data(). See definition below. |
| // startData() will remain undocumented. Please don't even ask. |
| // Use at your own risk. It may be deprecated in the future. |
| |
| // DON'T USE THE FUNCTION BELOW! |
| |
| const char* data() const; |
| // This member is deprecated and will be removed in a future version. |
| // It remains public only to maintain source compatibility. |
| // Since NASubString works by referencing the NAString's data, |
| // if you attempt to directly use the data() member of the NAString, |
| // you will very likely be surprised by the result, which will be null |
| // terminated not at the extent of the substring, |
| // but at the end of the NAString. |
| |
| size_t length() const {return extent_;} |
| size_t start() const {return begin_;} |
| void toLower(); // Convert self to lower-case |
| void toUpper(); // Convert self to upper-case |
| |
| // For detecting null substrings: |
| NABoolean isNull() const {return begin_==NA_NPOS;} |
| Int32 operator!() const {return begin_==NA_NPOS;} |
| |
| protected: |
| |
| void subStringError(size_t, size_t, size_t) const; |
| void assertElement(size_t i) const; // Verifies i is valid index |
| |
| private: |
| |
| // NB: the only constructor is private: |
| NASubString(const NAString & s, size_t start, size_t len); |
| |
| NAString* str_; // Referenced string |
| size_t begin_; // Index of starting character |
| size_t extent_;// Length of NASubString |
| |
| friend |
| NABoolean operator==(const NASubString& s1, const NASubString& s2); |
| |
| friend |
| NABoolean operator==(const NASubString& s1, const NAString& s2); |
| |
| friend |
| NABoolean operator==(const NASubString& s1, const char* s2); |
| |
| friend class NAString; |
| |
| }; |
| |
| |
| |
| ////////////////////////////////////////////////////////////////////////// |
| // // |
| // NAString // |
| // // |
| ////////////////////////////////////////////////////////////////////////// |
| // |
| // NB: classes deriving from NAString can change just the |
| // 'defaultHeapPtr()' method in order to define a default heap. In this |
| // way, it should be easy to create a "ParseString" or "OptString" class |
| // whose underlying char* array is always allocated in the right place. |
| // |
| ////////////////////////////////////////////////////////////////////////// |
| |
| class NAString : public NABasicObject |
| { |
| public: |
| |
| // Often when an NAString is created, no heap pointer is specified; |
| // in this case, we need to use a default value. |
| virtual NAMemory * defaultHeapPtr () const |
| { return NABasicObject::systemHeapPtr() ; } // fyi, this value is 0x0 |
| |
| // used to identify NAMemory *'s that weren't specified by the NAString ctor call |
| enum { nastring_uninit_heap_ptr = 0x0002 } ; |
| #define NASTRING_UNINIT_HEAP_PTR ((NAMemory *)NAString::nastring_uninit_heap_ptr) |
| #define NAWSTRING_UNINIT_HEAP_PTR NASTRING_UNINIT_HEAP_PTR |
| |
| enum stripType {leading = 0x1, trailing = 0x2, both = 0x3}; |
| enum caseCompare {exact, ignoreCase}; |
| enum scopeType {one, all}; |
| |
| typedef folly::basic_fbstring<char> FBString; |
| |
| NAString(NAMemory *h=NASTRING_UNINIT_HEAP_PTR) ; |
| NAString(NASize_T ic, NAMemory *h=NASTRING_UNINIT_HEAP_PTR) ; |
| NAString(const NAString & s, NAMemory *h=NASTRING_UNINIT_HEAP_PTR) ; |
| NAString(const NASubString& SS, NAMemory *h=NASTRING_UNINIT_HEAP_PTR) ; |
| NAString(const char * a, NAMemory *h=NASTRING_UNINIT_HEAP_PTR) ; |
| NAString(const char * a, size_t N, NAMemory *h=NASTRING_UNINIT_HEAP_PTR) ; |
| |
| // these three ctors are all the same |
| NAString(char c, NAMemory *h=NASTRING_UNINIT_HEAP_PTR) ; |
| NAString(unsigned char c, NAMemory *h=NASTRING_UNINIT_HEAP_PTR) ; |
| NAString(signed char c, NAMemory *h=NASTRING_UNINIT_HEAP_PTR) ; |
| NAString(const FBString & fbs, NAMemory *h=NASTRING_UNINIT_HEAP_PTR) ; |
| |
| NAString(const ComGuardianFileNamePart & e, NAMemory *h=NASTRING_UNINIT_HEAP_PTR) |
| :fbstring_(e.castToConstChar(), e.length(), |
| (h == NASTRING_UNINIT_HEAP_PTR) ? this->defaultHeapPtr() : h) |
| {} |
| |
| NAString(char c, size_t N, NAMemory *h=NASTRING_UNINIT_HEAP_PTR) ; |
| virtual ~NAString() ; |
| |
| // Type conversion: |
| operator const char*() const {return fbstring_.data();} |
| operator const ComNodeName() const {return ComNodeName(fbstring_.data());} |
| operator const ComVolumeName() const {return ComVolumeName(fbstring_.data());} |
| |
| // Assignment: |
| NAString& operator=(const char*); // Replace string |
| NAString& operator=(const NAString&); // Replace string |
| |
| NAString& operator=(const ComGuardianFileNamePart & e) |
| {return operator= (e.castToConstChar());}; |
| NAString& operator=(const char c) |
| {return operator= (NAString(c, heap()));}; |
| |
| NAString& operator+=(const char*); // Append string. |
| |
| NAString& operator+=(const NAString& s); |
| |
| NAString& operator+=(const char c); |
| |
| NAString& operator+=(const ComGuardianFileNamePart & e) |
| {return operator+= (e.castToConstChar());}; |
| |
| // Indexing operators: |
| char& operator[](size_t); // Indexing with bounds checking |
| |
| char& operator()(size_t); // Indexing with optional bounds checking |
| NASubString operator()(size_t start, size_t len); // Sub-string operator |
| |
| /* |
| # if !defined(RW_NO_STL) |
| NASubString match(const RWCRExpr& re); // Match the RE |
| NASubString match(const RWCRExpr& re, size_t start); // Match the RE |
| # endif |
| */ |
| |
| NASubString subString(const char* pat, size_t start=0, caseCompare=exact); |
| #ifndef RW_NO_CONST_OVERLOAD |
| |
| char operator[](size_t) const; |
| |
| char operator()(size_t) const; |
| NASubString operator()(size_t start, size_t len) const; |
| /* |
| # if !defined(RW_NO_STL) |
| NASubString match(const RWCRExpr& pat) const; // Match the RE |
| NASubString match(const RWCRExpr& pat, size_t start) const; // Match the RE |
| # endif |
| */ |
| NASubString subString(const char* pat, size_t start=0, caseCompare=exact) const; |
| NASubString strip(stripType s=trailing, char c=' ') const; |
| #endif |
| |
| // Non-static member functions: |
| |
| NAString& append(const char* cs); |
| |
| NAString& append(const char* cs, size_t N); |
| |
| NAString& append(const NAString& s); |
| |
| NAString& append(const NAString& s, size_t N); |
| |
| NAString& append(const char c, size_t rep=1); // Append c rep times |
| |
| NAString& append(const ComGuardianFileNamePart & e) |
| {return append (e.castToConstChar());} |
| |
| //RWspace binaryStoreSize() const {return length()+sizeof(size_t);} |
| // total memory allocated, including the NAStringRef object in front of |
| // the string data and the null! |
| size_t getAllocatedSize() const |
| { |
| return fbstring_.get_alloc_size(); |
| } |
| |
| size_t capacity() const {return fbstring_.capacity();} |
| size_t capacity(size_t N); |
| void clear(); |
| #ifndef RW_NO_LOCALE |
| Int32 collate(const char* cs) const {return ::strcoll(data(), cs);} |
| |
| Int32 collate(const NAString& st) const; |
| |
| #endif |
| Int32 compareTo(const char* cs, caseCompare cmp = exact) const; |
| Int32 compareTo(const NAString& st, caseCompare cmp = exact) const; |
| |
| NABoolean contains(const char* pat, caseCompare cmp = exact) const; |
| |
| NABoolean contains(const NAString& pat, caseCompare cmp = exact) const; |
| |
| NAString copy() const; |
| //Extract part of this string and append it to target |
| int extract(int begin, int end, NAString & target) const; |
| inline const char* toCharStar() const {return fbstring_.data();} ; |
| const char* data() const {return fbstring_.data();} |
| size_t first(char c) const { return fbstring_.find_first_of(c);} |
| size_t first(char c, size_t i) const { return fbstring_.find_first_of(c, i);} |
| size_t first(const char* cs) const { return fbstring_.find_first_of(cs); } |
| size_t first(const char* cs, size_t N) const{return fbstring_.find_first_of(cs, N);} |
| |
| //splite this string into words by delim, memory for words are allocated in heap of elems, |
| NAList<NAString> & split(char delim, NAList<NAString> & elems); |
| |
| UInt32 hash(caseCompare cmp) const; |
| UInt32 hash() const; |
| UInt32 hashFoldCase() const; |
| void mash(UInt32& hash, UInt32 chars) const; |
| |
| // index methods return: |
| // NA_NPOS if not found. |
| // 0 based index, if found. |
| size_t index(const char* pat, size_t i=0, caseCompare cmp = exact) |
| const; |
| |
| size_t index(const NAString& s, size_t i=0, caseCompare cmp = exact) |
| const; |
| |
| size_t index(const char* pat, size_t patlen, size_t i, |
| caseCompare cmp) const; |
| |
| size_t index(const NAString& s, size_t patlen, size_t i, |
| caseCompare cmp) const; |
| |
| NAString& insert(size_t pos, const char*); |
| |
| NAString& insert(size_t pos, const char*, size_t extent); |
| |
| NAString& insert(size_t pos, const NAString&); |
| |
| NAString& insert(size_t pos, const NAString&, size_t extent); |
| NABoolean isAscii() const; |
| |
| NABoolean isNull() const {return 0 == fbstring_.size();} |
| |
| size_t last(char c) const {return fbstring_.find_last_of(c);} |
| |
| size_t last(char c,size_t i) const {return fbstring_.find_last_of(c, i);} |
| |
| size_t length() const {return fbstring_.size();} |
| #ifndef RW_NO_LOCALE |
| size_t mbLength() const; // multibyte length, or NA_NPOS on error |
| #endif |
| |
| NAString& prepend(const char*); // Prepend a character string |
| |
| NAString& prepend(const char* cs, size_t N); |
| |
| NAString& prepend(const NAString& s); |
| |
| NAString& prepend(const NAString& s, size_t N); |
| NAString& prepend(char c, size_t rep=1); // Prepend c rep times |
| Int32 readFile(ifstream&); // Read to EOF or null character. |
| Int32 readLine(ifstream&); // Read to EOF or newline. |
| Int32 readToDelim(ifstream&, char delim='\n'); // Read to EOF or delimitor. |
| |
| NAString& remove(size_t pos); // Remove pos to end of string |
| |
| void adjustMemory(size_t tot); // adjust the capacity to tot |
| // if tot is smaller or equal |
| // to the current capacity, |
| // do nothing. |
| |
| NAString& remove(size_t pos, size_t n); // Remove n chars starting at pos |
| |
| NAString& replace(size_t pos, size_t n, const char*); |
| NAString& replace(size_t pos, size_t n, const char*, size_t); |
| |
| NAString& replace(size_t pos, size_t n, const NAString&); |
| |
| NAString& replace(size_t pos, size_t n, const NAString&, size_t); |
| |
| void resize(size_t N); // Truncate or add blanks as necessary. |
| |
| NASubString strip(stripType s=trailing, char c=' '); |
| |
| void toLower(); // Change self to lower-case |
| void toUpper(); // Change self to upper-case |
| void toUpper8859_1(); // ISO 8859_1 alphabet upper-case |
| |
| NABoolean format(const char* formatTemplate...); |
| |
| // useful for supplying hash functions to template hash collection ctors: |
| static UInt32 hash(const NAString&); |
| |
| NAMemory * heap() const { return fbstring_.heap(); } |
| protected: |
| |
| // Special concatenation constructor: |
| NAString (const char *a1, size_t N1, const char * a2, size_t N2, NAMemory *h = NASTRING_UNINIT_HEAP_PTR) ; |
| void assertElement(size_t) const; // Index in range |
| void clobber(size_t nc); // Remove old contents |
| |
| void cow(); // Do copy on write as needed |
| |
| void cow(size_t nc); // Do copy on write as needed |
| |
| void initChar(char, NAMemory *h); // Initialize from char |
| public: |
| static char* buildBuffer(const char* formatTemplate, va_list args); |
| |
| private: |
| |
| void clone(); // Make self a distinct copy |
| |
| void clone(size_t nc); // Make self a distinct copy w. capacity nc |
| |
| FBString fbstring_; |
| friend |
| NAString operator+(const NAString& s1, const NAString& s2); |
| |
| friend |
| NAString operator+(const NAString& s, const char* cs); |
| |
| friend |
| NAString operator+(const NAString& s, const char c); |
| |
| friend |
| NAString operator+(const char* cs, const NAString& s); |
| |
| |
| |
| friend |
| NABoolean operator==(const NAString& s1, const char* s2); |
| |
| |
| friend class NASubString; |
| |
| }; |
| |
| typedef NAString* NAStringPtr; |
| |
| NAString toLower(const NAString&); // Return lower-case version of argument. |
| |
| |
| NAString toUpper(const NAString&); // Return upper-case version of argument. |
| |
| |
| inline UInt32 rwhash(const NAString& s) { return s.hash(); } |
| inline UInt32 rwhash(const NAString* s) { return s->hash(); } |
| #ifndef RW_NO_LOCALE |
| NAString strXForm(const NAString&); // strxfrm() interface |
| #endif |
| |
| |
| ////////////////////////////////////////////////////////////////////////// |
| // // |
| // Inlines // |
| // // |
| ////////////////////////////////////////////////////////////////////////// |
| |
| inline void NAString::cow() |
| { clone(); } |
| |
| inline void NAString::cow(size_t nc) |
| { clone(nc); } |
| |
| inline NAString& NAString::append(const char* cs) |
| { fbstring_.append(cs); return *this; } |
| |
| inline NAString& NAString::append(const char* cs, size_t N) |
| { fbstring_.append(cs, N); return *this; } |
| |
| inline NAString& NAString::append(const NAString& s) |
| { fbstring_.append(s.fbstring_); return *this; } |
| |
| inline NAString& NAString::append(const NAString& s, size_t N) |
| { fbstring_.append(s.data(), N); return *this; } |
| |
| inline NAString& NAString::operator+=(const char* cs) |
| { fbstring_.append(cs, strlen(cs)); return *this; } |
| |
| inline NAString& NAString::operator+=(const NAString& s) |
| { fbstring_.append(s.data(), s.length()); return *this; } |
| |
| inline NAString& NAString::operator+=(const char c) |
| { fbstring_.append(1, c); return *this; } |
| |
| #ifndef RW_NO_LOCALE |
| inline Int32 NAString::collate(const NAString& st) const |
| { return ::strcoll(data(), st.data()); } |
| #endif |
| |
| inline NABoolean NAString::contains(const NAString& pat, caseCompare cmp) const |
| { return index(pat.data(), pat.length(), (size_t)0, cmp) != NA_NPOS; } |
| |
| inline NABoolean NAString::contains(const char* s, caseCompare cmp) const |
| { return index(s, strlen(s), (size_t)0, cmp) != NA_NPOS; } |
| |
| inline size_t NAString::index(const char* s, size_t i, caseCompare cmp) const |
| { return index(s, strlen(s), i, cmp); } |
| |
| inline size_t NAString::index(const NAString& s, size_t i, caseCompare cmp) const |
| { return index(s.data(), s.length(), i, cmp); } |
| |
| inline size_t NAString::index(const NAString& pat, size_t patlen, size_t i, caseCompare cmp) const |
| { return index(pat.data(), patlen, i, cmp); } |
| |
| inline NAString& NAString::insert(size_t pos, const char* cs) |
| { return replace(pos, 0, cs, strlen(cs)); } |
| |
| inline NAString& NAString::insert(size_t pos, const char* cs, size_t N) |
| { return replace(pos, 0, cs, N); } |
| |
| inline NAString& NAString::insert(size_t pos, const NAString& cstr) |
| { return replace(pos, 0, cstr.data(), cstr.length()); } |
| |
| inline NAString& NAString::insert(size_t pos, const NAString& cstr, size_t N) |
| { return replace(pos, 0, cstr.data(), MINOF(N, cstr.length())); } |
| |
| inline NAString& NAString::prepend(const char* cs) |
| { return replace(0, 0, cs, strlen(cs)); } |
| |
| inline NAString& NAString::prepend(const char* cs, size_t N) |
| { return replace(0, 0, cs, N); } |
| |
| inline NAString& NAString::prepend(const NAString& s) |
| { return replace(0, 0, s.data(), s.length()); } |
| |
| inline NAString& NAString::prepend(const NAString& s, size_t N) |
| { return replace(0, 0, s.data(), MINOF(N, s.length())); } |
| |
| inline NAString& NAString::remove(size_t pos) |
| { return replace(pos, length()-pos, nanil, 0); } |
| |
| inline NAString& NAString::remove(size_t pos, size_t n) |
| { return replace(pos, n, nanil, 0); } |
| |
| inline NAString& NAString::replace(size_t pos, size_t n, const char* cs) |
| { return replace(pos, n, cs, strlen(cs)); } |
| |
| inline NAString& NAString::replace(size_t pos, size_t n, const NAString& cstr) |
| { return replace(pos, n, cstr.data(), cstr.length()); } |
| |
| inline NAString& NAString::replace(size_t pos, size_t n1, const NAString& cstr, size_t n2) |
| { return replace(pos, n1, cstr.data(), MINOF(cstr.length(),n2)); } |
| |
| inline char& NAString::operator()(size_t i) |
| { |
| #ifndef NDEBUG |
| assertElement(i); |
| #endif |
| cow(); |
| return fbstring_[i]; |
| } |
| |
| inline char NAString::operator[](size_t i) const |
| { assertElement(i); return fbstring_[i]; } |
| |
| inline char NAString::operator()(size_t i) const |
| { |
| #ifndef NDEBUG |
| assertElement(i); |
| #endif |
| return fbstring_[i]; |
| } |
| |
| inline NAString operator+(const NAString& s, const ComGuardianFileNamePart & e) |
| {return operator+(s, e.castToConstChar());}; |
| |
| inline NAString operator+(const ComGuardianFileNamePart & e, const NAString& s ) |
| {return operator+(e.castToConstChar(), s);}; |
| |
| inline NAString operator+(const ComGuardianFileNamePart & e, const char * cs ) |
| {return operator+(NAString(e), cs);}; |
| |
| inline NAString operator+(const char * cs, const ComGuardianFileNamePart & e ) |
| {return operator+(cs, NAString(e));}; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // NASubString::startData() |
| // |
| // This member replaces data(). |
| // startData() will remain undocumented. Please don't even ask. |
| // Use at your own risk. It may be deprecated in the future. |
| // |
| // Since NASubString works by referencing the NAString's data, |
| // if you attempt to directly use the data() member of the NAString, |
| // you will very likely be surprised by the result, which will be null |
| // terminated not at the extent of the substring, |
| // but at the end of the NAString. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| inline const char* NASubString::startData() const |
| { return str_->data() + begin_; } |
| |
| // DON'T USE THE FUNCTION BELOW! |
| // This member is deprecated and will be removed in a future version. |
| // It remains public only to maintain source compatibility. |
| inline const char* NASubString::data() const |
| { return str_->data() + begin_; } |
| |
| //------------------------------------------------------------------------------ |
| |
| // Access to elements of sub-string with bounds checking |
| inline char NASubString::operator[](size_t i) const |
| { assertElement(i); return (*str_)[begin_+i]; } |
| |
| inline char NASubString::operator()(size_t i) const |
| { |
| #ifndef NDEBUG |
| assertElement(i); |
| #endif |
| return (*str_)[begin_+i]; |
| } |
| |
| // String Logical operators: |
| inline NABoolean operator==(const NAString& s1, const NAString& s2) |
| { return ((s1.length() == s2.length()) && |
| !memcmp(s1.data(), s2.data(), s1.length())); } |
| |
| inline NABoolean operator< (const NAString& s1, const NAString& s2) |
| { return s1.compareTo(s2)< 0;} |
| |
| inline NABoolean operator!=(const NAString& s1, const NAString& s2) |
| { return !(s1 == s2); } |
| |
| inline NABoolean operator> (const NAString& s1, const NAString& s2) |
| { return s1.compareTo(s2)> 0;} |
| |
| inline NABoolean operator<=(const NAString& s1, const NAString& s2) |
| { return s1.compareTo(s2)<=0;} |
| |
| inline NABoolean operator>=(const NAString& s1, const NAString& s2) |
| { return s1.compareTo(s2)>=0;} |
| |
| inline NABoolean operator!=(const NAString& s1, const char* s2) |
| { return !(s1 == s2); } |
| |
| inline NABoolean operator< (const NAString& s1, const char* s2) |
| { return s1.compareTo(s2)< 0; } |
| |
| inline NABoolean operator> (const NAString& s1, const char* s2) |
| { return s1.compareTo(s2)> 0; } |
| |
| inline NABoolean operator<=(const NAString& s1, const char* s2) |
| { return s1.compareTo(s2)<=0; } |
| |
| inline NABoolean operator>=(const NAString& s1, const char* s2) |
| { return s1.compareTo(s2)>=0; } |
| |
| inline NABoolean operator==(const char* s1, const NAString& s2) |
| { return (s2 == s1); } |
| |
| inline NABoolean operator!=(const char* s1, const NAString& s2) |
| { return !(s2 == s1); } |
| |
| inline NABoolean operator< (const char* s1, const NAString& s2) |
| { return s2.compareTo(s1)> 0; } |
| |
| inline NABoolean operator> (const char* s1, const NAString& s2) |
| { return s2.compareTo(s1)< 0; } |
| |
| inline NABoolean operator<=(const char* s1, const NAString& s2) |
| { return s2.compareTo(s1)>=0; } |
| |
| inline NABoolean operator>=(const char* s1, const NAString& s2) |
| { return s2.compareTo(s1)<=0; } |
| |
| // SubString Logical operators: |
| inline NABoolean operator==(const NAString& s1, const NASubString& s2) |
| { return (s2 == s1); } |
| |
| inline NABoolean operator==(const char* s1, const NASubString& s2) |
| { return (s2 == s1); } |
| |
| inline NABoolean operator!=(const NASubString& s1, const char* s2) |
| { return !(s1 == s2); } |
| |
| inline NABoolean operator!=(const NASubString& s1, const NAString& s2) |
| { return !(s1 == s2); } |
| |
| inline NABoolean operator!=(const NASubString& s1, const NASubString& s2) |
| { return !(s1 == s2); } |
| |
| inline NABoolean operator!=(const NAString& s1, const NASubString& s2) |
| { return !(s2 == s1); } |
| |
| inline NABoolean operator!=(const char* s1, const NASubString& s2) |
| { return !(s2 == s1); } |
| |
| inline NABoolean operator==(const NAString& s1, const ComGuardianFileNamePart& s2) |
| {return (s1 == s2.castToConstChar());} |
| inline NABoolean operator==(const ComGuardianFileNamePart& s1, const NAString& s2) |
| {return (s2 == s1.castToConstChar());} |
| inline NABoolean operator==(const NAString& s1, const ComNodeName& s2) |
| {return (s1 == s2.castToConstChar());} |
| inline NABoolean operator==(const ComNodeName& s1, const NAString& s2) |
| {return (s2 == s1.castToConstChar());} |
| inline NABoolean operator==(const NAString& s1, const char c) |
| {return (s1.length() == 1 && *s1.data() == c);} |
| |
| // $$$NB: besides usage of c-string-lib functions inside the NAString code, |
| // if we #ifdef the following two functions then we ought to be able to |
| // use NAString objects inside the executor ... |
| |
| // input/output |
| istream& operator>>(istream& str , NAString& cstr); |
| |
| ostream& operator<<(ostream& str , const NAString& cstr); |
| |
| #endif /* __NASTRING_DEF_H__ */ |
| |
