first commit

extern/ustl/1.5/sistream.h

@@ -0,0 +1,153 @@
+// This file is part of the uSTL library, an STL implementation.
+//
+// Copyright (c) 2005 by Mike Sharov <msharov@users.sourceforge.net>
+// This file is free software, distributed under the MIT License.
+
+#ifndef SISTREAM_H_0CCA102229A49F5D65EE852E62B27CE2
+#define SISTREAM_H_0CCA102229A49F5D65EE852E62B27CE2
+
+#include "mistream.h"
+#include "ustring.h"
+#ifndef EOF
+#define EOF (-1)
+#endif
+
+namespace ustl {
+
+/// \class istringstream sistream.h ustl.h
+/// \ingroup TextStreams
+///
+/// \brief A stream that reads textual data from a memory block.
+///
+class istringstream : public istream {
+public:
+    static const size_type	c_MaxDelimiters = 16;	///< Maximum number of word delimiters.
+public:
+    				istringstream (void);
+				istringstream (const void* p, size_type n);
+    explicit			istringstream (const cmemlink& source);
+    void			iread (int8_t& v)	{ v = skip_delimiters(); }
+    void			iread (int32_t& v);
+    void			iread (double& v);
+    void			iread (bool& v);
+    void			iread (wchar_t& v);
+    void			iread (string& v);
+#if HAVE_INT64_T
+    void			iread (int64_t& v);
+#endif
+#if HAVE_LONG_LONG && (!HAVE_INT64_T || SIZE_OF_LONG_LONG > 8)
+    void			iread (long long& v);
+#endif
+    inline string		str (void) const	{ string s; s.link (*this); return (s); }
+    inline istringstream&	str (const string& s)	{ link (s); return (*this); }
+    inline istringstream&	get (char& c)	{ return (read (&c, sizeof(c))); }
+    inline int			get (void)	{ char c = EOF; get(c); return (c); }
+    istringstream&		get (char* p, size_type n, char delim = '\n');
+    istringstream&		get (string& s, char delim = '\n');
+    istringstream&		getline (char* p, size_type n, char delim = '\n');
+    istringstream&		getline (string& s, char delim = '\n');
+    istringstream&		ignore (size_type n, char delim = '\0');
+    inline char			peek (void)	{ int8_t v; iread (v); ungetc(); return (v); }
+    inline istringstream&	putback (char)	{ ungetc(); return (*this); }
+    inline istringstream&	unget (void)	{ ungetc(); return (*this); }
+    inline void			set_delimiters (const char* delimiters);
+    inline void			set_base (short base);
+    inline void			set_decimal_separator (char)	{ }
+    inline void			set_thousand_separator (char)	{ }
+    istringstream&		read (void* buffer, size_type size);
+    inline istringstream&	read (memlink& buf)		{ return (read (buf.begin(), buf.size())); }
+    inline istringstream&	seekg (off_t p, seekdir d =beg)	{ istream::seekg(p,d); return (*this); }
+    inline int			sync (void)			{ skip (remaining()); return (0); }
+protected:
+    char			skip_delimiters (void);
+private:
+    inline void			read_strz (string&)	{ assert (!"Reading nul characters is not allowed from text streams"); }
+    inline bool			is_delimiter (char c) const;
+    template <typename T> void	read_number (T& v);
+private:
+    char			m_Delimiters [c_MaxDelimiters];
+    uint8_t			m_Base;
+};
+
+//----------------------------------------------------------------------
+
+/// Sets the numeric base used to read numbers.
+inline void istringstream::set_base (short base)
+{
+    m_Base = base;
+}
+
+/// Sets delimiters to the contents of \p delimiters.
+inline void istringstream::set_delimiters (const char* delimiters)
+{
+#if (__i386__ || __x86_64__) && CPU_HAS_SSE && HAVE_VECTOR_EXTENSIONS
+    typedef uint32_t v16ud_t __attribute__((vector_size(16)));
+    asm("xorps\t%%xmm0, %%xmm0\n\tmovups\t%%xmm0, %0":"=m"(*noalias_cast<v16ud_t*>(m_Delimiters))::"xmm0");
+#else
+    memset (m_Delimiters, 0, sizeof(m_Delimiters));
+#endif
+    memcpy (m_Delimiters, delimiters, min (strlen(delimiters),sizeof(m_Delimiters)-1));
+}
+
+/// Reads one type as another.
+template <typename RealT, typename CastT>
+inline void _cast_read (istringstream& is, RealT& v)
+{
+    CastT cv;
+    is.iread (cv);
+    v = RealT (cv);
+}
+
+/// Reads a line of text from \p is into \p s
+inline istringstream& getline (istringstream& is, string& s)
+    { return (is.getline (s)); }
+
+//----------------------------------------------------------------------
+
+template <typename T> struct object_text_reader {
+    inline void operator()(istringstream& is, T& v) const { v.text_read (is); }
+};
+template <typename T> struct integral_text_object_reader {
+    inline void operator()(istringstream& is, T& v) const { is.iread (v); }
+};
+template <typename T>
+inline istringstream& operator>> (istringstream& is, T& v) {
+    typedef typename tm::Select <numeric_limits<T>::is_integral,
+	integral_text_object_reader<T>, object_text_reader<T> >::Result object_reader_t;
+    object_reader_t()(is, v);
+    return (is);
+}
+
+//----------------------------------------------------------------------
+
+template <> struct object_text_reader<string> {
+    inline void operator()(istringstream& is, string& v) const { is.iread (v); }
+};
+#define ISTRSTREAM_CAST_OPERATOR(RealT, CastT)		\
+template <> struct integral_text_object_reader<RealT> {	\
+    inline void operator() (istringstream& is, RealT& v) const	\
+	{ _cast_read<RealT,CastT>(is, v); }		\
+};
+ISTRSTREAM_CAST_OPERATOR (uint8_t,	int8_t)
+ISTRSTREAM_CAST_OPERATOR (int16_t,	int32_t)
+ISTRSTREAM_CAST_OPERATOR (uint16_t,	int32_t)
+ISTRSTREAM_CAST_OPERATOR (uint32_t,	int32_t)
+ISTRSTREAM_CAST_OPERATOR (float,	double)
+#if HAVE_THREE_CHAR_TYPES
+ISTRSTREAM_CAST_OPERATOR (char,		int8_t)
+#endif
+#if HAVE_INT64_T
+ISTRSTREAM_CAST_OPERATOR (uint64_t,	int64_t)
+#endif
+#if SIZE_OF_LONG == SIZE_OF_INT
+ISTRSTREAM_CAST_OPERATOR (long,		int)
+ISTRSTREAM_CAST_OPERATOR (unsigned long,int)
+#endif
+#if HAVE_LONG_LONG && (!HAVE_INT64_T || SIZE_OF_LONG_LONG > 8)
+ISTRSTREAM_CAST_OPERATOR (unsigned long long, long long)
+#endif
+#undef ISTRSTREAM_CAST_OPERATOR
+
+} // namespace ustl
+
+#endif