#include <file_win32_wrapper.h>

Inheritance diagram for file_win32_wrapper_overlapped_t< p_writeable >:

Public Member Functions
	file_win32_wrapper_overlapped_t (HANDLE file)

	~file_win32_wrapper_overlapped_t ()

bool	can_seek ()

bool	get_content_type (pfc::string_base &out)

t_filesize	get_position (abort_callback &p_abort)

t_filesize	get_size (abort_callback &p_abort)

t_filetimestamp	get_timestamp (abort_callback &p_abort)

bool	is_in_memory ()

bool	is_remote ()

void	on_idle (abort_callback &p_abort)

t_size	read (void *p_buffer, t_size p_bytes, abort_callback &p_abort)

void	reopen (abort_callback &p_abort)

void	resize (t_filesize p_size, abort_callback &p_abort)

void	seek (t_filesize p_position, abort_callback &p_abort)

void	write (const void *p_buffer, t_size p_bytes, abort_callback &p_abort)

Static Public Member Functions
static file::ptr	g_create_from_handle (HANDLE p_handle)

static file::ptr	g_CreateFile (const char *p_path, DWORD p_access, DWORD p_sharemode, LPSECURITY_ATTRIBUTES p_security_attributes, DWORD p_createmode, DWORD p_flags, HANDLE p_template)

Protected Attributes
HANDLE	m_event

HANDLE	m_handle

t_filesize	m_position

Detailed Description

template<bool p_writeable>
class file_win32_wrapper_overlapped_t< p_writeable >

Definition at line 154 of file file_win32_wrapper.h.

Constructor & Destructor Documentation

template<bool p_writeable>

file_win32_wrapper_overlapped_t< p_writeable >::file_win32_wrapper_overlapped_t ( HANDLE file )

inline

Definition at line 156 of file file_win32_wrapper.h.

                                                  : m_handle(file), m_position() {
         WIN32_OP( (m_event = CreateEvent(NULL, TRUE, FALSE, NULL)) != NULL );
     }

template<bool p_writeable>

file_win32_wrapper_overlapped_t< p_writeable >::~file_win32_wrapper_overlapped_t ( )

inline

Definition at line 159 of file file_win32_wrapper.h.

159 {CloseHandle(m_event); CloseHandle(m_handle);}

file_win32_wrapper_overlapped_t::m_event

HANDLE m_event

Definition: file_win32_wrapper.h:237

file_win32_wrapper_overlapped_t::m_handle

HANDLE m_handle

Definition: file_win32_wrapper.h:237

Member Function Documentation

template<bool p_writeable>

bool file_win32_wrapper_overlapped_t< p_writeable >::can_seek ( )

inline

Definition at line 201 of file file_win32_wrapper.h.

201 {return true;}

template<bool p_writeable>

static file::ptr file_win32_wrapper_overlapped_t< p_writeable >::g_create_from_handle ( HANDLE p_handle )

inlinestatic

Definition at line 232 of file file_win32_wrapper.h.

                                                          {
         return new service_impl_t<file_win32_wrapper_overlapped_t<p_writeable> >(p_handle);
     }

template<bool p_writeable>

static file::ptr file_win32_wrapper_overlapped_t< p_writeable >::g_CreateFile	(	const char *	p_path,
		DWORD	p_access,
		DWORD	p_sharemode,
		LPSECURITY_ATTRIBUTES	p_security_attributes,
		DWORD	p_createmode,
		DWORD	p_flags,
		HANDLE	p_template
	)

inlinestatic

Definition at line 218 of file file_win32_wrapper.h.

                                                                                                                                                                                      {
         p_flags |= FILE_FLAG_OVERLAPPED;
         SetLastError(NO_ERROR);
         HANDLE handle = uCreateFile(p_path,p_access,p_sharemode,p_security_attributes,p_createmode,p_flags,p_template);
         if (handle == INVALID_HANDLE_VALUE) {
             const DWORD code = GetLastError();
             if (p_access & GENERIC_WRITE) win32_file_write_failure(code, p_path);
             else exception_io_from_win32(code);
         }
         try {
             return g_create_from_handle(handle);
         } catch(...) {CloseHandle(handle); throw;}
     }

template<bool p_writeable>

bool file_win32_wrapper_overlapped_t< p_writeable >::get_content_type ( pfc::string_base & out )

inline

Definition at line 202 of file file_win32_wrapper.h.

202 {return false;}

template<bool p_writeable>

t_filesize file_win32_wrapper_overlapped_t< p_writeable >::get_position ( abort_callback & p_abort )

inline

Definition at line 176 of file file_win32_wrapper.h.

                                                       {
         p_abort.check_e();
         return m_position;
     }

template<bool p_writeable>

t_filesize file_win32_wrapper_overlapped_t< p_writeable >::get_size ( abort_callback & p_abort )

inline

Definition at line 171 of file file_win32_wrapper.h.

                                                   {
         p_abort.check_e();
         return file_win32_helpers::get_size(m_handle);
     }

template<bool p_writeable>

t_filetimestamp file_win32_wrapper_overlapped_t< p_writeable >::get_timestamp ( abort_callback & p_abort )

inline

Definition at line 206 of file file_win32_wrapper.h.

                                                             {
         p_abort.check_e();
         FlushFileBuffers(m_handle);
         SetLastError(ERROR_SUCCESS);
         t_filetimestamp temp;
         if (!GetFileTime(m_handle,0,0,(FILETIME*)&temp)) exception_io_from_win32(GetLastError());
         return temp;
     }

template<bool p_writeable>

bool file_win32_wrapper_overlapped_t< p_writeable >::is_in_memory ( )

inline

Definition at line 203 of file file_win32_wrapper.h.

203 {return false;}

template<bool p_writeable>

bool file_win32_wrapper_overlapped_t< p_writeable >::is_remote ( )

inline

Definition at line 215 of file file_win32_wrapper.h.

215 {return false;}

template<bool p_writeable>

void file_win32_wrapper_overlapped_t< p_writeable >::on_idle ( abort_callback & p_abort )

inline

Definition at line 204 of file file_win32_wrapper.h.

204 {p_abort.check_e();}

template<bool p_writeable>

t_size file_win32_wrapper_overlapped_t< p_writeable >::read	(	void *	p_buffer,
		t_size	p_bytes,
		abort_callback &	p_abort
	)

inline

Definition at line 164 of file file_win32_wrapper.h.

                                                                          {
         return file_win32_helpers::readOverlapped(m_handle, m_event, m_position, p_buffer, p_bytes, p_abort);
     }

template<bool p_writeable>

void file_win32_wrapper_overlapped_t< p_writeable >::reopen ( abort_callback & p_abort )

inline

Definition at line 168 of file file_win32_wrapper.h.

168 {seek(0,p_abort);}

file_win32_wrapper_overlapped_t::seek

void seek(t_filesize p_position, abort_callback &p_abort)

Definition: file_win32_wrapper.h:194

template<bool p_writeable>

void file_win32_wrapper_overlapped_t< p_writeable >::resize	(	t_filesize	p_size,
		abort_callback &	p_abort
	)

inline

Definition at line 181 of file file_win32_wrapper.h.

                                                             {
         if (!p_writeable) throw exception_io_denied();
         p_abort.check_e();
         file_win32_helpers::seek(m_handle,p_size,file::seek_from_beginning);
         SetLastError(ERROR_SUCCESS);
         if (!SetEndOfFile(m_handle)) {
             DWORD code = GetLastError();
             exception_io_from_win32(code);
         }
         if (m_position > p_size) m_position = p_size;
     }

template<bool p_writeable>

void file_win32_wrapper_overlapped_t< p_writeable >::seek	(	t_filesize	p_position,
		abort_callback &	p_abort
	)

inline

Definition at line 194 of file file_win32_wrapper.h.

                                                               {
         p_abort.check_e();
         if (p_position > file_win32_helpers::get_size(m_handle)) throw exception_io_seek_out_of_range();
         // file_win32_helpers::seek(m_handle,p_position,file::seek_from_beginning);
         m_position = p_position;
     }

template<bool p_writeable>

void file_win32_wrapper_overlapped_t< p_writeable >::write	(	const void *	p_buffer,
		t_size	p_bytes,
		abort_callback &	p_abort
	)

inline

Definition at line 160 of file file_win32_wrapper.h.

                                                                               {
         if (!p_writeable) throw exception_io_denied();
         return file_win32_helpers::writeOverlapped(m_handle, m_event, m_position, p_buffer, p_bytes, p_abort);
     }