暇つぶしに _file_t を書いてみた

FILE* いれとく方のコンストラクタ辺りがダメダメダメだけど書いてみた。
まあ、こんなもんさ。

#ifndef metis__file_t_hxx
#define metis__file_t_hxx

#include <stdio.h>
#include <stdarg.h>
#include <tchar.h>

/**
 * @namespace metis
 * 多分、標準ライブラリの薄いラッパーの集まりになる悪寒。
 * <pre>
 * 「メティスは木星のアマルテア群の衛星の中で最も内側の軌道にある衛星」だそーです(ただしソースは wikipedia)。
 * </pre>
 */
namespace metis {


    /**
     * 指定されたファイル名と、モードでファイルを開きます。
     *    @param filename 開きたいファイル名。
     *    @param mode     開くモード。
     *
     *    @return 開いたファイルのストリーム。
     */
    inline FILE* _T_fopen(const _TCHAR* filename, const _TCHAR* mode) {
        FILE* result_stream = NULL;
#ifdef _MSC_VER
        errno_t er = ::_tfopen_s( &result_stream, filename, mode );
#else
        result_stream  = ::_tfopen( filename, mode );
#endif  /* def _MSC_VER */
        return result_stream;
    }


    /**
     * 指定されたストリームから、size 分だけ count 回 buffer に読み込みます。
     *    @param buffer  読み込んだデータを格納したいバッファの先頭ポインタ。
     *    @param size    読み込みたいデータのサイズ。
     *    @param count   読み込みたいデータの個数。
     *    @param stream  読み込むストリーム。
     *
     *    @return 読み込みに成功した個数。
     */
    inline size_t _T_fread(void* buffer, size_t size, size_t count, FILE* stream) {
        return ::fread( buffer, size, count, stream );
    }


    /**
     * 指定されたストリームから、size 分だけ count 回 buffer に書き込みます。
     *    @param buffer  書き込んだデータを格納したいバッファの先頭ポインタ。
     *    @param size    書き込みたいデータのサイズ。
     *    @param count   書き込みたいデータの個数。
     *    @param stream  書き込むストリーム。
     *
     *    @return 書き込みに成功した個数。
     */
    inline size_t _T_fwrite(const void* buffer, size_t size, size_t count, FILE* stream) {
        return ::fwrite( buffer, size, count, stream );
    }


    /**
     * 指定したストリームに str を書き込みます。
     *    @param str    書き込みたい文字列。
     *    @param stream 書き込むストリーム。
     *
     *    @return 負ではない数。
     */
    inline int _T_fputs(const _TCHAR* str, FILE* stream) {
        return ::fputs( str, stream );
    }


    /**
     * 文字 ch を指定されたストリームに書き込みます。
     *    @param ch     書き込みたい文字。
     *    @param stream 書き込みたいストリーム。
     *
     *    @return 書き込んだ文字を int にキャストしたもの。
     */
    inline int _T_fputc(_TCHAR ch, FILE* stream) {
        return ::fputc( ch, stream );
    }


    /**
     * 指定されたストリームに指定された書式に変換して出力します。
     *    @param stream     出力したいストリーム。
     *    @param format     書式。
     *    @param arguments  引数リスト。
     *
     *    @return 書き込まれた文字数。
     */
    inline int _T_fprintf(FILE* stream, _TCHAR* format, ...) {
        va_list   arguments;

        int result  = 0;

        va_start(arguments, format);
#ifdef _MS_VER
        result = _vftprintf_s( stream, format, arguments );
#else
        result = _vftprintf( stream, format, arguments );
#endif  /* def _MS_VER */
        va_end(arguments);

        return result;
    }


    /**
     * 指定したストリームを閉じます。
     *    @param stream 閉じたいストリーム。
     */
    inline void _T_fclose(FILE* stream) {
        ::fclose( stream );
    }


    /**
     * 指定されたストリームの内容をフラッシュします。
     *    @param  フラッシュしたいストリーム。
     *
     *    @return 成功したら 0。
     */
    inline int _T_fflush(FILE* stream) {
        return ::fflush( stream );
    }


    /**
     *
     */
    inline int _T_fileno(FILE* stream) {
#ifdef _MSC_VER
        return _fileno( stream );
#else
        return fileno( stream );
#endif  /* def _MSC_VER */
    }


    /**
     * 指定されたストリームの現在位置を取得します。
     *    @param 現在位置を取得したいストリーム。
     * 
     *    @return 現在のファイル位置。
     */
    inline int _T_ftell(FILE* stream) {
        return ::ftell( stream );
    }


    /**
     * ストリームの位置を変更します。
     *    @param stream 位置を変更したいストリーム。
     *    @param offset ずらしたいバイト数。
     *    @param origin ずらす位置の列挙体値。
     *
     *    @return 成功すると 0。
     */
    inline int _T_fseek(FILE* stream, long offset, int origin = SEEK_CUR) {
        return ::fseek( stream, offset, origin );
    }


    /**
     * @class _file_t  _file_t.hpp
     * 
     */
    class _file_t {
     public:
        /**
         *
         */
        _file_t();
        /**
         *
         */
        _file_t(const _TCHAR* filename, const _TCHAR* mode);
        /**
         *
         */
        _file_t(FILE* const& fp);
        /**
         *
         */
        _file_t(const _file_t& other);


        /**
         *
         */
        ~_file_t();

     public:
        /**
         *
         */
        int file_descriptor() const;


        /**
         *
         */
        size_t read(void* buffer, size_t size);


        /**
         *
         */
        size_t write(const void* buffer, size_t size);


        /**
         *
         */
        int puts(const _TCHAR* s);


        /**
         * 
         */
        int print(const _TCHAR* s);


        /**
         * 
         */
        int printf(const _TCHAR* format, ...);


        /**
         *
         */
        int flush();


        /**
         *
         */
        void close();

     private:
        FILE*    fp_;
        bool     is_closed_;
    };


    _file_t::_file_t() : fp_(NULL), is_closed_(false) {
    }
    _file_t::_file_t(const _TCHAR* filename, const _TCHAR* mode) : fp_(NULL), is_closed_(false) {
        fp_ = _T_fopen( filename, mode );
    }
    _file_t::_file_t(FILE* const& fp) : fp_(fp), is_closed_(false) {
    }


    _file_t::~_file_t() {
        close();
    }


    int _file_t::file_descriptor() const {
        return _T_fileno( fp_ );
    }


    size_t _file_t::read(void* buffer, size_t size) {
        return _T_fread( buffer, size, 1, fp_ );
    }


    size_t _file_t::write(const void* buffer, size_t size) {
        return _T_fwrite( buffer, size, 1, fp_ );
    }


    int _file_t::print(const _TCHAR* s) {
        return printf( s );
    }


    int _file_t::printf(const _TCHAR* format, ...) {
        va_list   arguments;

        int result  = 0;

        va_start(arguments, format);
#ifdef _MS_VER
        result = _vftprintf_s( fp_, format, arguments );
#else
        result = _vftprintf( fp_, format, arguments );
#endif  /* def _MS_VER */
        va_end(arguments);

        return result;
    }


    /**
     *
     */
    int _file_t::puts(const _TCHAR* s) {
        return _T_fputs( s, fp_ );
    }


    /**
     *
     */
    int _file_t::flush() {
        return _T_fflush( fp_ );
    }


    /**
     *
     */
    void _file_t::close() {
        if ( fp_ ) {
            if ( !is_closed_ ) {
                _T_fclose( fp_ );
                is_closed_ = true;
            }
        }
    }


}


#endif  /* metis__file_t_hxx */