| /********************************************************************** |
| // @@@ 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 @@@ |
| **********************************************************************/ |
| #ifndef NAWSTRING_H |
| #define NAWSTRING_H |
| /* -*-C++-*- |
| ****************************************************************************** |
| * |
| * File: NAWString.h |
| * RCS: $Id: nawstring.h,v 1.2 1998/08/10 15:33:50 Exp $ |
| * Description: common definitions of basic data types |
| * |
| * Created: 4/27/94 |
| * Modified: $Date: 2001/03/13 15:33: |
| * Language: C++ |
| * Status: $State: Exp $ |
| * |
| * |
| ****************************************************************************** |
| */ |
| |
| #include "Platform.h" |
| #include "NAWinNT.h" |
| #include "NAStringDef.h" |
| |
| // ----------------------------------------------------------------------- |
| // a Unicode string datatype |
| // ----------------------------------------------------------------------- |
| |
| // Note NAWString always put a NAWchar null at the end of the string. So we |
| // count in the trailing NAWchar null here. |
| #define NAW_TO_NASTRING(w) (const char *)w.data(), (w.length()+1) * BYTES_PER_NAWCHAR |
| |
| class SQLEXPORT_LIB_FUNC NAWString : public NABasicObject |
| { |
| public: |
| |
| virtual NAMemory * defaultHeapPtr () const |
| { return NABasicObject::systemHeapPtr() ; } // fyi, this value is 0x0 |
| |
| #if __SIZEOF_WCHAR_T__ == 2 |
| typedef folly::basic_fbstring<char16_t> FBWString; |
| #else |
| typedef folly::basic_fbstring<NAWchar> FBWString; |
| #endif |
| |
| NAWString(Lng32 charset, const char* str, NAMemory *h=NAWSTRING_UNINIT_HEAP_PTR); |
| NAWString(Lng32 charset, const char* str, size_t, NAMemory *h=NAWSTRING_UNINIT_HEAP_PTR); |
| NAWString(const NAWchar*, size_t, NAMemory *h=NAWSTRING_UNINIT_HEAP_PTR); |
| NAWString(const NAWchar*, NAMemory *h=NAWSTRING_UNINIT_HEAP_PTR); |
| NAWString(const NAWString &, NAMemory *h=NAWSTRING_UNINIT_HEAP_PTR); |
| NAWString(NAWchar, NAMemory *h=NAWSTRING_UNINIT_HEAP_PTR); |
| NAWString(NAMemory *h=NAWSTRING_UNINIT_HEAP_PTR); |
| ~NAWString(); |
| |
| NABoolean operator==(const NAWchar * s2) const |
| { return fbwstring_.compare((FBWString::value_type*)s2) == 0; } |
| |
| operator const NAWchar*() const |
| { return (const NAWchar*)fbwstring_.data(); } |
| |
| NAWString& operator=(const NAWString& rhs) // Replace string |
| { fbwstring_.replace(0, length(), (FBWString::value_type*)rhs.data(), rhs.length()); return *this; } |
| NAWString& operator=(const NAWchar*); // Replace string |
| NAWString& operator+=(NAWchar wc) |
| { fbwstring_ += (FBWString::value_type)wc; return *this; } |
| |
| NAWchar& operator[](size_t i) { return (NAWchar&)fbwstring_[i]; } ; |
| |
| size_t index(const NAWchar* pat, size_t patLen, size_t i=0, NAString::caseCompare cmp = NAString::exact) const; |
| size_t index(const NAWString& pat, size_t i=0, NAString::caseCompare cmp = NAString::exact) const |
| { return index(pat.data(), pat.length(), i, cmp); } |
| |
| NAWString& append(const NAWString& s) |
| { fbwstring_.replace(length(), 0, (FBWString::value_type*)s.data(), s.length());return *this; } |
| |
| NAWString& append(const NAWchar* cs, size_t N) |
| { fbwstring_.replace(length(), 0, (FBWString::value_type*)cs, N); return *this;} |
| |
| NAWString& remove(size_t pos) |
| { fbwstring_.replace(pos, length()-pos, nanil, 0);return *this; } |
| |
| // Remove n chars starting at pos |
| NAWString& remove(size_t pos, size_t n) |
| { fbwstring_.replace(pos, n, nanil, 0); return *this;} |
| |
| NAWString& replace(size_t pos, size_t n1, const NAWchar* cs, size_t n2); |
| const NAWchar* data() const { return (NAWchar*)fbwstring_.data(); } |
| |
| size_t length() const { return fbwstring_.length(); } |
| |
| NAWString ToQuotedWString(); |
| |
| friend |
| SQLEXPORT_LIB_FUNC |
| NAWString operator+(const NAWString& s1, const NAWString& s2); |
| |
| friend |
| SQLEXPORT_LIB_FUNC |
| NABoolean operator==(const NAWString& s1, const NAWString& s2); |
| |
| friend |
| SQLEXPORT_LIB_FUNC |
| NABoolean operator< (const NAWString& s1, const NAWString& s2); |
| |
| friend |
| SQLEXPORT_LIB_FUNC |
| NABoolean operator> (const NAWString& s1, const NAWString& s2); |
| |
| protected: |
| NAWString(const NAWchar* a1, size_t N1, |
| const NAWchar* a2, size_t N2, NAMemory *h); |
| |
| void initFromSingleByteString(Lng32 charset, const char* str, size_t N, NAMemory *h); |
| void initFromVariableWidthMultiByteString(Lng32 charset, const char* str, size_t N, NAMemory *h); |
| |
| private: |
| |
| // ==================================================================== |
| // Capacity, increment and max waste are all expressed in UCS2 units |
| // ==================================================================== |
| size_t capacity() const {return fbwstring_.capacity()/BYTES_PER_NAWCHAR;} |
| static size_t adjustCapacity(size_t nc); |
| static size_t initialCapacity(size_t ic = 15); // Initial allocation Capacity |
| static size_t maxWaste(size_t mw = 15); // Max empty space before reclaim |
| static size_t resizeIncrement(size_t ri = 16); // Resizing increment |
| |
| static size_t getInitialCapacity() {return initialCapac;} |
| |
| static size_t getResizeIncrement() {return resizeInc;} |
| |
| static size_t getMaxWaste() {return freeboard;} |
| |
| static const size_t initialCapac; // Initial allocation Capacity |
| static const size_t resizeInc; // Resizing increment |
| static const size_t freeboard; // Max empty space before reclaim |
| |
| NAMemory * heap() const { return fbwstring_.heap() ; } |
| |
| FBWString fbwstring_; |
| }; //NAWString |
| |
| // NAWString Logical operators: |
| NA_EIDPROC |
| //#ifdef NA_NSK // :cnu -- As of 8/30/2011, there are no callers in SQ SQL |
| inline NABoolean operator==(const NAWString& s1, const NAWString& s2) |
| { return s1.fbwstring_ == s2.fbwstring_; } |
| |
| NA_EIDPROC |
| inline NABoolean operator< (const NAWString& s1, const NAWString& s2) |
| { return s1.fbwstring_ < s2.fbwstring_; } |
| //#endif // :cnu |
| |
| NA_EIDPROC |
| inline NABoolean operator!=(const NAWString& s1, const NAWString& s2) |
| { return !(s1 == s2); } |
| |
| NA_EIDPROC |
| inline NABoolean operator> (const NAWString& s1, const NAWString& s2) |
| { return s1.fbwstring_ > s2.fbwstring_; } |
| |
| NA_EIDPROC |
| inline NABoolean operator<=(const NAWString& s1, const NAWString& s2) |
| { return !(s1 > s2); } |
| |
| NA_EIDPROC |
| inline NABoolean operator>=(const NAWString& s1, const NAWString& s2) |
| { return !(s1 < s2); } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Returns TRUE if the string consists entirely of whitespace |
| // (zero or more spaces or tabs, and nothing else), including none (empty str). |
| // ----------------------------------------------------------------------- |
| SQLEXPORT_LIB_FUNC |
| NABoolean IsNAWStringSpaceOrEmpty(const NAWString& naws); |
| |
| // ----------------------------------------------------------------------- |
| // Remove whitespace (spaces and tabs) from front or back or both |
| // ----------------------------------------------------------------------- |
| SQLEXPORT_LIB_FUNC |
| void TrimNAWStringSpace(NAWString& naws, NAString::stripType s = NAString::trailing); |
| |
| // ----------------------------------------------------------------------- |
| // Allocates space (including an extra NAWchar for the NULL character |
| // terminator) in the specified heap or the process C/C++ runtime |
| // heap (if the specified heap pointer is a NULL pointer) and then |
| // DEEP-copies the contents of the NAWString parameter naws to the |
| // newly allocated buffer (including the NULL character terminator). |
| // |
| // It is the caller responsibility to deallocate the returned the |
| // newly allocated buffer when the buffer is no longer needed. |
| // Use the NADELETEBASIC(returned_NAWchar_star_pointer, heap_pointer) |
| // call (C macro expansion/invocation) to deallocate the buffer. |
| // ----------------------------------------------------------------------- |
| SQLEXPORT_LIB_FUNC |
| NAWchar * newNAWcharBuffer(const NAWString& naws, CollHeap *heap = NULL); |
| |
| // ----------------------------------------------------------------------- |
| // Allocates space for one or two NAWchar's to contain the |
| // NAWchar NULL character (respresenting on empty string) |
| // in the specified heap or the process C/C++ runtime |
| // heap (if the specified heap pointer is a NULL pointer) |
| // and then set the contents of newly allocated buffer to |
| // the NAWchar NULL character encoding value. |
| // |
| // It is the caller responsibility to deallocate the returned the |
| // newly allocated buffer when the buffer is no longer needed. |
| // Use the NADELETEBASIC(returned_NAWchar_star_pointer, heap_pointer) |
| // call (C macro expansion/invocation) to deallocate the buffer. |
| // ----------------------------------------------------------------------- |
| SQLEXPORT_LIB_FUNC |
| NAWchar * newNAWcharBufferContainingAnEmptyString(CollHeap *heap = NULL); |
| |
| // // ----------------------------------------------------------------------- |
| // // A simple API (abeit inefficient) to convert a C string from ISO88591 |
| // // encoding format to UCS2/UTF16 encoding format. The specified work |
| // // heap is used for allocating temporary storage buffers during the |
| // // execution of the routine - The default is to use the process heap. |
| // // |
| // // The returned NAWString object always uses the C/C++ runtime process |
| // // heap (regardless whether the working heap is specified or not). |
| // // |
| // // This function relates to the function Latin1StrToUTF8 declared in |
| // // the header file w:/common/NAString.h. |
| // // |
| // // 3/21/2011 Comment out the function because it is not currently used. |
| // // ----------------------------------------------------------------------- |
| // SQLEXPORT_LIB_FUNC |
| // NAWString Latin1StrToUCS2(const NAString & latin1Str, CollHeap * workHeap = NULL); |
| #endif |