24 #include "../gtx/quaternion.hpp" 
   26 #ifndef GLM_ENABLE_EXPERIMENTAL 
   27 #       error "GLM: GLM_GTX_io is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 
   28 #elif GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 
   29 #       pragma message("GLM: GLM_GTX_io extension included") 
   32 #if GLM_COMPILER & GLM_COMPILER_CLANG 
   33 #       pragma clang diagnostic push 
   34 #       pragma clang diagnostic ignored "-Wpadded" 
   35 #       pragma clang diagnostic ignored "-Wshorten-64-to-32" 
   36 #       pragma clang diagnostic ignored "-Wglobal-constructors" 
   50                 enum order_type { column_major, row_major};
 
   52                 template<
typename CTy>
 
   53                 class format_punct : 
public std::locale::facet
 
   55                         typedef CTy char_type;
 
   59                         static std::locale::id id;
 
   66                         char_type  delim_right;
 
   71                         GLM_FUNC_DECL 
explicit format_punct(
size_t a = 0);
 
   72                         GLM_FUNC_DECL 
explicit format_punct(format_punct 
const&);
 
   75                 template<
typename CTy, 
typename CTr = std::
char_traits<CTy> >
 
   76                 class basic_state_saver {
 
   80                         GLM_FUNC_DECL 
explicit basic_state_saver(std::basic_ios<CTy,CTr>&);
 
   81                         GLM_FUNC_DECL ~basic_state_saver();
 
   85                         typedef ::std::basic_ios<CTy,CTr>      state_type;
 
   86                         typedef typename state_type::char_type char_type;
 
   87                         typedef ::std::ios_base::fmtflags      flags_type;
 
   88                         typedef ::std::streamsize              streamsize_type;
 
   89                         typedef ::std::locale 
const            locale_type;
 
   93                         streamsize_type precision_;
 
   94                         streamsize_type width_;
 
   98                         GLM_FUNC_DECL basic_state_saver& operator=(basic_state_saver 
const&);
 
  101                 typedef basic_state_saver<char>     state_saver;
 
  102                 typedef basic_state_saver<wchar_t> wstate_saver;
 
  104                 template<
typename CTy, 
typename CTr = std::
char_traits<CTy> >
 
  105                 class basic_format_saver
 
  109                         GLM_FUNC_DECL 
explicit basic_format_saver(std::basic_ios<CTy,CTr>&);
 
  110                         GLM_FUNC_DECL ~basic_format_saver();
 
  114                         basic_state_saver<CTy> 
const bss_;
 
  116                         GLM_FUNC_DECL basic_format_saver& operator=(basic_format_saver 
const&);
 
  119                 typedef basic_format_saver<char>     format_saver;
 
  120                 typedef basic_format_saver<wchar_t> wformat_saver;
 
  126                         GLM_FUNC_DECL 
explicit precision(
unsigned);
 
  133                         GLM_FUNC_DECL 
explicit width(
unsigned);
 
  136                 template<
typename CTy>
 
  141                         GLM_FUNC_DECL 
explicit delimeter(CTy , CTy , CTy  = 
',');
 
  148                         GLM_FUNC_DECL 
explicit order(order_type);
 
  153                 template<
typename FTy, 
typename CTy, 
typename CTr>
 
  154                 FTy 
const& get_facet(std::basic_ios<CTy,CTr>&);
 
  155                 template<
typename FTy, 
typename CTy, 
typename CTr>
 
  156                 std::basic_ios<CTy,CTr>& formatted(std::basic_ios<CTy,CTr>&);
 
  157                 template<
typename FTy, 
typename CTy, 
typename CTr>
 
  158                 std::basic_ios<CTy,CTr>& unformatted(std::basic_ios<CTy,CTr>&);
 
  160                 template<
typename CTy, 
typename CTr>
 
  161                 std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, precision 
const&);
 
  162                 template<
typename CTy, 
typename CTr>
 
  163                 std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, width 
const&);
 
  164                 template<
typename CTy, 
typename CTr>
 
  165                 std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, delimeter<CTy> 
const&);
 
  166                 template<
typename CTy, 
typename CTr>
 
  167                 std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, order 
const&);
 
  170         template<
typename CTy, 
typename CTr, 
typename T, qualifier Q>
 
  171         GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, qua<T, Q> 
const&);
 
  172         template<
typename CTy, 
typename CTr, 
typename T, qualifier Q>
 
  173         GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, vec<1, T, Q> 
const&);
 
  174         template<
typename CTy, 
typename CTr, 
typename T, qualifier Q>
 
  175         GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, vec<2, T, Q> 
const&);
 
  176         template<
typename CTy, 
typename CTr, 
typename T, qualifier Q>
 
  177         GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, vec<3, T, Q> 
const&);
 
  178         template<
typename CTy, 
typename CTr, 
typename T, qualifier Q>
 
  179         GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, vec<4, T, Q> 
const&);
 
  180         template<
typename CTy, 
typename CTr, 
typename T, qualifier Q>
 
  181         GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<2, 2, T, Q> 
const&);
 
  182         template<
typename CTy, 
typename CTr, 
typename T, qualifier Q>
 
  183         GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<2, 3, T, Q> 
const&);
 
  184         template<
typename CTy, 
typename CTr, 
typename T, qualifier Q>
 
  185         GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<2, 4, T, Q> 
const&);
 
  186         template<
typename CTy, 
typename CTr, 
typename T, qualifier Q>
 
  187         GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<3, 2, T, Q> 
const&);
 
  188         template<
typename CTy, 
typename CTr, 
typename T, qualifier Q>
 
  189         GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<3, 3, T, Q> 
const&);
 
  190         template<
typename CTy, 
typename CTr, 
typename T, qualifier Q>
 
  191         GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<3, 4, T, Q> 
const&);
 
  192         template<
typename CTy, 
typename CTr, 
typename T, qualifier Q>
 
  193         GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<4, 2, T, Q> 
const&);
 
  194         template<
typename CTy, 
typename CTr, 
typename T, qualifier Q>
 
  195         GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<4, 3, T, Q> 
const&);
 
  196         template<
typename CTy, 
typename CTr, 
typename T, qualifier Q>
 
  197         GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, mat<4, 4, T, Q> 
const&);
 
  199   template<
typename CTy, 
typename CTr, 
typename T, qualifier Q>
 
  200         GLM_FUNC_DECL std::basic_ostream<CTy,CTr> & operator<<(std::basic_ostream<CTy,CTr> &,
 
  201                                                          std::pair<mat<4, 4, T, Q> 
const, mat<4, 4, T, Q> 
const> 
const&);
 
  206 #if GLM_COMPILER & GLM_COMPILER_CLANG 
  207 #       pragma clang diagnostic pop