Documentation Overview Building ASL Documentation Library Wiki Docs Indices Browse Perforce More Info Release Notes Wiki Site Search License Success Stories Contributors Media Download Perforce Depots Support ASL SourceForge Home Mailing Lists Discussion Forums Report Bugs Suggest Features Contribute to ASL RSS Short-text news Full-text news File releases Other Adobe Projects Adobe Air Adobe GIL C++ Benchmarks Adobe Labs Adobe Media Gallery Adobe XMP Tamarin project (Mozilla Foundation) Other Resources Boost RIAForge SGI STL

string.hpp Go to the documentation of this file. /* Copyright 2005-2007 Adobe Systems Incorporated Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt or a copy at http://stlab.adobe.com/licenses.html) */ /*************************************************************************************************/ #ifndef ADOBE_STRING_HPP #define ADOBE_STRING_HPP #include <adobe/config.hpp> #include <cstring> #include <functional> #include <iterator> #include <string> #if defined(ADOBE_STD_SERIALIZATION) #include <iosfwd> #endif #include <boost/cstdint.hpp> #include <boost/operators.hpp> #include <boost/static_assert.hpp> #include <boost/utility.hpp> #include <adobe/cstring.hpp> #include <adobe/string_fwd.hpp> #include <adobe/typeinfo.hpp> #include <adobe/vector.hpp> /*************************************************************************************************/ namespace std { /*************************************************************************************************/ template<typename CharT, class Traits, class Allocator> typename std::basic_string<CharT, Traits, Allocator>& operator << ( std::basic_string<CharT, Traits, Allocator>& out, const std::basic_string<CharT, Traits, Allocator>& in) { typename std::basic_string<CharT, Traits, Allocator>::size_type required(in.size() + out.size()); if (required > out.capacity()) out.reserve((std::max)(out.capacity() * 2, required)); out += in; return out; } /*************************************************************************************************/ template<typename CharT, class Traits, class Allocator> typename std::basic_string<CharT, Traits, Allocator>& operator << (std::basic_string<CharT, Traits, Allocator>& out_str, const CharT* in_str) { typename std::basic_string<CharT, Traits, Allocator>::size_type required(std::strlen(in_str) + out_str.size()); if (required > out_str.capacity()) out_str.reserve((std::max)(out_str.capacity() * 2, required)); out_str += in_str; return out_str; } /*************************************************************************************************/ } // namespace std /*************************************************************************************************/ namespace adobe { /*************************************************************************************************/ inline std::string make_string(const char* a, const char * b) { std::string result; result.reserve(std::strlen(a) + std::strlen(b)); result += a; result += b; return result; } /*************************************************************************************************/ inline std::string make_string(const char* a, const char * b, const char* c) { std::string result; result.reserve(std::strlen(a) + std::strlen(b) + std::strlen(b)); result += a; result += b; result += c; return result; } /*************************************************************************************************/ struct str_less_t : std::binary_function<const char*, const char*, bool> { bool operator()(const char* x, const char* y) const { return adobe::strcmp(x, y) < 0; } }; /*************************************************************************************************/ } // namespace adobe /*************************************************************************************************/ namespace adobe { namespace version_1 { /*************************************************************************************************/ // Move this to some appropriate file. template <typename Derived> class empty_base_t { }; // Empty base to reduce size of adobe::string /*************************************************************************************************/ class string_t : boost::totally_ordered<string_t, string_t, empty_base_t<string_t> > { public: typedef char value_type; typedef char* pointer; typedef const char* const_pointer; typedef char& reference; typedef const char& const_reference; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef char* iterator; typedef const char* const_iterator; typedef std::reverse_iterator<char*> reverse_iterator; typedef std::reverse_iterator<const char*> const_reverse_iterator; private: typedef vector<value_type> storage_type; storage_type storage_m; /* NOTE (eberdahl@adobe.com): Because c_str is required to return a null-terminated sequence, we ensure that the storage vector is always null-terminated. This means that the storage is always either empty or contains one extra character to hold the null-character. */ template <typename ForwardIterator> void assign(ForwardIterator first, ForwardIterator last, std::forward_iterator_tag) { storage_type tmp; if (first != last) { const size_type len(std::distance(first, last)); tmp.reserve(len + 1); tmp.insert(tmp.end(), first, last); tmp.push_back(char(0)); } storage_m.swap(tmp); } template <typename InputIterator> void assign(InputIterator first, InputIterator last, std::input_iterator_tag) { storage_type tmp; if (first != last) { tmp.insert(tmp.end(), first, last); tmp.push_back(char(0)); } storage_m.swap(tmp); } template <typename Iterator> void assign(Iterator first, Iterator last) { assign(first, last, typename std::iterator_traits<Iterator>::iterator_category()); } public: string_t() { } string_t(const string_t& s) : storage_m(s.storage_m) { } string_t(move_from<string_t> x) : storage_m(move(x.source.storage_m)) { } string_t(const char* s); string_t(const char* s, std::size_t length); template <typename Iterator> string_t(Iterator first, Iterator last) { assign(first, last); } string_t(const std::string& s); ~string_t() { } string_t& operator=(string_t s) { storage_m = move(s.storage_m); return *this; } /* NOTE (eberdahl@adobe.com): This function was created to support extracting std::string from any_regular_t (N.B. any_regular_t stores strings as string_t). Using conversion member functions may not be the best way to support the required conversion. Until any_regular_t changes the way it extracts data, we'll need this function. */ operator std::string() const { return std::string(begin(), end()); } const char* c_str() const { return empty() ? "" : &storage_m[0]; } void push_back(value_type c); template <typename Iterator> void append(Iterator first, Iterator last) { if (first != last) { if (!storage_m.empty()) storage_m.pop_back(); storage_m.insert(storage_m.end(), first, last); storage_m.push_back(0); } } void append(const string_t& s) { append(s.begin(), s.end()); } void append(const char* s) { append(s, s + std::strlen(s)); } void append(const char* s, std::size_t length) { append(s, s + length); } void append(const std::string& s) { append(s.begin(), s.end()); } string_t& operator+=(const string_t& s) { append(s); return *this; } string_t& operator+=(const char* s) { append(s); return *this; } string_t& operator+=(const std::string& s) { append(s); return *this; } const_iterator begin() const { return storage_m.begin(); } const_iterator end() const { return storage_m.empty() ? storage_m.end() : boost::prior(storage_m.end()); } const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } size_type capacity() const; void reserve(size_type n) { storage_m.reserve(0 == n ? 0 : n + 1); } void clear() { storage_m.clear(); } size_type size() const { return storage_m.empty() ? 0 : storage_m.size() - 1; } bool empty() const { return storage_m.empty(); } void swap(string_t& s) { storage_m.swap(s.storage_m); } friend bool operator==(const string_t& x, const string_t& y) { return x.storage_m == y.storage_m; } friend bool operator<(const string_t& x, const string_t& y) { return x.storage_m < y.storage_m; } friend inline void swap(string_t& x, string_t& y) { x.storage_m.swap(y.storage_m); } }; inline string_t operator+(string_t s1, const string_t& s2) { return move(s1 += s2); } inline string_t operator+(string_t s1, const std::string& s2) { return move(s1 += s2); } inline string_t operator+(string_t s1, const char* s2) { return move(s1 += s2); } /*************************************************************************************************/ #if defined(ADOBE_STD_SERIALIZATION) std::ostream& operator<<(std::ostream& os, const string_t& t); #endif /*************************************************************************************************/ class string16_t : boost::totally_ordered<string16_t, string16_t, empty_base_t<string16_t> > { public: typedef boost::uint16_t value_type; typedef boost::uint16_t* pointer; typedef const boost::uint16_t* const_pointer; typedef boost::uint16_t& reference; typedef const boost::uint16_t& const_reference; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef boost::uint16_t* iterator; typedef const boost::uint16_t* const_iterator; typedef std::reverse_iterator<boost::uint16_t*> reverse_iterator; typedef std::reverse_iterator<const boost::uint16_t*> const_reverse_iterator; private: typedef vector<value_type> storage_type; storage_type storage_m; /* NOTE (eberdahl@adobe.com): Because c_str is required to return a null-terminated sequence, we ensure that the storage vector is always null-terminated. This means that the storage is always either empty or contains one extra character to hold the null-character. */ template <typename ForwardIterator> void assign(ForwardIterator first, ForwardIterator last, std::forward_iterator_tag) { storage_type tmp; if (first != last) { const size_type len(std::distance(first, last)); tmp.reserve(len + 1); tmp.insert(tmp.end(), first, last); tmp.push_back(boost::uint16_t(0)); } storage_m.swap(tmp); } template <typename InputIterator> void assign(InputIterator first, InputIterator last, std::input_iterator_tag) { storage_type tmp; if (first != last) { tmp.insert(tmp.end(), first, last); tmp.push_back(boost::uint16_t(0)); } storage_m.swap(tmp); } template <typename Iterator> void assign(Iterator first, Iterator last) { assign(first, last, typename std::iterator_traits<Iterator>::iterator_category()); } public: string16_t() { } string16_t(const string16_t& s) : storage_m(s.storage_m) { } string16_t(move_from<string16_t> x) : storage_m(move(x.source.storage_m)) { } string16_t(const boost::uint16_t* s); string16_t(const boost::uint16_t* s, std::size_t length); template <typename Iterator> string16_t(Iterator first, Iterator last) { assign(first, last); } ~string16_t() { } string16_t& operator=(string16_t s) { storage_m = move(s.storage_m); return *this; } const boost::uint16_t* c_str() const; void push_back(value_type c); template <typename Iterator> void append(Iterator first, Iterator last) { if (first != last) { if (!storage_m.empty()) storage_m.pop_back(); storage_m.insert(storage_m.end(), first, last); storage_m.push_back(0); } } void append(const string16_t& s) { append(s.begin(), s.end()); } void append(const boost::uint16_t* s); void append(const boost::uint16_t* s, std::size_t length) { append(s, s + length); } string16_t& operator+=(const string16_t& s) { append(s); return *this; } string16_t& operator+=(const boost::uint16_t* s) { append(s); return *this; } const_iterator begin() const { return storage_m.begin(); } const_iterator end() const { return storage_m.empty() ? storage_m.end() : boost::prior(storage_m.end()); } const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } size_type capacity() const; void reserve(size_type n) { storage_m.reserve(0 == n ? 0 : n + 1); } void clear() { storage_m.clear(); } size_type size() const { return storage_m.empty() ? 0 : storage_m.size() - 1; } bool empty() const { return storage_m.empty(); } void swap(string16_t& s) { storage_m.swap(s.storage_m); } friend bool operator==(const string16_t& x, const string16_t& y) { return x.storage_m == y.storage_m; } friend bool operator<(const string16_t& x, const string16_t& y) { return x.storage_m < y.storage_m; } friend inline void swap(string16_t& x, string16_t& y) { x.storage_m.swap(y.storage_m); } }; inline string16_t operator+(string16_t s1, const string16_t& s2) { return move(s1 += s2); } inline string16_t operator+(string16_t s1, const boost::uint16_t* s2) { return move(s1 += s2); } /*************************************************************************************************/ BOOST_STATIC_ASSERT(sizeof(string_t) == sizeof(vector<char>)); BOOST_STATIC_ASSERT(sizeof(string16_t) == sizeof(vector<boost::uint16_t>)); /*************************************************************************************************/ } // namespace version_1 /*************************************************************************************************/ using version_1::string_t; using version_1::string16_t; /*************************************************************************************************/ } // namespace adobe /*************************************************************************************************/ ADOBE_NAME_TYPE_0("string_t:version_1:adobe", adobe::version_1::string_t) ADOBE_NAME_TYPE_0("string16_t:version_1:adobe", adobe::version_1::string16_t) ADOBE_SHORT_NAME_TYPE('s','t','r','g', adobe::version_1::string_t) ADOBE_SHORT_NAME_TYPE('s','t','1','6', adobe::version_1::string16_t) /*************************************************************************************************/ namespace boost { template <> struct has_nothrow_constructor<adobe::version_1::string_t> : boost::mpl::true_ { }; template <> struct has_nothrow_constructor<adobe::version_1::string16_t> : boost::mpl::true_ { }; } // namespace boost /*************************************************************************************************/ #endif /*************************************************************************************************/

• Company | 
• Online Privacy Policy | 
• Terms of Use | 
• Contact Us | 
• Accessibility | 
• Report Piracy | 
• Permissions & Trademarks | 
• Product License Agreements | 
• Send Feedback

Copyright © 2006-2007 Adobe Systems Incorporated.

Use of this website signifies your agreement to the Terms of Use and Online Privacy Policy.

Search powered by Google