Ошибка при компиляции (.is not a member of std)

#include <windows.h>
#include <iostream>
#include <sstream>
#include <process.h>
#include <fstream>
 
namespace TST
{
    class Exception
    {
    public:
        Exception(const wchar_t* szwText)
            :   m_wstrText(szwText)
        {;};
 
        std::wstring What() const throw()
        {
            return m_wstrText;
        };
 
    protected:
        const std::wstring m_wstrText;
    };
 
    void le_chk(BOOL bResult, const char* file, int line)
    {
        if(!bResult)
        {
            std::clog << "An error " << GetLastError() << "occured";
            std::wostringstream os;
            os  << L"Win32 error occured: GetLastError returned " << GetLastError() << " in " << file << L"@" << line;
            throw Exception(os.str().c_str());
        };
    };
 
    #define TST_LE_CHECK(res)   le_chk((res), __FILE__, __LINE__)
 
    class CallBase
    {
    public:
        virtual void Call() = 0;
    };
 
    class AsyncActionBase
    {
    public:
        AsyncActionBase(CallBase* pCall)
            :   m_hThread(NULL)
        {
            unsigned uId = 0;
            m_hThread = (HANDLE)_beginthreadex(NULL, 0, &AsyncActionBase::thread_proc, (void*)pCall, 0, &uId);
            TST_LE_CHECK(!!m_hThread);
        };
 
        virtual ~AsyncActionBase()
        {
            if(m_hThread)
            {
                TST_LE_CHECK(WaitForSingleObject(m_hThread, INFINITE)!= WAIT_FAILED);
                TST_LE_CHECK(CloseHandle(m_hThread));
                m_hThread = NULL;
            };
        };
    protected:
        static unsigned __stdcall thread_proc(void * p)
        {
            try
            {
                ((CallBase*)p)->Call();
            }
            catch (const TST::Exception& excpt)
            {
                std::wcerr << excpt.What();
            };
            return 0;
        };
        HANDLE m_hThread;
    };
 
    class MyAsyncAction1
        :   public CallBase
        ,   public AsyncActionBase
    {
    public:
        MyAsyncAction1()
            :   AsyncActionBase(this)
        {
            ;
        };
        
        virtual ~MyAsyncAction1()
        {
            ;
        };
 
    //CallBase
        virtual void Call()
        {
            for(size_t i = 0; i < 100; ++i)
            {
                std::cout << "Test #" << (i+1) << std::endl;
                Sleep(10);
            };
        };
    };
};
 
int main()
{
    try
    {
        TST::MyAsyncAction1 oBj;
    }
    catch (const TST::Exception& excpt)
    {
        std::wcerr << excpt.What();
    };
};

// sstream standard header
#pragma once
#ifndef _SSTREAM_
#define _SSTREAM_
#ifndef RC_INVOKED
#include <string>
 
#ifdef _MSC_VER
 #pragma pack(push,_CRT_PACKING)
 #pragma warning(push,3)
#endif  /* _MSC_VER */
 
_STD_BEGIN
 
  #pragma warning(disable:4251)
 
        // TEMPLATE CLASS basic_stringbuf
template<class _Elem,
    class _Traits,
    class _Alloc>
    class basic_stringbuf
        : public basic_streambuf<_Elem, _Traits>
    {   // stream buffer maintaining an allocated character array
public:
    typedef _Alloc allocator_type;
    typedef basic_streambuf<_Elem, _Traits> _Mysb;
    typedef basic_string<_Elem, _Traits, _Alloc> _Mystr;
 
    explicit __CLR_OR_THIS_CALL basic_stringbuf(ios_base::openmode _Mode =
        ios_base::in | ios_base::out)
        {   // construct empty character buffer from mode
        _Init(0, 0, _Getstate(_Mode));
        }
 
    explicit __CLR_OR_THIS_CALL basic_stringbuf(const _Mystr& _Str,
        ios_base::openmode _Mode = ios_base::in | ios_base::out)
        {   // construct character buffer from string, mode
        _Init(_Str.c_str(), _Str.size(), _Getstate(_Mode));
        }
 
    virtual __CLR_OR_THIS_CALL ~basic_stringbuf()
        {   // destroy the object
        _Tidy();
        }
 
    enum
        {   // constants for bits in stream state
        _Allocated = 1, // set if character array storage has been allocated
        _Constant = 2,  // set if character array nonmutable
        _Noread = 4,    // set if character array cannot be read
        _Append = 8,    // set if all writes are appends
        _Atend = 16};   // set if initial writes are appends
    typedef int _Strstate;
 
    typedef typename _Traits::int_type int_type;
    typedef typename _Traits::pos_type pos_type;
    typedef typename _Traits::off_type off_type;
 
    _Mystr __CLR_OR_THIS_CALL str() const
        {   // return string copy of character array
        if (!(_Mystate & _Constant) && _Mysb::pptr() != 0)
            {   // writable, make string from write buffer
            _Mystr _Str(_Mysb::pbase(), (_Seekhigh < _Mysb::pptr()
                ? _Mysb::pptr() : _Seekhigh) - _Mysb::pbase());
            return (_Str);
            }
        else if (!(_Mystate & _Noread) && _Mysb::gptr() != 0)
            {   // readable, make string from read buffer
            _Mystr _Str(_Mysb::eback(), _Mysb::egptr() - _Mysb::eback());
            return (_Str);
            }
        else
            {   // inaccessible, return empty string
            _Mystr _Nul;
            return (_Nul);
            }
        }
 
    void __CLR_OR_THIS_CALL str(const _Mystr& _Newstr)
        {   // replace character array from string
        _Tidy();
        _Init(_Newstr.c_str(), _Newstr.size(), _Mystate);
        }
 
protected:
    virtual int_type __CLR_OR_THIS_CALL overflow(int_type _Meta = _Traits::eof())
        {   // put an element to stream
        if (_Mystate & _Append
            && _Mysb::pptr() != 0 && _Mysb::pptr() < _Seekhigh)
            _Mysb::setp(_Mysb::pbase(), _Seekhigh, _Mysb::epptr());
 
        if (_Traits::eq_int_type(_Traits::eof(), _Meta))
            return (_Traits::not_eof(_Meta));   // EOF, return success code
        else if (_Mysb::pptr() != 0
            && _Mysb::pptr() < _Mysb::epptr())
            {   // room in buffer, store it
            *_Mysb::_Pninc() = _Traits::to_char_type(_Meta);
            return (_Meta);
            }
        else if (_Mystate & _Constant)
            return (_Traits::eof());    // array nonmutable, fail
        else
            {   // grow buffer and store element
            size_t _Oldsize = _Mysb::pptr() == 0
                ? 0 : _Mysb::epptr() - _Mysb::eback();
            size_t _Newsize = _Oldsize;
            size_t _Inc = _Newsize / 2 < _MINSIZE
                ? _MINSIZE : _Newsize / 2;  // grow by 50 per cent
            _Elem *_Newptr = 0;
            _Elem *_Oldptr = _Mysb::eback();
 
            while (0 < _Inc && INT_MAX - _Inc < _Newsize)
                _Inc /= 2;  // increment causes overflow, halve it
            if (0 < _Inc)
                {   // finite increment, allocate new character array
                _Newsize += _Inc;
                _Newptr = _Al.allocate(_Newsize);
                }
 
            if (0 < _Oldsize)
                _Traits_helper::copy_s<_Traits>(_Newptr, _Newsize, _Oldptr, _Oldsize);
 
            if (_Oldsize == 0)
                {   // first growth, set up pointers
                _Seekhigh = _Newptr;
                _Mysb::setp(_Newptr, _Newptr + _Newsize);
                if (_Mystate & _Noread)
                    _Mysb::setg(_Newptr, 0, _Newptr);
                else
                    _Mysb::setg(_Newptr, _Newptr, _Newptr + 1);
                }
            else
                {   // not first growth, adjust pointers
                _Seekhigh = _Newptr + (_Seekhigh - _Oldptr);
                _Mysb::setp(_Newptr + (_Mysb::pbase() - _Oldptr),
                    _Newptr + (_Mysb::pptr() - _Oldptr),
                    _Newptr + _Newsize);
                if (_Mystate & _Noread)
                    _Mysb::setg(_Newptr, 0, _Newptr);
                else
                    _Mysb::setg(_Newptr,
                        _Newptr + (_Mysb::gptr() - _Oldptr),
                        _Mysb::pptr() + 1);
                }
 
            if (_Mystate & _Allocated)
                _Al.deallocate(_Oldptr, _Oldsize);
            _Mystate |= _Allocated;
 
            *_Mysb::_Pninc() = _Traits::to_char_type(_Meta);
            return (_Meta);
            }
        }
 
    virtual int_type __CLR_OR_THIS_CALL pbackfail(int_type _Meta = _Traits::eof())
        {   // put an element back to stream
        if (_Mysb::gptr() == 0
            || _Mysb::gptr() <= _Mysb::eback()
            || !_Traits::eq_int_type(_Traits::eof(), _Meta)
            && !_Traits::eq(_Traits::to_char_type(_Meta), _Mysb::gptr()[-1])
            && _Mystate & _Constant)
            return (_Traits::eof());    // can't put back, fail
        else
            {   // back up one position and store put-back character
            _Mysb::gbump(-1);
            if (!_Traits::eq_int_type(_Traits::eof(), _Meta))
                *_Mysb::gptr() = _Traits::to_char_type(_Meta);
            return (_Traits::not_eof(_Meta));
            }
        }
 
    virtual int_type __CLR_OR_THIS_CALL underflow()
        {   // get an element from stream, but don't point past it
        if (_Mysb::gptr() == 0)
            return (_Traits::eof());    // no character buffer, fail
        else if (_Mysb::gptr() < _Mysb::egptr())
            return (_Traits::to_int_type(*_Mysb::gptr()));  // return buffered
        else if (_Mystate & _Noread || _Mysb::pptr() == 0
            || _Mysb::pptr() <= _Mysb::gptr() && _Seekhigh <= _Mysb::gptr())
            return (_Traits::eof());    // can't read, fail
        else
            {   // extend read buffer into written area, then return buffered
            if (_Seekhigh < _Mysb::pptr())
                _Seekhigh = _Mysb::pptr();
            _Mysb::setg(_Mysb::eback(), _Mysb::gptr(), _Seekhigh);
            return (_Traits::to_int_type(*_Mysb::gptr()));
            }
        }
 
    virtual pos_type __CLR_OR_THIS_CALL seekoff(off_type _Off,
        ios_base::seekdir _Way,
        ios_base::openmode _Which = ios_base::in | ios_base::out)
        {   // change position by _Off, according to _Way, _Mode
        if (_Mysb::pptr() != 0 && _Seekhigh < _Mysb::pptr())
            _Seekhigh = _Mysb::pptr();  // update high-water pointer
 
        if (_Which & ios_base::in && _Mysb::gptr() != 0)
            {   // position within read buffer
            if (_Way == ios_base::end)
                _Off += (off_type)(_Seekhigh - _Mysb::eback());
            else if (_Way == ios_base::cur
                && (_Which & ios_base::out) == 0)
                _Off += (off_type)(_Mysb::gptr() - _Mysb::eback());
            else if (_Way != ios_base::beg)
                _Off = _BADOFF;
 
            if (0 <= _Off && _Off <= _Seekhigh - _Mysb::eback())
                {   // change read position
                _Mysb::gbump((int)(_Mysb::eback() - _Mysb::gptr() + _Off));
                if (_Which & ios_base::out && _Mysb::pptr() != 0)
                    _Mysb::setp(_Mysb::pbase(), _Mysb::gptr(),
                        _Mysb::epptr());    // change write position to match
                }
            else
                _Off = _BADOFF;
            }
        else if (_Which & ios_base::out && _Mysb::pptr() != 0)
            {   // position within write buffer
            if (_Way == ios_base::end)
                _Off += (off_type)(_Seekhigh - _Mysb::eback());
            else if (_Way == ios_base::cur)
                _Off += (off_type)(_Mysb::pptr() - _Mysb::eback());
            else if (_Way != ios_base::beg)
                _Off = _BADOFF;
 
            if (0 <= _Off && _Off <= _Seekhigh - _Mysb::eback())
                _Mysb::pbump((int)(_Mysb::eback()
                    - _Mysb::pptr() + _Off));   // change write position
            else
                _Off = _BADOFF;
            }
        else
            _Off = _BADOFF; // neither read nor write buffer selected, fail
        return (pos_type(_Off));
        }
 
    virtual pos_type __CLR_OR_THIS_CALL seekpos(pos_type _Ptr,
        ios_base::openmode _Mode = ios_base::in | ios_base::out)
        {   // change position to _Pos, according to _Mode
        streamoff _Off = (streamoff)_Ptr;
        if (_Mysb::pptr() != 0 && _Seekhigh < _Mysb::pptr())
            _Seekhigh = _Mysb::pptr();  // update high-water pointer
 
        if (_Off == _BADOFF)
            ;
        else if (_Mode & ios_base::in && _Mysb::gptr() != 0)
            {   // position within read buffer
            if (0 <= _Off && _Off <= _Seekhigh - _Mysb::eback())
                {   // change read position
                _Mysb::gbump((int)(_Mysb::eback() - _Mysb::gptr() + _Off));
                if (_Mode & ios_base::out && _Mysb::pptr() != 0)
                    _Mysb::setp(_Mysb::pbase(), _Mysb::gptr(),
                        _Mysb::epptr());    // change write position to match
                }
            else
                _Off = _BADOFF;
            }
        else if (_Mode & ios_base::out && _Mysb::pptr() != 0)
            {   // position within write buffer
            if (0 <= _Off && _Off <= _Seekhigh - _Mysb::eback())
                _Mysb::pbump((int)(_Mysb::eback()
                    - _Mysb::pptr() + _Off));   // change write position
            else
                _Off = _BADOFF;
            }
        else
            _Off = _BADOFF;
        return (streampos(_Off));
        }
 
    void __CLR_OR_THIS_CALL _Init(const _Elem *_Ptr,
        size_t _Count, _Strstate _State)
        {   // initialize buffer to [_Ptr, _Ptr + _Count), set state
        _Seekhigh = 0;
        _Mystate = _State;
 
        if (_Count != 0
            && (_Mystate & (_Noread | _Constant)) != (_Noread | _Constant))
            {   // finite buffer that can be read or written, set it up
            _Elem *_Pnew = _Al.allocate(_Count);
            _Traits_helper::copy_s<_Traits>(_Pnew, _Count, _Ptr, _Count);
            _Seekhigh = _Pnew + _Count;
 
            if (!(_Mystate & _Noread))
                _Mysb::setg(_Pnew, _Pnew,
                    _Pnew + _Count);    // setup read buffer
            if (!(_Mystate & _Constant))
                {   // setup write buffer, and maybe read buffer
                _Mysb::setp(_Pnew,
                    (_Mystate & _Atend) ? _Pnew + _Count : _Pnew,
                    _Pnew + _Count);
                if (_Mysb::gptr() == 0)
                    _Mysb::setg(_Pnew, 0, _Pnew);
                }
            _Mystate |= _Allocated;
            }
        }
 
    void __CLR_OR_THIS_CALL _Tidy()
        {   // discard any allocated buffer and clear pointers
        if (_Mystate & _Allocated)
            _Al.deallocate(_Mysb::eback(),
                (_Mysb::pptr() != 0 ? _Mysb::epptr()
                    : _Mysb::egptr()) - _Mysb::eback());
        _Mysb::setg(0, 0, 0);
        _Mysb::setp(0, 0);
        _Seekhigh = 0;
        _Mystate &= ~_Allocated;
        }
 
private:
    enum
        {   // constant for minimum buffer size
        _MINSIZE = 32};
 
    _Strstate __CLR_OR_THIS_CALL _Getstate(ios_base::openmode _Mode)
        {   // convert open mode to stream state bits
        _Strstate _State = (_Strstate)0;
        if (!(_Mode & ios_base::in))
            _State |= _Noread;
        if (!(_Mode & ios_base::out))
            _State |= _Constant;
        if (_Mode & ios_base::app)
            _State |= _Append;
        if (_Mode & ios_base::ate)
            _State |= _Atend;
        return (_State);
        }
 
    _Elem *_Seekhigh;   // the high-water pointer in character array
    _Strstate _Mystate; // the stream state
    allocator_type _Al; // the allocator object
    };
 
 #if defined(_DLL_CPPLIB) && !defined(_M_CEE_PURE)
 
template class _CRTIMP2_PURE basic_stringbuf<char,
    char_traits<char>, allocator<char> >;
template class _CRTIMP2_PURE basic_stringbuf<wchar_t,
    char_traits<wchar_t>, allocator<wchar_t> >;
 
 
 
 #endif /* _DLL_CPPLIB */
 
        // TEMPLATE CLASS basic_istringstream
template<class _Elem,
    class _Traits,
    class _Alloc>
    class basic_istringstream
        : public basic_istream<_Elem, _Traits>
    {   // input stream associated with a character array
public:
    typedef _Alloc allocator_type;
    typedef basic_stringbuf<_Elem, _Traits, _Alloc> _Mysb;
    typedef basic_string<_Elem, _Traits, _Alloc> _Mystr;
 
    explicit __CLR_OR_THIS_CALL basic_istringstream(ios_base::openmode _Mode = ios_base::in)
        : basic_istream<_Elem, _Traits>(&_Stringbuffer),
            _Stringbuffer(_Mode | ios_base::in)
        {   // construct empty readable character buffer
        }
 
    explicit __CLR_OR_THIS_CALL basic_istringstream(const _Mystr& _Str,
        ios_base::openmode _Mode = ios_base::in)
        : basic_istream<_Elem, _Traits>(&_Stringbuffer),
            _Stringbuffer(_Str, _Mode | ios_base::in)
        {   // construct readable character buffer from NTCS
        }
 
    virtual __CLR_OR_THIS_CALL ~basic_istringstream()
        {   // destroy the object
        }
 
    _Mysb *__CLR_OR_THIS_CALL rdbuf() const
        {   // return pointer to file buffer
        return ((_Mysb *)&_Stringbuffer);
        }
 
    _Mystr __CLR_OR_THIS_CALL str() const
        {   // return string copy of character array
        return (_Stringbuffer.str());
        }
 
    void __CLR_OR_THIS_CALL str(const _Mystr& _Newstr)
        {   // replace character array from string
        _Stringbuffer.str(_Newstr);
        }
 
private:
    _Mysb _Stringbuffer;    // the string buffer
    };
 
 #if defined(_DLL_CPPLIB) && !defined(_M_CEE_PURE)
 
template class _CRTIMP2_PURE basic_istringstream<char,
    char_traits<char>, allocator<char> >;
template class _CRTIMP2_PURE basic_istringstream<wchar_t,
    char_traits<wchar_t>, allocator<wchar_t> >;
 
 
 
 #endif /* _DLL_CPPLIB */
 
        // TEMPLATE CLASS basic_ostringstream
template<class _Elem,
    class _Traits,
    class _Alloc>
    class basic_ostringstream
        : public basic_ostream<_Elem, _Traits>
    {   // output stream associated with a character array
public:
    typedef _Alloc allocator_type;
    typedef basic_stringbuf<_Elem, _Traits, _Alloc> _Mysb;
    typedef basic_string<_Elem, _Traits, _Alloc> _Mystr;
 
    explicit __CLR_OR_THIS_CALL basic_ostringstream(ios_base::openmode _Mode = ios_base::out)
        : basic_ostream<_Elem, _Traits>(&_Stringbuffer),
            _Stringbuffer(_Mode | ios_base::out)
        {   // construct empty writable character buffer
        }
 
    explicit __CLR_OR_THIS_CALL basic_ostringstream(const _Mystr& _Str,
        ios_base::openmode _Mode = ios_base::out)
        : basic_ostream<_Elem, _Traits>(&_Stringbuffer),
            _Stringbuffer(_Str, _Mode | ios_base::out)
        {   // construct writable character buffer from NTCS
        }
 
    virtual __CLR_OR_THIS_CALL ~basic_ostringstream()
        {   // destroy the object
        }
 
    _Mysb *__CLR_OR_THIS_CALL rdbuf() const
        {   // return pointer to buffer
        return ((_Mysb *)&_Stringbuffer);
        }
 
    _Mystr __CLR_OR_THIS_CALL str() const
        {   // return string copy of character array
        return (_Stringbuffer.str());
        }
 
    void __CLR_OR_THIS_CALL str(const _Mystr& _Newstr)
        {   // replace character array from string
        _Stringbuffer.str(_Newstr);
        }
 
private:
    _Mysb _Stringbuffer;    // the string buffer
    };
 
 #if defined(_DLL_CPPLIB) && !defined(_M_CEE_PURE)
 
template class _CRTIMP2_PURE basic_ostringstream<char,
    char_traits<char>, allocator<char> >;
template class _CRTIMP2_PURE basic_ostringstream<wchar_t,
    char_traits<wchar_t>, allocator<wchar_t> >;
 
 
 
 #endif /* _DLL_CPPLIB */
 
        // TEMPLATE CLASS basic_stringstream
template<class _Elem,
    class _Traits,
    class _Alloc>
    class basic_stringstream
        : public basic_iostream<_Elem, _Traits>
    {   // input/output stream associated with a character array
public:
    typedef _Elem char_type;
    typedef _Traits traits_type;
    typedef _Alloc allocator_type;
    typedef typename _Traits::int_type int_type;
    typedef typename _Traits::pos_type pos_type;
    typedef typename _Traits::off_type off_type;
    typedef basic_string<_Elem, _Traits, _Alloc> _Mystr;
 
    explicit __CLR_OR_THIS_CALL basic_stringstream(ios_base::openmode _Mode =
        ios_base::in | ios_base::out)
        : basic_iostream<_Elem, _Traits>(&_Stringbuffer),
            _Stringbuffer(_Mode)
        {   // construct empty character buffer
        }
 
    explicit __CLR_OR_THIS_CALL basic_stringstream(const _Mystr& _Str,
        ios_base::openmode _Mode = ios_base::in | ios_base::out)
        : basic_iostream<_Elem, _Traits>(&_Stringbuffer),
            _Stringbuffer(_Str, _Mode)
        {   // construct character buffer from NTCS
        }
 
    virtual __CLR_OR_THIS_CALL ~basic_stringstream()
        {   // destroy the object
        }
 
    basic_stringbuf<_Elem, _Traits, _Alloc> *__CLR_OR_THIS_CALL rdbuf() const
        {   // return pointer to buffer
        return ((basic_stringbuf<_Elem, _Traits, _Alloc> *)&_Stringbuffer);
        }
 
    _Mystr __CLR_OR_THIS_CALL str() const
        {   // return string copy of character array
        return (_Stringbuffer.str());
        }
 
    void __CLR_OR_THIS_CALL str(const _Mystr& _Newstr)
        {   // replace character array from string
        _Stringbuffer.str(_Newstr);
        }
 
private:
    basic_stringbuf<_Elem, _Traits, _Alloc>
        _Stringbuffer;  // the string buffer
    };
 
 #if defined(_DLL_CPPLIB) && !defined(_M_CEE_PURE)
 
template class _CRTIMP2_PURE basic_stringstream<char,
    char_traits<char>, allocator<char> >;
template class _CRTIMP2_PURE basic_stringstream<wchar_t,
    char_traits<wchar_t>, allocator<wchar_t> >;
 
 
 
 #endif /* _DLL_CPPLIB */
_STD_END
 
#ifdef _MSC_VER
 #pragma warning(pop)
 #pragma pack(pop)
#endif  /* _MSC_VER */
 
#endif /* RC_INVOKED */
#endif /* _SSTREAM_ */