ofile_w32.hpp

Go to the documentation of this file.

/*****************************************************************************
** Ifdefs
*****************************************************************************/

#ifndef ECL_DEVICES_OFILE_W32_HPP_
#define ECL_DEVICES_OFILE_W32_HPP_

/*****************************************************************************
** Cross Platform Functionality
*****************************************************************************/

#include <ecl/config/ecl.hpp>
#if defined(ECL_IS_WIN32)

/*****************************************************************************
** Includes
*****************************************************************************/

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <cstdio> // FILE calls
#include <string>
#include <ecl/concepts/containers.hpp>
#include <ecl/exceptions/macros.hpp>
#include <ecl/exceptions/standard_exception.hpp>
#include "detail/exception_handler_pos.hpp"
#include "modes.hpp"
#include "traits.hpp"
#include "macros.hpp"

/*****************************************************************************
** Namespaces
*****************************************************************************/

namespace ecl {

/*****************************************************************************
** Interface [Output File]
*****************************************************************************/
class ecl_devices_PUBLIC OFile {
public:
        /*********************
        ** C&D
        **********************/
        OFile();
        OFile(const std::string &file_name, const WriteMode &mode = New) ecl_throw_decl(StandardException);

        virtual ~OFile();

        /*********************
        ** Open/Close
        **********************/
        virtual bool open() { return ( file != NULL ) ? true : false; }

        virtual bool open(const std::string &file_name, const WriteMode &mode = New) ecl_throw_decl(StandardException);

        virtual bool close() ecl_throw_decl(StandardException);

        /*********************
        ** Utility Methods
        **********************/
        virtual const std::string& filename() const { return name; }


        /*********************
        ** Output Methods
        **********************/
        virtual long write(const char &c) ecl_debug_throw_decl(StandardException);
        long write(const char* s, unsigned long n) ecl_debug_throw_decl(StandardException);

        template <typename ByteArray>
        long write(const ByteArray &byte_array) ecl_debug_throw_decl(StandardException);
        virtual bool flush() ecl_debug_throw_decl(StandardException);

        const Error& error() const { return error_handler; }

private:
        /*********************
        ** Variables
        **********************/
        int file_descriptor;
    FILE *file;
    std::string name;
    Error error_handler;
};

/*****************************************************************************
** Template Implementation
*****************************************************************************/

template <typename ByteArray>
long OFile::write(const ByteArray&byte_array) ecl_debug_throw_decl(StandardException) {

    ecl_compile_time_concept_check(ecl::ByteContainerConcept<ByteArray>);
    if ( !open() ) {
        ecl_debug_throw(ecl::StandardException(LOC, OpenError, std::string("File ") + name + std::string(" is not open for writing.")));
        error_handler = OpenError;
        return -1;
    }
    size_t written = fwrite(&byte_array[0],byte_array.size(),1,file);
    if ( written == 0) {
        ecl_debug_throw(ecl::StandardException(LOC, WriteError, std::string("Could not write to ") + name + std::string(".")));
        error_handler = WriteError;
        return -1;
    }
    error_handler = NoError;
    return byte_array.size()*written; // fwrite returns the number of 'items' written, not bytes!
}


/*****************************************************************************
** Traits [OFile]
*****************************************************************************/

template <>
class is_sink<OFile> : public True {};

} // namespace ecl


#endif /* ECL_IS_WIN32 */
#endif /* ECL_DEVICES_OFILE_W32_HPP_ */