Allow String class members to be inlined

diff --git a/lib/base/string.cpp b/lib/base/string.cpp
index f4fca2c1f6410df10056346ea8af48fca839c3f7..d2fa2744a6d92239615fabbaa70be04d56de0662 100644 (file)
--- a/lib/base/string.cpp
+++ b/lib/base/string.cpp
@@ -29,328 +29,13 @@ REGISTER_BUILTIN_TYPE(String);
 
 const String::SizeType String::NPos = std::string::npos;
 
-String::String(void)
-       : m_Data()
-{ }
-
-String::String(const char *data)
-       : m_Data(data)
-{ }
-
-String::String(const std::string& data)
-       : m_Data(data)
-{ }
-
-String::String(String::SizeType n, char c)
-       : m_Data(n, c)
-{ }
-
-String::String(const String& other)
-       : m_Data(other.m_Data)
-{ }
-
-String& String::operator=(const String& rhs)
-{
-       m_Data = rhs.m_Data;
-       return *this;
-}
-
-String& String::operator=(const std::string& rhs)
-{
-       m_Data = rhs;
-       return *this;
-}
-
-String& String::operator=(const char *rhs)
-{
-       m_Data = rhs;
-       return *this;
-}
-
-const char& String::operator[](String::SizeType pos) const
-{
-       return m_Data[pos];
-}
-
-char& String::operator[](String::SizeType pos)
-{
-       return m_Data[pos];
-}
-
-String& String::operator+=(const String& rhs)
-{
-       m_Data += rhs.m_Data;
-       return *this;
-}
-
-String& String::operator+=(const char *rhs)
-{
-       m_Data += rhs;
-       return *this;
-}
-
 String& String::operator+=(const Value& rhs)
 {
        m_Data += static_cast<String>(rhs);
        return *this;
 }
 
-String& String::operator+=(char rhs)
-{
-       m_Data += rhs;
-       return *this;
-}
-
-bool String::IsEmpty(void) const
-{
-       return m_Data.empty();
-}
-
-bool String::operator<(const String& rhs) const
-{
-       return m_Data < rhs.m_Data;
-}
-
-String::operator const std::string&(void) const
-{
-       return m_Data;
-}
-
-const char *String::CStr(void) const
-{
-       return m_Data.c_str();
-}
-
-void String::Clear(void)
-{
-       m_Data.clear();
-}
-
-String::SizeType String::GetLength(void) const
-{
-       return m_Data.size();
-}
-
-std::string& String::GetData(void)
-{
-       return m_Data;
-}
-
-const std::string& String::GetData(void) const
-{
-       return m_Data;
-}
-
-String::SizeType String::Find(const String& str, String::SizeType pos) const
-{
-       return m_Data.find(str, pos);
-}
-
-String::SizeType String::RFind(const String& str, String::SizeType pos) const
-{
-       return m_Data.rfind(str, pos);
-}
-
-String::SizeType String::FindFirstOf(const char *s, String::SizeType pos) const
-{
-       return m_Data.find_first_of(s, pos);
-}
-
-String::SizeType String::FindFirstOf(char ch, String::SizeType pos) const
-{
-       return m_Data.find_first_of(ch, pos);
-}
-
-String::SizeType String::FindFirstNotOf(const char *s, String::SizeType pos) const
-{
-       return m_Data.find_first_not_of(s, pos);
-}
-
-String::SizeType String::FindFirstNotOf(char ch, String::SizeType pos) const
-{
-       return m_Data.find_first_not_of(ch, pos);
-}
-
-String String::SubStr(String::SizeType first, String::SizeType len) const
-{
-       return m_Data.substr(first, len);
-}
-
-void String::Replace(String::SizeType first, String::SizeType second, const String& str)
-{
-       m_Data.replace(first, second, str);
-}
-
 void String::Trim(void)
 {
        boost::algorithm::trim(m_Data);
 }
-
-bool String::Contains(const String& str) const
-{
-       return (m_Data.find(str) != std::string::npos);
-}
-
-void String::swap(String& str)
-{
-       m_Data.swap(str.m_Data);
-}
-
-String::Iterator String::erase(String::Iterator first, String::Iterator last)
-{
-       return m_Data.erase(first, last);
-}
-
-String::Iterator String::Begin(void)
-{
-       return m_Data.begin();
-}
-
-String::ConstIterator String::Begin(void) const
-{
-       return m_Data.begin();
-}
-
-String::Iterator String::End(void)
-{
-       return m_Data.end();
-}
-
-String::ConstIterator String::End(void) const
-{
-       return m_Data.end();
-}
-
-std::ostream& icinga::operator<<(std::ostream& stream, const String& str)
-{
-       stream << static_cast<std::string>(str);
-       return stream;
-}
-
-std::istream& icinga::operator>>(std::istream& stream, String& str)
-{
-       std::string tstr;
-       stream >> tstr;
-       str = tstr;
-       return stream;
-}
-
-String icinga::operator+(const String& lhs, const String& rhs)
-{
-       return static_cast<std::string>(lhs) + static_cast<std::string>(rhs);
-}
-
-String icinga::operator+(const String& lhs, const char *rhs)
-{
-       return static_cast<std::string>(lhs) + rhs;
-}
-
-String icinga::operator+(const char *lhs, const String& rhs)
-{
-       return lhs + static_cast<std::string>(rhs);
-}
-
-bool icinga::operator==(const String& lhs, const String& rhs)
-{
-       return static_cast<std::string>(lhs) == static_cast<std::string>(rhs);
-}
-
-bool icinga::operator==(const String& lhs, const char *rhs)
-{
-       return static_cast<std::string>(lhs) == rhs;
-}
-
-bool icinga::operator==(const char *lhs, const String& rhs)
-{
-       return lhs == static_cast<std::string>(rhs);
-}
-
-bool icinga::operator<(const String& lhs, const char *rhs)
-{
-       return static_cast<std::string>(lhs) < rhs;
-}
-
-bool icinga::operator<(const char *lhs, const String& rhs)
-{
-       return lhs < static_cast<std::string>(rhs);
-}
-
-bool icinga::operator>(const String& lhs, const String& rhs)
-{
-       return static_cast<std::string>(lhs) > static_cast<std::string>(rhs);
-}
-
-bool icinga::operator>(const String& lhs, const char *rhs)
-{
-       return static_cast<std::string>(lhs) > rhs;
-}
-
-bool icinga::operator>(const char *lhs, const String& rhs)
-{
-       return lhs > static_cast<std::string>(rhs);
-}
-
-bool icinga::operator<=(const String& lhs, const String& rhs)
-{
-       return static_cast<std::string>(lhs) <= static_cast<std::string>(rhs);
-}
-
-bool icinga::operator<=(const String& lhs, const char *rhs)
-{
-       return static_cast<std::string>(lhs) <= rhs;
-}
-
-bool icinga::operator<=(const char *lhs, const String& rhs)
-{
-       return lhs <= static_cast<std::string>(rhs);
-}
-
-bool icinga::operator>=(const String& lhs, const String& rhs)
-{
-       return static_cast<std::string>(lhs) >= static_cast<std::string>(rhs);
-}
-
-bool icinga::operator>=(const String& lhs, const char *rhs)
-{
-       return static_cast<std::string>(lhs) >= rhs;
-}
-
-bool icinga::operator>=(const char *lhs, const String& rhs)
-{
-       return lhs >= static_cast<std::string>(rhs);
-}
-
-bool icinga::operator!=(const String& lhs, const String& rhs)
-{
-       return static_cast<std::string>(lhs) != static_cast<std::string>(rhs);
-}
-
-bool icinga::operator!=(const String& lhs, const char *rhs)
-{
-       return static_cast<std::string>(lhs) != rhs;
-}
-
-bool icinga::operator!=(const char *lhs, const String& rhs)
-{
-       return lhs != static_cast<std::string>(rhs);
-}
-
-String::Iterator icinga::range_begin(String& x)
-{
-       return x.Begin();
-}
-
-String::ConstIterator icinga::range_begin(const String& x)
-{
-       return x.Begin();
-}
-
-String::Iterator icinga::range_end(String& x)
-{
-       return x.End();
-}
-
-String::ConstIterator icinga::range_end(const String& x)
-{
-       return x.End();
-}

diff --git a/lib/base/string.hpp b/lib/base/string.hpp
index 72c94f43195e5c28e7846e0e2cb4d8cc8698668f..c117cef3c7edccbb32052e17f5b69f082f5f1470 100644 (file)
--- a/lib/base/string.hpp
+++ b/lib/base/string.hpp
@@ -48,57 +48,175 @@ public:
 
        typedef std::string::size_type SizeType;
 
-       String(void);
-       String(const char *data);
-       String(const std::string& data);
-       String(SizeType n, char c);
+       inline String(void)
+               : m_Data()
+       { }
+
+       inline String(const char *data)
+               : m_Data(data)
+       { }
+
+       inline String(const std::string& data)
+               : m_Data(data)
+       { }
+
+       inline String(String::SizeType n, char c)
+               : m_Data(n, c)
+       { }
+
+       inline String(const String& other)
+               : m_Data(other.m_Data)
+       { }
 
        template<typename InputIterator>
        String(InputIterator begin, InputIterator end)
                : m_Data(begin, end)
        { }
 
-       String(const String& other);
+       inline String& operator=(const String& rhs)
+       {
+               m_Data = rhs.m_Data;
+               return *this;
+       }
+
+       inline String& operator=(const std::string& rhs)
+       {
+               m_Data = rhs;
+               return *this;
+       }
+
+       inline String& operator=(const char *rhs)
+       {
+               m_Data = rhs;
+               return *this;
+       }
+
+       inline const char& operator[](SizeType pos) const
+       {
+               return m_Data[pos];
+       }
+
+       inline char& operator[](SizeType pos)
+       {
+               return m_Data[pos];
+       }
 
-       String& operator=(const String& rhs);
-       String& operator=(const std::string& rhs);
-       String& operator=(const char *rhs);
+       inline String& operator+=(const String& rhs)
+       {
+               m_Data += rhs.m_Data;
+               return *this;
+       }
 
-       const char& operator[](SizeType pos) const;
-       char& operator[](SizeType pos);
+       inline String& operator+=(const char *rhs)
+       {
+               m_Data += rhs;
+               return *this;
+       }
 
-       String& operator+=(const String& rhs);
-       String& operator+=(const char *rhs);
        String& operator+=(const Value& rhs);
-       String& operator+=(char rhs);
 
-       bool IsEmpty(void) const;
+       inline String& operator+=(char rhs)
+       {
+               m_Data += rhs;
+               return *this;
+       }
+
+       inline bool IsEmpty(void) const
+       {
+               return m_Data.empty();
+       }
+
+       inline bool operator<(const String& rhs) const
+       {
+               return m_Data < rhs.m_Data;
+       }
+
+       inline operator const std::string&(void) const
+       {
+               return m_Data;
+       }
+
+       inline const char *CStr(void) const
+       {
+               return m_Data.c_str();
+       }
+
+       inline void Clear(void)
+       {
+               m_Data.clear();
+       }
+
+       inline SizeType GetLength(void) const
+       {
+               return m_Data.size();
+       }
+
+       inline std::string& GetData(void)
+       {
+               return m_Data;
+       }
+
+       inline const std::string& GetData(void) const
+       {
+               return m_Data;
+       }
+
+       inline SizeType Find(const String& str, SizeType pos) const
+       {
+               return m_Data.find(str, pos);
+       }
+
+       inline SizeType RFind(const String& str, SizeType pos) const
+       {
+               return m_Data.rfind(str, pos);
+       }
+
+       inline SizeType FindFirstOf(const char *s, SizeType pos) const
+       {
+               return m_Data.find_first_of(s, pos);
+       }
 
-       bool operator<(const String& rhs) const;
+       inline SizeType FindFirstOf(char ch, SizeType pos) const
+       {
+               return m_Data.find_first_of(ch, pos);
+       }
 
-       operator const std::string&(void) const;
+       inline SizeType FindFirstNotOf(const char *s, SizeType pos) const
+       {
+               return m_Data.find_first_not_of(s, pos);
+       }
 
-       const char *CStr(void) const;
-       void Clear(void);
-       SizeType GetLength(void) const;
+       inline SizeType FindFirstNotOf(char ch, SizeType pos) const
+       {
+               return m_Data.find_first_not_of(ch, pos);
+       }
 
-       std::string& GetData(void);
-       const std::string& GetData(void) const;
+       inline String SubStr(SizeType first, SizeType len) const
+       {
+               return m_Data.substr(first, len);
+       }
 
-       SizeType Find(const String& str, SizeType pos = 0) const;
-       SizeType RFind(const String& str, SizeType pos = NPos) const;
-       SizeType FindFirstOf(const char *s, SizeType pos = 0) const;
-       SizeType FindFirstOf(char ch, SizeType pos = 0) const;
-       SizeType FindFirstNotOf(const char *s, SizeType pos = 0) const;
-       SizeType FindFirstNotOf(char ch, SizeType pos = 0) const;
-       String SubStr(SizeType first, SizeType len = NPos) const;
-       void Replace(SizeType first, SizeType second, const String& str);
+       inline void Replace(SizeType first, SizeType second, const String& str)
+       {
+               m_Data.replace(first, second, str);
+       }
 
        void Trim(void);
-       bool Contains(const String& str) const;
 
-       void swap(String& str);
-       Iterator erase(Iterator first, Iterator last);
+       inline bool Contains(const String& str) const
+       {
+               return (m_Data.find(str) != std::string::npos);
+       }
+
+       inline void swap(String& str)
+       {
+               m_Data.swap(str.m_Data);
+       }
+
+       inline Iterator erase(Iterator first, Iterator last)
+       {
+               return m_Data.erase(first, last);
+       }
 
        template<typename InputIterator>
        void insert(Iterator p, InputIterator first, InputIterator last)
@@ -106,10 +224,25 @@ public:
                m_Data.insert(p, first, last);
        }
 
-       Iterator Begin(void);
-       ConstIterator Begin(void) const;
-       Iterator End(void);
-       ConstIterator End(void) const;
+       inline Iterator Begin(void)
+       {
+               return m_Data.begin();
+       }
+
+       inline ConstIterator Begin(void) const
+       {
+               return m_Data.begin();
+       }
+
+       inline Iterator End(void)
+       {
+               return m_Data.end();
+       }
+
+       inline ConstIterator End(void) const
+       {
+               return m_Data.end();
+       }
 
        static const SizeType NPos;
 
@@ -117,40 +250,139 @@ private:
        std::string m_Data;
 };
 
-I2_BASE_API std::ostream& operator<<(std::ostream& stream, const String& str);
-I2_BASE_API std::istream& operator>>(std::istream& stream, String& str);
+inline std::ostream& operator<<(std::ostream& stream, const String& str)
+{
+       stream << static_cast<std::string>(str);
+       return stream;
+}
+
+inline std::istream& operator>>(std::istream& stream, String& str)
+{
+       std::string tstr;
+       stream >> tstr;
+       str = tstr;
+       return stream;
+}
+
+inline String operator+(const String& lhs, const String& rhs)
+{
+       return static_cast<std::string>(lhs)+static_cast<std::string>(rhs);
+}
+
+inline String operator+(const String& lhs, const char *rhs)
+{
+       return static_cast<std::string>(lhs)+rhs;
+}
+
+inline String operator+(const char *lhs, const String& rhs)
+{
+       return lhs + static_cast<std::string>(rhs);
+}
+
+inline bool operator==(const String& lhs, const String& rhs)
+{
+       return static_cast<std::string>(lhs) == static_cast<std::string>(rhs);
+}
+
+inline bool operator==(const String& lhs, const char *rhs)
+{
+       return static_cast<std::string>(lhs) == rhs;
+}
+
+inline bool operator==(const char *lhs, const String& rhs)
+{
+       return lhs == static_cast<std::string>(rhs);
+}
+
+inline bool operator<(const String& lhs, const char *rhs)
+{
+       return static_cast<std::string>(lhs) < rhs;
+}
+
+inline bool operator<(const char *lhs, const String& rhs)
+{
+       return lhs < static_cast<std::string>(rhs);
+}
+
+inline bool operator>(const String& lhs, const String& rhs)
+{
+       return static_cast<std::string>(lhs) > static_cast<std::string>(rhs);
+}
+
+inline bool operator>(const String& lhs, const char *rhs)
+{
+       return static_cast<std::string>(lhs) > rhs;
+}
+
+inline bool operator>(const char *lhs, const String& rhs)
+{
+       return lhs > static_cast<std::string>(rhs);
+}
+
+inline bool operator<=(const String& lhs, const String& rhs)
+{
+       return static_cast<std::string>(lhs) <= static_cast<std::string>(rhs);
+}
+
+inline bool operator<=(const String& lhs, const char *rhs)
+{
+       return static_cast<std::string>(lhs) <= rhs;
+}
+
+inline bool operator<=(const char *lhs, const String& rhs)
+{
+       return lhs <= static_cast<std::string>(rhs);
+}
+
+inline bool operator>=(const String& lhs, const String& rhs)
+{
+       return static_cast<std::string>(lhs) >= static_cast<std::string>(rhs);
+}
+
+inline bool operator>=(const String& lhs, const char *rhs)
+{
+       return static_cast<std::string>(lhs) >= rhs;
+}
 
-I2_BASE_API String operator+(const String& lhs, const String& rhs);
-I2_BASE_API String operator+(const String& lhs, const char *rhs);
-I2_BASE_API String operator+(const char *lhs, const String& rhs);
+inline bool operator>=(const char *lhs, const String& rhs)
+{
+       return lhs >= static_cast<std::string>(rhs);
+}
 
-I2_BASE_API bool operator==(const String& lhs, const String& rhs);
-I2_BASE_API bool operator==(const String& lhs, const char *rhs);
-I2_BASE_API bool operator==(const char *lhs, const String& rhs);
+inline bool operator!=(const String& lhs, const String& rhs)
+{
+       return static_cast<std::string>(lhs) != static_cast<std::string>(rhs);
+}
 
-I2_BASE_API bool operator!=(const String& lhs, const String& rhs);
-I2_BASE_API bool operator!=(const String& lhs, const char *rhs);
-I2_BASE_API bool operator!=(const char *lhs, const String& rhs);
+inline bool operator!=(const String& lhs, const char *rhs)
+{
+       return static_cast<std::string>(lhs) != rhs;
+}
 
-I2_BASE_API bool operator<(const String& lhs, const char *rhs);
-I2_BASE_API bool operator<(const char *lhs, const String& rhs);
+inline bool operator!=(const char *lhs, const String& rhs)
+{
+       return lhs != static_cast<std::string>(rhs);
+}
 
-I2_BASE_API bool operator>(const String& lhs, const String& rhs);
-I2_BASE_API bool operator>(const String& lhs, const char *rhs);
-I2_BASE_API bool operator>(const char *lhs, const String& rhs);
+inline String::Iterator range_begin(String& x)
+{
+       return x.Begin();
+}
 
-I2_BASE_API bool operator<=(const String& lhs, const String& rhs);
-I2_BASE_API bool operator<=(const String& lhs, const char *rhs);
-I2_BASE_API bool operator<=(const char *lhs, const String& rhs);
+inline String::ConstIterator range_begin(const String& x)
+{
+       return x.Begin();
+}
 
-I2_BASE_API bool operator>=(const String& lhs, const String& rhs);
-I2_BASE_API bool operator>=(const String& lhs, const char *rhs);
-I2_BASE_API bool operator>=(const char *lhs, const String& rhs);
+inline String::Iterator range_end(String& x)
+{
+       return x.End();
+}
 
-I2_BASE_API String::Iterator range_begin(String& x);
-I2_BASE_API String::ConstIterator range_begin(const String& x);
-I2_BASE_API String::Iterator range_end(String& x);
-I2_BASE_API String::ConstIterator range_end(const String& x);
+inline String::ConstIterator range_end(const String& x)
+{
+       return x.End();
+}
 
 struct string_iless : std::binary_function<String, String, bool>
 {

diff --git a/lib/base/value.hpp b/lib/base/value.hpp
index 6c64840298a94dcbb05a3a49ae7e3e830dbcecf6..d13a70a164c6f019cc4325844015abff29506c86 100644 (file)
--- a/lib/base/value.hpp
+++ b/lib/base/value.hpp
@@ -81,6 +81,10 @@ public:
                : m_Value(String(value))
        { }
 
+       inline Value(const Value& other)
+               : m_Value(other.m_Value)
+       { }
+
        inline Value(Object *value)
                : m_Value()
        {