UTFile.h

Go to the documentation of this file.

//==================================================================================================
// Copyright (C) 2010  Brian Tietz    sdbtietz at yahoo dot com
//
// This program is free software; you can redistribute it and/or modify it under the terms of the
// GNU General Public License as published by the Free Software Foundation, version 2.0 of the
// License.
//
// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
// even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with this program; if
// not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301, USA.
//
// For commercial software, the copyright holder (Brian Tietz, email sdbtietz at yahoo dot com)
// reserves the right and is willing to waive the proprietary source code disclosure aspects of that
// license as applied to the UT library in exchange for either substantial contributions to the
// development of the UT library or other forms of compensation.  Any such waiver must be
// established in writing between the copyright holder and the commercial entity obtaining such a
// waiver.
//==================================================================================================


#ifndef _UT_FILE_H_
#define _UT_FILE_H_


//==================================================================================================
//=== System headers
//==================================================================================================
#include <fcntl.h>


//==================================================================================================
//=== Project headers
//==================================================================================================
#include "UTIOStreams.h"
#include "UTPath.h"
#include "UTMessageLoop.h"
#include "UTEvent.h"


//==================================================================================================
//=== Constants
//==================================================================================================

// \cond DOXYGEN_DOCUMENT_NEVER

enum async_status_t
{
    eAS_closed,
    eAS_opening,
    eAS_opened,
    eAS_idle,
    eAS_read,
    eAS_write
};

enum thread_io_helper_command_t
{
    eTIOHC_open,
    eTIOHC_idle,
    eTIOHC_read,
    eTIOHC_write,
    eTIOHC_quit
};

// \endcond


//==================================================================================================
//=== Forward name declarations
//==================================================================================================
class FileOpenCompleteMessage_t;
class FileReadCompleteMessage_t;
class FileWriteCompleteMessage_t;
class FilePlatformInfo_t;
class ThreadedIOHelper_t;


//==================================================================================================
class UT_EXPORT File_t
//==================================================================================================
:   public IOStream_t
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
                            File_t();

    virtual                 ~File_t();

    virtual Status_t        Open(
                                const Path_t& path,
                                int flags,
                                mode_t permissions = 0,
                                MessageDestination_t<FileReadCompleteMessage_t>* read_dest = NULL,
                                MessageDestination_t<FileWriteCompleteMessage_t>* write_dest = NULL,
                                MessageDestination_t<FileOpenCompleteMessage_t>* open_dest = NULL
                                );

    inline Status_t         Open(
                                const utf8* path,
                                int flags,
                                mode_t permissions = 0,
                                MessageDestination_t<FileReadCompleteMessage_t>* read_dest = NULL,
                                MessageDestination_t<FileWriteCompleteMessage_t>* write_dest = NULL,
                                MessageDestination_t<FileOpenCompleteMessage_t>* open_dest = NULL );

    inline Status_t         Open(
                                stringliteral* path,
                                int flags,
                                mode_t permissions = 0,
                                MessageDestination_t<FileReadCompleteMessage_t>* read_dest = NULL,
                                MessageDestination_t<FileWriteCompleteMessage_t>* write_dest = NULL,
                                MessageDestination_t<FileOpenCompleteMessage_t>* open_dest = NULL );

    inline int              OpenFlags() const;

    inline int              OpenRWFlags() const;

    inline const Path_t&    Path() const;

    virtual Status_t        Read( byte* buffer, int bytes_to_read, bool force_read_all = true );

    virtual Status_t        Write(  const byte* buffer,
                                    int bytes_to_write,
                                    bool force_write_all = true );

    virtual Status_t        Size(out fileoff_t* size);

    virtual Status_t        Position(out fileoff_t* position);

    virtual Status_t        Seek(fileoff_t position);

    virtual Status_t        Flush();

    virtual Status_t        Close();

    //----------------------------------------------------------------------------------------------
    protected:
    //----------------------------------------------------------------------------------------------
    virtual Status_t        AsyncOpenComplete();

    //----------------------------------------------------------------------------------------------
    protected:
    //----------------------------------------------------------------------------------------------
    #if LOG_FILE_OPS
    virtual void            AppendStateInfo(String_t* state) const;
    #endif

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    Path_t                                              m_path;
    int                                                 m_flags;
    int                                                 m_rw_flags;
    FilePlatformInfo_t*                                 m_platform_info;
    Status_t                                            m_status;
    MessageDestination_t<FileReadCompleteMessage_t>     m_read_dest;
    MessageDestination_t<FileWriteCompleteMessage_t>    m_write_dest;
    MessageDestination_t<FileOpenCompleteMessage_t>     m_open_dest;
    async_status_t                                      m_async_status;
    byte*                                               m_async_buffer;
    int                                                 m_async_bytes;
    fileoff_t                                           m_pos;
    fileoff_t                                           m_size;

    friend class FilePlatformInfo_t;
    friend class ThreadedIOHelper_t;
};


//==================================================================================================
class UT_EXPORT FileOpenCompleteMessage_t
//==================================================================================================
: public Message_t
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
    inline                  FileOpenCompleteMessage_t(Status_t status);

    inline const Status_t&  Status() const;

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    Status_t                m_status;
};


//==================================================================================================
class UT_EXPORT FileReadCompleteMessage_t
//==================================================================================================
: public Message_t
{ };


//==================================================================================================
class UT_EXPORT FileWriteCompleteMessage_t
//==================================================================================================
: public Message_t
{ };


// \cond DOXYGEN_DOCUMENT_NEVER

//==================================================================================================
class ThreadedIOHelper_t
//==================================================================================================
: public Thread_t
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
                                ThreadedIOHelper_t( FilePlatformInfo_t* file_info,
                                                    File_t* file,
                                                    int flags,
                                                    int rw_flags,
                                                    int permissions );
                                ThreadedIOHelper_t( FilePlatformInfo_t* file_info, File_t* file );
                                ~ThreadedIOHelper_t();

    virtual void                Main();

    int                         Read(   byte* buffer,
                                        int bytes_to_read,
                                        bool force_read_all );
    int                         Write(  const byte* buffer,
                                        int bytes_to_write,
                                        bool force_write_all );

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    FilePlatformInfo_t*         m_file_info;
    File_t*                     m_file;
    int                         m_flags;
    int                         m_rw_flags;
    int                         m_permissions;
    thread_io_helper_command_t  m_command;
    byte*                       m_command_buffer;
    int                         m_command_io_length;
    bool                        m_command_force_all;
    Event_t                     m_command_event;
    Event_t                     m_command_complete_event;
    error_code_t                m_io_status;

    friend class FilePlatformInfo_t;
};

// \endcond




//==================================================================================================
//==================================================================================================
//===
//=== Inline function implementations
//===
//==================================================================================================
//==================================================================================================
inline Status_t
File_t::Open(   const utf8* path,
                int flags,
                mode_t permissions,
                MessageDestination_t<FileReadCompleteMessage_t>* read_dest,
                MessageDestination_t<FileWriteCompleteMessage_t>* write_dest,
                MessageDestination_t<FileOpenCompleteMessage_t>* open_dest )
{
    // Using the stringliteral form allows the temporary Path_t to borrow the caller's utf8* rather
    // than copying it
    return Open( Path_t(path), flags, permissions, read_dest, write_dest, open_dest );
}


inline Status_t
File_t::Open(   stringliteral* path,
                int flags,
                mode_t permissions,
                MessageDestination_t<FileReadCompleteMessage_t>* read_dest,
                MessageDestination_t<FileWriteCompleteMessage_t>* write_dest,
                MessageDestination_t<FileOpenCompleteMessage_t>* open_dest )
{
    return Open( Path_t(path), flags, permissions, read_dest, write_dest, open_dest );
}


inline int
File_t::OpenFlags() const
{
    return m_flags;
}


inline int
File_t::OpenRWFlags() const
{
    return m_rw_flags;
}


inline const Path_t&
File_t::Path() const
{
    return m_path;
}


inline
FileOpenCompleteMessage_t::FileOpenCompleteMessage_t(Status_t status)
{
    m_status = status;
}


inline const Status_t&
FileOpenCompleteMessage_t::Status() const
{
    return m_status;
}


#endif // _UT_FILE_H_