home *** CD-ROM | disk | FTP | other *** search
/ Hackers Magazine 57 / CdHackersMagazineNr57.iso / Software / Multimedia / k3d-setup-0.7.11.0.exe / include / k3d / k3dsdk / ustring.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-01-23  |  18.1 KB  |  418 lines
  1. #ifndef K3DSDK_USTRING_H
  2. #define K3DSDK_USTRING_H
  3.  
  4. // K-3D
  5. // Copyright (c) 1995-2007, Timothy M. Shead
  6. //
  7. // Contact: tshead@k-3d.com
  8. //
  9. // This program is free software; you can redistribute it and/or
  10. // modify it under the terms of the GNU General Public
  11. // License as published by the Free Software Foundation; either
  12. // version 2 of the License, or (at your option) any later version.
  13. //
  14. // This program is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17. // General Public License for more details.
  18. //
  19. // You should have received a copy of the GNU General Public
  20. // License along with this program; if not, write to the Free Software
  21. // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22.  
  23. /** \file
  24.         \author Tim Shead (tshead@k-3d.com)
  25. */
  26.  
  27. #include <glibmm/ustring.h>
  28.  
  29. namespace k3d
  30. {
  31.  
  32. /// UTF-8 string class that is based on Glib::ustring, with some omissions
  33. /** \note: Does not provide implicit conversions to/from std::string */
  34. /** \note: Does not insertion and extraction operators */
  35. class ustring
  36. {
  37. public:
  38.     typedef Glib::ustring::size_type size_type;
  39.     typedef Glib::ustring::difference_type difference_type;
  40.     typedef gunichar value_type;
  41.     typedef gunichar& reference;
  42.     typedef const gunichar& const_reference;
  43.     typedef Glib::ustring::iterator iterator;
  44.     typedef Glib::ustring::const_iterator const_iterator;
  45.     typedef Glib::ustring::reverse_iterator reverse_iterator;
  46.     typedef Glib::ustring::const_reverse_iterator const_reverse_iterator;
  47.  
  48.     static const size_type npos;
  49.  
  50.     /*! Default constructor, which creates an empty string.
  51.     */
  52.     ustring();
  53.  
  54.     ~ustring();
  55.  
  56.     /*! Construct a ustring as a copy of another ustring.
  57.     * @param other A source string.
  58.     */
  59.     ustring(const ustring& other);
  60.  
  61.     /*! Construct a ustring as a copy of a substring.
  62.     * @param src %Source ustring.
  63.     * @param i Index of first character to copy from.
  64.     * @param n Number of characters to copy (defaults to copying the remainder).
  65.     */
  66.     ustring(const ustring& src, size_type i, size_type n=npos);
  67.  
  68.     /*! Construct a ustring as multiple characters.
  69.     * @param n Number of characters.
  70.     * @param uc UCS-4 code point to use.
  71.     */  
  72.     ustring(size_type n, gunichar uc);
  73.  
  74.     /// Constructs a ustring from a string that already contains UTF-8 characters (i.e. no conversion is performed)
  75.     static ustring from_utf8(const std::string& src);
  76.     /// Constructs a ustring from a string that already contains UTF-8 characters (i.e. no conversion is performed)
  77.     static ustring from_utf8(const char* src);
  78.  
  79.     /*! Assign the value of another string to this string.
  80.     * @param other A source string.
  81.     */ 
  82.     ustring& operator=(const ustring& other);
  83.  
  84.     /*! Swap contents with another string.
  85.     * @param other String to swap with.
  86.     */
  87.     void swap(ustring& other);
  88.  
  89.     //! @name Assign new contents.
  90.     //! @{
  91.  
  92.     ustring& assign(const ustring& src);
  93.     ustring& assign(const ustring& src, size_type i, size_type n);
  94.     ustring& assign(size_type n, gunichar uc);
  95.  
  96.     //! @}
  97.     //! @name Append to the string.
  98.     //! @{
  99.  
  100.     ustring operator+(const ustring& src) const;
  101.     ustring& operator+=(const ustring& src);
  102.     ustring& operator+=(gunichar uc);
  103.     void push_back(gunichar uc);
  104.  
  105.     ustring& append(const ustring& src);
  106.     ustring& append(const ustring& src, size_type i, size_type n);
  107.     ustring& append(size_type n, gunichar uc);
  108.  
  109.     //! @}
  110.     //! @name Insert into the string.
  111.     //! @{
  112.  
  113.     ustring& insert(size_type i, const ustring& src);
  114.     ustring& insert(size_type i, const ustring& src, size_type i2, size_type n);
  115.     ustring& insert(size_type i, size_type n, gunichar uc);
  116.     iterator insert(iterator p, gunichar uc);
  117.     void     insert(iterator p, size_type n, gunichar uc);
  118.  
  119.     //! @}
  120.     //! @name Replace sub-strings.
  121.     //! @{
  122.  
  123.     ustring& replace(size_type i, size_type n, const ustring& src);
  124.     ustring& replace(size_type i, size_type n, const ustring& src, size_type i2, size_type n2);
  125.     ustring& replace(size_type i, size_type n, size_type n2, gunichar uc);
  126.     ustring& replace(iterator pbegin, iterator pend, const ustring& src);
  127.     ustring& replace(iterator pbegin, iterator pend, size_type n, gunichar uc);
  128.  
  129.     //! @}
  130.     //! @name Erase sub-strings.
  131.     //! @{
  132.  
  133.     void clear();
  134.     ustring& erase(size_type i, size_type n=npos);
  135.     ustring& erase();
  136.     iterator erase(iterator p);
  137.     iterator erase(iterator pbegin, iterator pend);
  138.  
  139.     //! @}
  140.     //! @name Compare and collate.
  141.     //! @{
  142.  
  143.     int compare(const ustring& rhs) const;
  144.     int compare(size_type i, size_type n, const ustring& rhs) const;
  145.     int compare(size_type i, size_type n, const ustring& rhs, size_type i2, size_type n2) const;
  146.  
  147.     /*! Create a unique sorting key for the UTF-8 string.  If you need to
  148.     * compare UTF-8 strings regularly, e.g. for sorted containers such as
  149.     * <tt>std::set<></tt>, you should consider creating a collate key first
  150.     * and compare this key instead of the actual string.
  151.     *
  152.     * The ustring::compare() methods as well as the relational operators
  153.     * <tt>== != < > <= >=</tt> are quite costly
  154.     * because they have to deal with %Unicode and the collation rules defined by
  155.     * the current locale.  Converting both operands to UCS-4 is just the first
  156.     * of several costly steps involved when comparing ustrings.  So be careful.
  157.     */
  158.     std::string collate_key() const;
  159.  
  160.     /*! Create a unique key for the UTF-8 string that can be used for caseless
  161.     * sorting.  <tt>ustr.casefold_collate_key()</tt> results in the same string
  162.     * as <tt>ustr.casefold().collate_key()</tt>, but the former is likely more
  163.     * efficient.
  164.     */
  165.     std::string casefold_collate_key() const;
  166.  
  167.     //! @}
  168.     //! @name Extract characters and sub-strings.
  169.     //! @{
  170.  
  171.     /*! No reference return; use replace() to write characters. */
  172.     value_type operator[](size_type i) const;
  173.  
  174.     /*! No reference return; use replace() to write characters. @throw std::out_of_range */
  175.     value_type at(size_type i) const;
  176.  
  177.     inline ustring substr(size_type i=0, size_type n=npos) const;
  178.  
  179.     //! @}
  180.     //! @name Access a sequence of characters.
  181.     //! @{
  182.  
  183.     iterator begin();
  184.     iterator end();
  185.     const_iterator begin() const;
  186.     const_iterator end()   const;
  187.     reverse_iterator rbegin();
  188.     reverse_iterator rend();
  189.     const_reverse_iterator rbegin() const;
  190.     const_reverse_iterator rend()   const;
  191.  
  192.     //! @}
  193.     //! @name Find sub-strings.
  194.     //! @{
  195.  
  196.     size_type find(const ustring& str, size_type i=0) const;
  197.     size_type find(gunichar uc, size_type i=0) const;
  198.  
  199.     size_type rfind(const ustring& str, size_type i=npos) const;
  200.     size_type rfind(gunichar uc, size_type i=npos) const;
  201.  
  202.     //! @}
  203.     //! @name Match against a set of characters.
  204.     //! @{
  205.  
  206.     size_type find_first_of(const ustring& match, size_type i=0) const;
  207.     size_type find_first_of(gunichar uc, size_type i=0) const;
  208.  
  209.     size_type find_last_of(const ustring& match, size_type i=npos) const;
  210.     size_type find_last_of(gunichar uc, size_type i=npos) const;
  211.  
  212.     size_type find_first_not_of(const ustring& match, size_type i=0) const;
  213.     size_type find_first_not_of(gunichar uc, size_type i=0) const;
  214.  
  215.     size_type find_last_not_of(const ustring& match, size_type i=npos) const;
  216.     size_type find_last_not_of(gunichar uc, size_type i=npos) const;
  217.     
  218.     //! @}
  219.     //! @name Retrieve the string's size.
  220.     //! @{
  221.  
  222.     /** Returns true if the string is empty. Equivalent to *this == "".
  223.     * @result Whether the string is empty.
  224.     */
  225.     bool empty()  const;
  226.  
  227.     /** Returns the number of characters in the string, not including any null-termination.
  228.     * @result The number of UTF-8 characters.
  229.     *
  230.     * @see bytes(), empty() 
  231.     */
  232.     size_type size()   const;
  233.  
  234.     //We have length() as well as size(), because std::string has both.
  235.  
  236.     /** This is the same as size().
  237.     */
  238.     size_type length() const;
  239.  
  240.     /** Returns the number of bytes in the string, not including any null-termination.
  241.     * @result The number of bytes.
  242.     *
  243.     * @see size(), empty()
  244.     */
  245.     size_type bytes()  const;
  246.  
  247.     //! @}
  248.     //! @name Change the string's size.
  249.     //! @{
  250.  
  251.     void resize(size_type n, gunichar uc);
  252.  
  253.     //! @}
  254.     //! @name Control the allocated memory.
  255.     //! @{
  256.  
  257.     size_type capacity() const;
  258.     size_type max_size() const;
  259.     void reserve(size_type n=0);
  260.  
  261.     //! @}
  262.     //! @name Get a per-byte representation of the string.
  263.     //! @{
  264.  
  265.     const std::string& raw() const;
  266.  
  267.     //! @}
  268.     //! @name UTF-8 utilities.
  269.     //! @{
  270.  
  271.     /*! Check whether the string is valid UTF-8. */
  272.     bool validate() const;
  273.  
  274.     /*! Check whether the string is valid UTF-8. */
  275.     bool validate(iterator& first_invalid);
  276.  
  277.     /*! Check whether the string is valid UTF-8. */
  278.     bool validate(const_iterator& first_invalid) const;
  279.  
  280.     /*! Check whether the string is plain 7-bit ASCII. @par
  281.     * Unlike any other ustring method, is_ascii() is safe to use on invalid
  282.     * UTF-8 strings.  If the string isn't valid UTF-8, it cannot be valid
  283.     * ASCII either, therefore is_ascii() will just return @c false then.
  284.     * @return Whether the string contains only ASCII characters.
  285.     */
  286.     bool is_ascii() const;
  287.  
  288.     /*! "Normalize" the %Unicode character representation of the string. */
  289. //    ustring normalize(Glib::ustring::NormalizeMode mode = Glib::ustring::NORMALIZE_DEFAULT_COMPOSE) const;
  290.  
  291.     //! @}
  292.     //! @name Character case conversion.
  293.     //! @{
  294.  
  295.     /*! Returns a new UTF-8 string with all characters characters converted to
  296.     * their lowercase equivalent, while honoring the current locale.  The
  297.     * resulting string may change in the number of bytes as well as in the
  298.     * number of characters.  For instance, the German sharp s
  299.     * <tt>"ß"</tt> will be replaced by two characters
  300.     * <tt>"SS"</tt> because there is no capital <tt>"ß"</tt>.
  301.     */
  302.     ustring uppercase() const;
  303.  
  304.     /*! Returns a new UTF-8 string with all characters characters converted to
  305.     * their lowercase equivalent, while honoring the current locale.  The
  306.     * resulting string may change in the number of bytes as well as in the
  307.     * number of characters.
  308.     */
  309.     ustring lowercase() const;
  310.  
  311.     /*! Returns a caseless representation of the UTF-8 string.  The resulting
  312.     * string doesn't correspond to any particular case, therefore the result
  313.     * is only useful to compare strings and should never be displayed to the
  314.     * user.
  315.     */
  316.     ustring casefold() const;
  317.  
  318. //! @}
  319.  
  320.     friend bool operator<(const ustring& lhs, const ustring& rhs);
  321.     friend bool operator==(const ustring& lhs, const ustring& rhs);
  322.     friend bool operator!=(const ustring& lhs, const ustring& rhs);
  323.  
  324. private:
  325.     ustring(const Glib::ustring& str);
  326.     Glib::ustring storage;
  327. };
  328.  
  329. inline ustring::ustring() {}
  330. inline ustring::~ustring() {}
  331. inline ustring::ustring(const ustring& other) : storage(other.storage) {}
  332. inline ustring::ustring(const ustring& src, size_type i, size_type n) : storage(src.storage, i, n) {}
  333. inline ustring::ustring(size_type n, gunichar uc) : storage(n, uc) {}
  334. inline ustring::ustring(const Glib::ustring& str) : storage(str) {}
  335. inline ustring ustring::from_utf8(const std::string& src) { return ustring(Glib::ustring(src)); }
  336. inline ustring ustring::from_utf8(const char* src) { return ustring(Glib::ustring(src)); }
  337. inline ustring& ustring::operator=(const ustring& other) { storage = other.storage; return *this; }
  338. inline void ustring::swap(ustring& other) { storage.swap(other.storage); }
  339. inline ustring& ustring::assign(const ustring& src) { storage.assign(src.storage); return *this; }
  340. inline ustring& ustring::assign(const ustring& src, size_type i, size_type n) { storage.assign(src.storage, i, n); return *this; }
  341. inline ustring& ustring::assign(size_type n, gunichar uc) { storage.assign(n, uc); return *this; }
  342. inline ustring ustring::operator+(const ustring& src) const { ustring temp(storage); temp += src; return temp; }
  343. inline ustring& ustring::operator+=(const ustring& src) { storage += src.storage; return *this; }
  344. inline ustring& ustring::operator+=(gunichar uc) { storage += uc; return *this; }
  345. inline void ustring::push_back(gunichar uc) { storage.push_back(uc); }
  346. inline ustring& ustring::append(const ustring& src) { storage.append(src.storage); return *this; }
  347. inline ustring& ustring::append(const ustring& src, size_type i, size_type n) { storage.append(src.storage, i, n); return *this; }
  348. inline ustring& ustring::append(size_type n, gunichar uc) { storage.append(n, uc); return *this; }
  349. inline ustring& ustring::insert(size_type i, const ustring& src) { storage.insert(i, src.storage); return *this; }
  350. inline ustring& ustring::insert(size_type i, const ustring& src, size_type i2, size_type n) { storage.insert(i, src.storage, i2, n); return *this; }
  351. inline ustring& ustring::insert(size_type i, size_type n, gunichar uc) { storage.insert(i, n, uc); return *this; }
  352. inline ustring::iterator ustring::insert(ustring::iterator p, gunichar uc) { return storage.insert(p, uc); }
  353. inline void ustring::insert(ustring::iterator p, size_type n, gunichar uc) { storage.insert(p, n, uc); }
  354. inline ustring& ustring::replace(size_type i, size_type n, const ustring& src) { storage.replace(i, n, src.storage); return *this; }
  355. inline ustring& ustring::replace(size_type i, size_type n, const ustring& src, size_type i2, size_type n2) { storage.replace(i, n, src.storage, i2, n2); return *this; }
  356. inline ustring& ustring::replace(size_type i, size_type n, size_type n2, gunichar uc) { storage.replace(i, n, n2, uc); return *this; }
  357. inline ustring& ustring::replace(iterator pbegin, iterator pend, const ustring& src) { storage.replace(pbegin, pend, src.storage); return *this; }
  358. inline ustring& ustring::replace(iterator pbegin, iterator pend, size_type n, gunichar uc) { storage.replace(pbegin, pend, n, uc); return *this; }
  359. inline void ustring::clear() { storage.clear(); }
  360. inline ustring& ustring::erase(size_type i, size_type n) { storage.erase(i, n); return *this; }
  361. inline ustring& ustring::erase() { storage.erase(); return *this; }
  362. inline ustring::iterator ustring::erase(ustring::iterator p) { return storage.erase(p); }
  363. inline ustring::iterator ustring::erase(ustring::iterator pbegin, iterator pend) { return storage.erase(pbegin, pend); }
  364. inline int ustring::compare(const ustring& rhs) const { return storage.compare(rhs.storage); }
  365. inline int ustring::compare(size_type i, size_type n, const ustring& rhs) const { return storage.compare(i, n, rhs.storage); }
  366. inline int ustring::compare(size_type i, size_type n, const ustring& rhs, size_type i2, size_type n2) const { return storage.compare(i, n, rhs.storage, i2, n2); }
  367. inline std::string ustring::collate_key() const { return storage.collate_key(); }
  368. inline std::string ustring::casefold_collate_key() const { return storage.casefold_collate_key(); }
  369. inline ustring::value_type ustring::operator[](size_type i) const { return storage[i]; }
  370. inline ustring::value_type ustring::at(size_type i) const { return storage.at(i); }
  371. inline ustring ustring::substr(size_type i, size_type n) const { return storage.substr(i, n); }
  372. inline ustring::iterator ustring::begin() { return storage.begin(); }
  373. inline ustring::iterator ustring::end() { return storage.end(); }
  374. inline ustring::const_iterator ustring::begin() const { return storage.begin(); }
  375. inline ustring::const_iterator ustring::end() const { return storage.end(); }
  376. inline ustring::reverse_iterator ustring::rbegin() { return storage.rbegin(); }
  377. inline ustring::reverse_iterator ustring::rend() { return storage.rend(); }
  378. inline ustring::const_reverse_iterator ustring::rbegin() const { return storage.rbegin(); }
  379. inline ustring::const_reverse_iterator ustring::rend() const { return storage.rend(); }
  380. inline ustring::size_type ustring::find(const ustring& str, size_type i) const { return storage.find(str.storage, i); }
  381. inline ustring::size_type ustring::find(gunichar uc, size_type i) const { return storage.find(uc, i); }
  382. inline ustring::size_type ustring::rfind(const ustring& str, size_type i) const { return storage.rfind(str.storage, i); }
  383. inline ustring::size_type ustring::rfind(gunichar uc, size_type i) const { return storage.rfind(uc, i); }
  384. inline ustring::size_type ustring::find_first_of(const ustring& match, size_type i) const { return storage.find_first_of(match.storage, i); }
  385. inline ustring::size_type ustring::find_first_of(gunichar uc, size_type i) const { return storage.find_first_of(uc, i); }
  386. inline ustring::size_type ustring::find_last_of(const ustring& match, size_type i) const { return storage.find_last_of(match.storage, i); }
  387. inline ustring::size_type ustring::find_last_of(gunichar uc, size_type i) const { return storage.find_last_of(uc, i); }
  388. inline ustring::size_type ustring::find_first_not_of(const ustring& match, size_type i) const { return storage.find_first_not_of(match.storage, i); }
  389. inline ustring::size_type ustring::find_first_not_of(gunichar uc, size_type i) const { return storage.find_first_not_of(uc, i); }
  390. inline ustring::size_type ustring::find_last_not_of(const ustring& match, size_type i) const { return storage.find_last_not_of(match.storage, i); }
  391. inline ustring::size_type ustring::find_last_not_of(gunichar uc, size_type i) const { return storage.find_last_not_of(uc, i); }
  392. inline bool ustring::empty() const { return storage.empty(); }
  393. inline ustring::size_type ustring::size() const { return storage.size(); }
  394. inline ustring::size_type ustring::length() const { return storage.length(); }
  395. inline ustring::size_type ustring::bytes() const { return storage.bytes(); }
  396. inline void ustring::resize(size_type n, gunichar uc) { storage.resize(n, uc); }
  397. inline ustring::size_type ustring::capacity() const { return storage.capacity(); }
  398. inline ustring::size_type ustring::max_size() const { return storage.max_size(); }
  399. inline void ustring::reserve(size_type n) { storage.reserve(n); }
  400. inline const std::string& ustring::raw() const { return storage.raw(); }
  401. inline bool ustring::validate() const { return storage.validate(); }
  402. inline bool ustring::validate(iterator& first_invalid) { return storage.validate(first_invalid); }
  403. inline bool ustring::validate(const_iterator& first_invalid) const { return storage.validate(first_invalid); }
  404. inline bool ustring::is_ascii() const { return storage.is_ascii(); }
  405. //inline ustring ustring::normalize(NormalizeMode mode) const { return storage.normalize(mode); }
  406. inline ustring ustring::uppercase() const { return storage.uppercase(); }
  407. inline ustring ustring::lowercase() const { return storage.lowercase(); }
  408. inline ustring ustring::casefold() const { return storage.casefold(); }
  409.  
  410. inline bool operator<(const ustring& lhs, const ustring& rhs) { return lhs.storage < rhs.storage; }
  411. inline bool operator==(const ustring& lhs, const ustring& rhs) { return lhs.storage == rhs.storage; }
  412. inline bool operator!=(const ustring& lhs, const ustring& rhs) { return lhs.storage != rhs.storage; }
  413.  
  414. } // namespace k3d
  415.  
  416. #endif // !K3DSDK_USTRING_H
  417.  
  418.