/*

 * Copyright (c) 1999

 * Silicon Graphics Computer Systems, Inc.

 *

 * Copyright (c) 1999

 * Boris Fomitchev

 *

 * This material is provided "as is", with absolutely no warranty expressed

 * or implied. Any use is at your own risk.

 *

 * Permission to use or copy this software for any purpose is hereby granted

 * without fee, provided the above notices are retained on all copies.

 * Permission to modify the code and to distribute modified code is granted,

 * provided the above notices are retained, and a notice that the code was

 * modified is included with the above copyright notice.

 *

 */

// WARNING: This is an internal header file, included by other C++

// standard library headers.  You should not attempt to use this header

// file directly.

#ifndef _STLP_INTERNAL_CODECVT_H

#define _STLP_INTERNAL_CODECVT_H

#ifndef _STLP_C_LOCALE_H

#  include <stl/c_locale.h>

#endif

#ifndef _STLP_INTERNAL_LOCALE_H

#  include <stl/_locale.h>

#endif

#ifndef _STLP_INTERNAL_ALGOBASE_H

#  include <stl/_algobase.h>

#endif

_STLP_BEGIN_NAMESPACE

class _STLP_CLASS_DECLSPEC codecvt_base {

public:

  enum result {ok, partial, error, noconv};

};

template <class _InternT, class _ExternT, class _StateT>

class codecvt : public locale::facet, public codecvt_base {

public:

  typedef _InternT intern_type;

  typedef _ExternT extern_type;

  typedef _StateT state_type;

#if defined (_STLP_MSVC) && (_STLP_MSVC < 1300)

  /* For the moment VC6 do not support this facet default implementation

   * because of the static locale::id instance. When VC6 see this definition

   * it goes crasy with locale::id static instances and all the has_facet tests

   * unit tests are failing.

   */

};

#else

  explicit codecvt(size_t __refs = 0) : locale::facet(__refs) {}

  result out(state_type&          __state,

             const intern_type*   __from,

             const intern_type*   __from_end,

             const intern_type*&  __from_next,

             extern_type*         __to,

             extern_type*         __to_limit,

             extern_type*&        __to_next) const {

    return do_out(__state,

                  __from, __from_end, __from_next,

                  __to,   __to_limit, __to_next);

  }

  result unshift(state_type&    __state,

                 extern_type*   __to,

                 extern_type*   __to_limit,

                 extern_type*&  __to_next) const {

    return do_unshift(__state, __to, __to_limit, __to_next);

  }

  result in(state_type&         __state,

            const extern_type*  __from,

            const extern_type*  __from_end,

            const extern_type*& __from_next,

            intern_type*        __to,

            intern_type*        __to_limit,

            intern_type*&       __to_next) const {

    return do_in(__state,

                 __from, __from_end, __from_next,

                 __to,  __to_limit, __to_next);

  }

  int encoding() const _STLP_NOTHROW { return do_encoding(); }

  bool always_noconv() const _STLP_NOTHROW { return do_always_noconv(); }

  int length(const state_type&  __state,

             const extern_type* __from,

             const extern_type* __end,

             size_t             __max) const {

    return do_length(__state, __from, __end, __max);

  }

  int max_length() const _STLP_NOTHROW { return do_max_length(); }

  static _STLP_STATIC_MEMBER_DECLSPEC locale::id id;

protected:

  ~codecvt() {}

  virtual result do_out(state_type&,

                        const intern_type*  __from,

                        const intern_type*,

                        const intern_type*& __from_next,

                        extern_type*        __to,

                        extern_type*,

                        extern_type*&       __to_next) const

  { __from_next = __from; __to_next   = __to; return noconv; }

  virtual result do_in (state_type&,

                        const extern_type*  __from,

                        const extern_type*,

                        const extern_type*& __from_next,

                        intern_type*        __to,

                        intern_type*,

                        intern_type*&       __to_next) const

  { __from_next = __from; __to_next = __to; return noconv; }

  virtual result do_unshift(state_type&,

                            extern_type* __to,

                            extern_type*,

                            extern_type*& __to_next) const

  { __to_next = __to; return noconv; }

  virtual int do_encoding() const _STLP_NOTHROW

  { return 1; }

  virtual bool do_always_noconv() const _STLP_NOTHROW

  { return true; }

  virtual int do_length(const state_type&,

                        const extern_type* __from,

                        const extern_type* __end,

                        size_t __max) const

  { return (int)(min) ( __STATIC_CAST(size_t, (__end - __from)), __max); }

  virtual int do_max_length() const _STLP_NOTHROW

  { return 1; }

private:

  codecvt(const codecvt<intern_type, extern_type, state_type>&);

  codecvt<intern_type, extern_type, state_type>& operator = (const codecvt<intern_type, extern_type, state_type>&);

};

#  if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)

#    if (_STLP_STATIC_TEMPLATE_DATA > 0)

#      if !defined (__BORLANDC__)

template <class _InternT, class _ExternT, class _StateT>

locale::id codecvt<_InternT, _ExternT, _StateT>::id;

#      endif

#    endif

#  endif

#endif

template <class _InternT, class _ExternT, class _StateT>

class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT> {};

_STLP_TEMPLATE_NULL

class _STLP_CLASS_DECLSPEC codecvt<char, char, mbstate_t>

  : public locale::facet, public codecvt_base

{

  friend class _Locale_impl;

public:

  typedef char       intern_type;

  typedef char       extern_type;

  typedef mbstate_t  state_type;

  explicit codecvt(size_t __refs = 0) : locale::facet(__refs) {}

  result out(mbstate_t&   __state,

             const char*  __from,

             const char*  __from_end,

             const char*& __from_next,

             char*        __to,

             char*        __to_limit,

             char*&       __to_next) const {

    return do_out(__state,

                  __from, __from_end, __from_next,

                  __to,   __to_limit, __to_next);

  }

  result unshift(mbstate_t& __state,

                 char* __to, char* __to_limit, char*& __to_next) const

    { return do_unshift(__state, __to, __to_limit, __to_next); }

  result in(state_type&   __state,

            const char*  __from,

            const char*  __from_end,

            const char*& __from_next,

            char*        __to,

            char*        __to_limit,

            char*&       __to_next) const {

    return do_in(__state,

                 __from, __from_end, __from_next,

                 __to,   __to_limit, __to_next);

  }

  int encoding() const _STLP_NOTHROW { return do_encoding(); }

  bool always_noconv() const _STLP_NOTHROW { return do_always_noconv(); }

  int length(const state_type& __state,

             const char* __from, const char* __end,

             size_t __max) const

    { return do_length(__state, __from, __end, __max); }

  int max_length() const _STLP_NOTHROW { return do_max_length(); }

  static _STLP_STATIC_MEMBER_DECLSPEC locale::id id;

protected:

  ~codecvt();

  virtual result do_out(mbstate_t&   /* __state */,

                        const char*  __from,

                        const char*  /* __from_end */,

                        const char*& __from_next,

                        char*        __to,

                        char*        /* __to_limit */,

                        char*&       __to_next) const;

  virtual result do_in (mbstate_t&   /* __state */ ,

                        const char*  __from,

                        const char*  /* __from_end */,

                        const char*& __from_next,

                        char*        __to,

                        char*        /* __to_end */,

                        char*&       __to_next) const;

  virtual result do_unshift(mbstate_t& /* __state */,

                            char*      __to,

                            char*      /* __to_limit */,

                            char*&     __to_next) const;

  virtual int do_encoding() const _STLP_NOTHROW;

  virtual bool do_always_noconv() const _STLP_NOTHROW;

  virtual int do_length(const mbstate_t&         __state,

                        const  char* __from,

                        const  char* __end,

                        size_t __max) const;

  virtual int do_max_length() const _STLP_NOTHROW;

private:

  codecvt(const codecvt<char, char, mbstate_t>&);

  codecvt<char, char, mbstate_t>& operator =(const codecvt<char, char, mbstate_t>&);

};

# ifndef _STLP_NO_WCHAR_T

_STLP_TEMPLATE_NULL

class _STLP_CLASS_DECLSPEC codecvt<wchar_t, char, mbstate_t>

  : public locale::facet, public codecvt_base

{

  friend class _Locale_impl;

public:

  typedef wchar_t    intern_type;

  typedef char       extern_type;

  typedef mbstate_t  state_type;

  explicit codecvt(size_t __refs = 0) : locale::facet(__refs) {}

  result out(mbstate_t&      __state,

             const wchar_t*  __from,

             const wchar_t*  __from_end,

             const wchar_t*& __from_next,

             char*           __to,

             char*           __to_limit,

             char*&          __to_next) const {

    return do_out(__state,

                  __from, __from_end, __from_next,

                  __to,   __to_limit, __to_next);

  }

  result unshift(mbstate_t& __state,

                 char*  __to, char*  __to_limit, char*& __to_next) const {

    return do_unshift(__state, __to, __to_limit, __to_next);

  }

  result in(mbstate_t&   __state,

            const char*  __from,

            const char*  __from_end,

            const char*& __from_next,

            wchar_t*     __to,

            wchar_t*     __to_limit,

            wchar_t*&    __to_next) const {

    return do_in(__state,

                 __from, __from_end, __from_next,

                 __to,   __to_limit, __to_next);

  }

  int encoding() const _STLP_NOTHROW { return do_encoding(); }

  bool always_noconv() const _STLP_NOTHROW { return do_always_noconv(); }

  int length(const mbstate_t& __state,

             const char* __from, const char* __end,

             size_t __max) const

    { return do_length(__state, __from, __end, __max); }

  int max_length() const _STLP_NOTHROW { return do_max_length(); }

  static _STLP_STATIC_MEMBER_DECLSPEC locale::id id;

protected:

  ~codecvt();

  virtual result do_out(mbstate_t&         __state,

                        const wchar_t*  __from,

                        const wchar_t*  __from_end,

                        const wchar_t*& __from_next,

                        char*        __to,

                        char*        __to_limit,

                        char*&       __to_next) const;

  virtual result do_in (mbstate_t&         __state,

                        const char*  __from,

                        const char*  __from_end,

                        const char*& __from_next,

                        wchar_t*        __to,

                        wchar_t*        __to_limit,

                        wchar_t*&       __to_next) const;

  virtual result do_unshift(mbstate_t&   __state,

                            char*  __to,

                            char*  __to_limit,

                            char*& __to_next) const;

  virtual int do_encoding() const _STLP_NOTHROW;

  virtual bool do_always_noconv() const _STLP_NOTHROW;

  virtual int do_length(const mbstate_t& __state,

                        const  char* __from,

                        const  char* __end,

                        size_t __max) const;

  virtual int do_max_length() const _STLP_NOTHROW;

private:

  codecvt(const codecvt<wchar_t, char, mbstate_t>&);

  codecvt<wchar_t, char, mbstate_t>& operator = (const codecvt<wchar_t, char, mbstate_t>&);

};

# endif

_STLP_TEMPLATE_NULL

class _STLP_CLASS_DECLSPEC codecvt_byname<char, char, mbstate_t>

  : public codecvt<char, char, mbstate_t> {

public:

  explicit codecvt_byname(const char* __name, size_t __refs = 0);

  ~codecvt_byname();

private:

  codecvt_byname(const codecvt_byname<char, char, mbstate_t>&);

  codecvt_byname<char, char, mbstate_t>& operator =(const codecvt_byname<char, char, mbstate_t>&);

};

# ifndef _STLP_NO_WCHAR_T

_STLP_TEMPLATE_NULL

class _STLP_CLASS_DECLSPEC codecvt_byname<wchar_t, char, mbstate_t>

  : public codecvt<wchar_t, char, mbstate_t>

{

public:

  explicit codecvt_byname(const char * __name, size_t __refs = 0, _Locale_name_hint* __hint = 0);

protected:

  ~codecvt_byname();

  virtual result do_out(mbstate_t&         __state,

                        const wchar_t*  __from,

                        const wchar_t*  __from_end,

                        const wchar_t*& __from_next,

                        char*        __to,

                        char*        __to_limit,

                        char*&       __to_next) const;

  virtual result do_in (mbstate_t&         __state,

                        const char*  __from,

                        const char*  __from_end,

                        const char*& __from_next,

                        wchar_t*        __to,

                        wchar_t*        __to_limit,

                        wchar_t*&       __to_next) const;

  virtual result do_unshift(mbstate_t&   __state,

                            char*  __to,

                            char*  __to_limit,

                            char*& __to_next) const;

  virtual int do_encoding() const _STLP_NOTHROW;

  virtual bool do_always_noconv() const _STLP_NOTHROW;

  virtual int do_length(const mbstate_t&         __state,

                        const  char* __from,

                        const  char* __end,

                        size_t __max) const;

  virtual int do_max_length() const _STLP_NOTHROW;

private:

  _Locale_ctype* _M_ctype;

  codecvt_byname(const codecvt_byname<wchar_t, char, mbstate_t>&);

  codecvt_byname<wchar_t, char, mbstate_t>& operator =(const codecvt_byname<wchar_t, char, mbstate_t>&);

};

# endif

_STLP_END_NAMESPACE

#endif /* _STLP_INTERNAL_CODECVT_H */

// Local Variables:

// mode:C++

// End: