Imported Upstream version 3.3.0.2upstream/3.3.0.2

4 files changed, 614 insertions, 0 deletions

diff --git a/libcult/cult/types/evptr.hxx b/libcult/cult/types/evptr.hxx
new file mode 100644
index 0000000..a39cd86
--- /dev/null
+++ b/libcult/cult/types/evptr.hxx
@@ -0,0 +1,21 @@
+// file      : cult/types/evptr.hxx
+// author    : Boris Kolpackov <boris@kolpackov.net>
+// copyright : Copyright (c) 2005-2010 Boris Kolpackov
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef CULT_TYPES_EVPTR_HXX
+#define CULT_TYPES_EVPTR_HXX
+
+#include <cult/mm/evptr.hxx>
+
+namespace Cult
+{
+  namespace Types
+  {
+    using MM::Evptr;
+  }
+
+  using Types::Evptr;
+}
+
+#endif  // CULT_TYPES_EVPTR_HXX
diff --git a/libcult/cult/types/fundamental.hxx b/libcult/cult/types/fundamental.hxx
new file mode 100644
index 0000000..01116f1
--- /dev/null
+++ b/libcult/cult/types/fundamental.hxx
@@ -0,0 +1,175 @@
+// file      : cult/types/fundamental.hxx
+// author    : Boris Kolpackov <boris@kolpackov.net>
+// copyright : Copyright (c) 2005-2010 Boris Kolpackov
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef CULT_TYPES_FUNDAMENTAL_HXX
+#define CULT_TYPES_FUNDAMENTAL_HXX
+
+#include <cstddef> // std::size_t, std::ptrdiff_t
+
+namespace Cult
+{
+  namespace Types
+  {
+    namespace Fundamental
+    {
+      // Fundamental types
+      //
+      typedef void Void;
+
+      typedef bool Boolean;
+
+      typedef char Char;
+      typedef wchar_t WideChar;
+
+      typedef short Short;
+      typedef unsigned short UnsignedShort;
+
+      typedef int Int;
+      typedef unsigned int UnsignedInt;
+
+      typedef long Long;
+      typedef unsigned long UnsignedLong;
+
+      //@@ what would be a good name for float, double and long double?
+      //   ShortFloat, Float and LongFloat
+      //   ShortReal, Real, LongReal
+
+      typedef std::size_t Size;
+      typedef std::ptrdiff_t PtrDifference;
+      typedef Size Index;
+
+      // Fixed-size types.
+      //
+      typedef signed char Int8;
+      typedef unsigned char UnsignedInt8;
+
+      typedef signed short Int16;
+      typedef unsigned short UnsignedInt16;
+
+      typedef signed int Int32;
+      typedef unsigned int UnsignedInt32;
+
+      typedef signed long long Int64;
+      typedef unsigned long long UnsignedInt64;
+
+
+      typedef float Float32;
+      typedef double Float64;
+      typedef long double Float128; // Only 96 on x86-32.
+    }
+
+
+    // Fundamental types
+    //
+    using Fundamental::Void;
+
+    using Fundamental::Boolean;
+
+    using Fundamental::Char;
+    using Fundamental::WideChar;
+
+    using Fundamental::Short;
+    using Fundamental::UnsignedShort;
+
+    using Fundamental::Int;
+    using Fundamental::UnsignedInt;
+
+    using Fundamental::Long;
+    using Fundamental::UnsignedLong;
+
+    using Fundamental::Size;
+    using Fundamental::PtrDifference;
+    using Fundamental::Index;
+
+
+    // Fixed-size types.
+    //
+    using Fundamental::Int8;
+    using Fundamental::UnsignedInt8;
+
+    using Fundamental::Int16;
+    using Fundamental::UnsignedInt16;
+
+    using Fundamental::Int32;
+    using Fundamental::UnsignedInt32;
+
+    using Fundamental::Int64;
+    using Fundamental::UnsignedInt64;
+
+
+    using Fundamental::Float32;
+    using Fundamental::Float64;
+    using Fundamental::Float128; // Only 96 on x86-32.
+
+
+    // Note: make sure you inherit publicly from this type for
+    // it could be used for metaprogramming.
+    //
+    class NonCopyable
+    {
+      NonCopyable (NonCopyable const&);
+
+      NonCopyable&
+      operator= (NonCopyable const&);
+
+    protected:
+      NonCopyable ()
+      {
+      }
+    };
+
+    // class Clonable ?
+    //
+
+  }
+
+  // Fundamental types
+  //
+  using Types::Void;
+
+  using Types::Boolean;
+
+  using Types::Char;
+  using Types::WideChar;
+
+  using Types::Short;
+  using Types::UnsignedShort;
+
+  using Types::Int;
+  using Types::UnsignedInt;
+
+  using Types::Long;
+  using Types::UnsignedLong;
+
+  using Types::Size;
+  using Types::PtrDifference;
+  using Types::Index;
+
+
+  // Fixed-size types.
+  //
+  using Types::Int8;
+  using Types::UnsignedInt8;
+
+  using Types::Int16;
+  using Types::UnsignedInt16;
+
+  using Types::Int32;
+  using Types::UnsignedInt32;
+
+  using Types::Int64;
+  using Types::UnsignedInt64;
+
+
+  using Types::Float32;
+  using Types::Float64;
+  using Types::Float128; // Only 96 on x86-32.
+
+  //
+  //
+  using Types::NonCopyable;
+}
+
+#endif  // CULT_TYPES_FUNDAMENTAL_HXX
diff --git a/libcult/cult/types/shptr.hxx b/libcult/cult/types/shptr.hxx
new file mode 100644
index 0000000..c5d2d66
--- /dev/null
+++ b/libcult/cult/types/shptr.hxx
@@ -0,0 +1,21 @@
+// file      : cult/types/shptr.hxx
+// author    : Boris Kolpackov <boris@kolpackov.net>
+// copyright : Copyright (c) 2005-2010 Boris Kolpackov
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef CULT_TYPES_SHPTR_HXX
+#define CULT_TYPES_SHPTR_HXX
+
+#include <cult/mm/shptr.hxx>
+
+namespace Cult
+{
+  namespace Types
+  {
+    using MM::Shptr;
+  }
+
+  using Types::Shptr;
+}
+
+#endif  // CULT_TYPES_SHPTR_HXX
diff --git a/libcult/cult/types/string.hxx b/libcult/cult/types/string.hxx
new file mode 100644
index 0000000..108f830
--- /dev/null
+++ b/libcult/cult/types/string.hxx
@@ -0,0 +1,397 @@
+// file      : cult/types/string.hxx
+// author    : Boris Kolpackov <boris@kolpackov.net>
+// copyright : Copyright (c) 2005-2010 Boris Kolpackov
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef CULT_TYPES_STRING_HXX
+#define CULT_TYPES_STRING_HXX
+
+#include <cult/types/fundamental.hxx>
+#include <cult/eh/exception.hxx>
+
+//@@ Dependency on 'containers'. Maybe move iterator to 'types'?
+//
+#include <cult/containers/iterator.hxx>
+
+#include <string>
+#include <cstdlib> // mbstowcs
+
+namespace Cult
+{
+  namespace Types
+  {
+    //@@ Maybe create StringFwd.hxx
+    //
+
+    namespace Bits
+    {
+      struct None {};
+
+      template <typename C>
+      struct NarrowerChar
+      {
+        typedef None Type;
+      };
+
+
+      template <>
+      struct NarrowerChar<WideChar>
+      {
+        typedef Char Type;
+      };
+    }
+
+    template <typename C,
+              typename NarrowerChar = typename Bits::NarrowerChar<C>::Type>
+    class StringTemplate;
+
+    template <>
+    class StringTemplate<Bits::None, Bits::None>
+    {
+    };
+
+
+    template <typename C, typename NarrowerChar>
+    class StringTemplate : public std::basic_string<C>
+    {
+      typedef std::basic_string<C> Base;
+      typedef std::basic_string<NarrowerChar> NarrowerBase;
+
+      Base&
+      base ()
+      {
+        return *this;
+      }
+
+      Base const&
+      base () const
+      {
+        return *this;
+      }
+
+    public:
+      typedef typename Base::value_type Value;
+
+      /*
+      typedef traits traits_type;
+      typedef typename traits::char_type value_type;
+      typedef Allocator allocator_type;
+      typedef typename Allocator::size_type size_type;
+      typedef typename Allocator::difference_type difference_type;
+      typedef typename Allocator::reference reference;
+      typedef typename Allocator::const_reference const_reference;
+      typedef typename Allocator::pointer pointer;
+      typedef typename Allocator::const_pointer const_pointer;
+      */
+
+      typedef
+      Containers::IteratorAdapter<typename Base::iterator>
+      Iterator;
+
+      typedef
+      Containers::IteratorAdapter<typename Base::const_iterator>
+      ConstIterator;
+
+
+      typedef
+      Containers::IteratorAdapter<typename Base::reverse_iterator>
+      ReverseIterator;
+
+      typedef
+      Containers::IteratorAdapter<typename Base::const_reverse_iterator>
+      ConstReverseIterator;
+
+
+      using Base::npos;
+      using Base::empty;
+
+    public:
+      explicit
+      StringTemplate ()
+      {
+      }
+
+      StringTemplate (StringTemplate const& str, Size pos, Size n = npos)
+          : Base (str, pos, n)
+      {
+      }
+
+      StringTemplate (Value const* s, Size n)
+          : Base (s, n)
+      {
+      }
+
+      StringTemplate (Value const* s)
+          : Base (s)
+      {
+      }
+
+      StringTemplate (Size n, Value c)
+          : Base (n, c)
+      {
+      }
+
+      template <typename InputIterator>
+      StringTemplate(InputIterator begin, InputIterator end)
+          : Base (begin, end)
+      {
+      }
+
+      StringTemplate (StringTemplate const& other)
+          : Base (other)
+      {
+      }
+
+      // Conversion from Base.
+      //
+      StringTemplate (Base const& str)
+          : Base (str)
+      {
+      }
+
+      // Conversion from the Narrower type. Experimental.
+      //
+      StringTemplate (NarrowerChar const* s)
+      {
+        from_narrow (s);
+      }
+
+      StringTemplate (StringTemplate<NarrowerChar> const& other)
+      {
+        from_narrow (other.c_str ());
+      }
+
+      StringTemplate (NarrowerBase const& other)
+      {
+        from_narrow (other.c_str ());
+      }
+
+      // Conversion to the Narrower type. Experimental.
+      //
+      struct NonRepresentable: virtual EH::Exception {};
+
+      StringTemplate<NarrowerChar>
+      to_narrow () const;
+
+      // Assignment.
+      //
+      StringTemplate&
+      operator= (StringTemplate const& str)
+      {
+        base () = str;
+        return *this;
+      }
+
+      StringTemplate&
+      operator= (Value const* s)
+      {
+        base () = s;
+        return *this;
+      }
+
+      StringTemplate&
+      operator= (Value c)
+      {
+        base () = c;
+        return *this;
+      }
+
+      // Assignment from Base.
+      //
+      StringTemplate&
+      operator= (Base const& str)
+      {
+        base () = str;
+        return *this;
+      }
+
+    public:
+      StringTemplate&
+      operator+= (StringTemplate const& str)
+      {
+        base () += str;
+        return *this;
+      }
+
+      StringTemplate&
+      operator+= (Value const* s)
+      {
+        base () += s;
+        return *this;
+      }
+
+      StringTemplate&
+      operator+= (Value c)
+      {
+        base () += c;
+        return *this;
+      }
+
+
+    public:
+      Iterator
+      begin ()
+      {
+        return Iterator (base ().begin ());
+      }
+
+      Iterator
+      end ()
+      {
+        return Iterator (base ().end ());
+      }
+
+
+      ConstIterator
+      begin () const
+      {
+        return ConstIterator (base ().begin ());
+      }
+
+      ConstIterator
+      end () const
+      {
+        return ConstIterator (base ().end ());
+      }
+
+      //
+      //
+
+      ReverseIterator
+      rbegin ()
+      {
+        return ReverseIterator (base ().rbegin ());
+      }
+
+      ReverseIterator
+      rend ()
+      {
+        return ReverseIterator (base ().rend ());
+      }
+
+
+      ConstReverseIterator
+      rbegin () const
+      {
+        return ConstReverseIterator (base ().rbegin ());
+      }
+
+      ConstReverseIterator
+      rend () const
+      {
+        return ConstReverseIterator (base ().rend ());
+      }
+
+
+      // Conversion to Boolean.
+      //
+    private:
+      typedef Void (StringTemplate::*BooleanConvertable)();
+
+      void
+      true_ ()
+      {
+      }
+
+    public:
+      operator BooleanConvertable () const
+      {
+        return empty () ? 0 : &StringTemplate::true_;
+      }
+
+    private:
+      Void
+      from_narrow (NarrowerChar const* s);
+    };
+
+
+    template<typename C>
+    StringTemplate<C>
+    operator+ (StringTemplate<C> const& lhs, StringTemplate<C> const& rhs)
+    {
+      return StringTemplate<C> (lhs) += rhs;
+    }
+
+    template<typename C>
+    StringTemplate<C>
+    operator+ (C const* lhs, StringTemplate<C> const& rhs)
+    {
+      return StringTemplate<C> (lhs) += rhs;
+    }
+
+    template<typename C>
+    StringTemplate<C>
+    operator+ (StringTemplate<C> const& lhs, C const* rhs)
+    {
+      return StringTemplate<C> (lhs) += rhs;
+    }
+
+    template<typename C>
+    StringTemplate<C>
+    operator+ (C lhs, StringTemplate<C> const& rhs)
+    {
+      return StringTemplate<C> (1, lhs) += rhs;
+    }
+
+
+    template<typename C>
+    StringTemplate<C>
+    operator+ (StringTemplate<C> const& lhs, C rhs)
+    {
+      return StringTemplate<C> (lhs) += rhs;
+    }
+
+    //
+    //
+    typedef StringTemplate<Char> String;
+    typedef StringTemplate<Char> NarrowString;
+    typedef StringTemplate<WideChar> WideString;
+
+    // Specialization for Char to WideChar conversion.
+    //
+    template <>
+    inline Void StringTemplate<WideChar, Char>::
+    from_narrow (Char const* s)
+    {
+      Size size (std::mbstowcs (0, s, 0) + 1);
+
+      // I dare to change the guts!
+      //
+      resize (size - 1);
+
+      WideChar* p (const_cast<WideChar*> (data ()));
+
+      std::mbstowcs (p, s, size);
+    }
+
+    // Specialization for WideChar to Char conversion.
+    //
+    template <>
+    inline StringTemplate<Char> StringTemplate<WideChar, Char>::
+    to_narrow () const
+    {
+      Size size (std::wcstombs (0, c_str (), 0));
+
+      if (size == Size (-1))
+        throw NonRepresentable ();
+
+      // I dare to change the guts!
+      //
+      StringTemplate<Char> r;
+      r.resize (size);
+
+      Char* p (const_cast<Char*> (r.data ()));
+
+      std::wcstombs (p, c_str (), size + 1);
+
+      return r;
+    }
+  }
+
+  using Types::String;
+  using Types::NarrowString;
+  using Types::WideString;
+  using Types::StringTemplate;
+}
+
+#endif  // CULT_TYPES_STRING_HXX