Thread portable class Gate portable class Timer class Pool class Terimber 2.0 About C++

Downloads Products & Services Support Clients Open Source About Home / Open source / Terimber 2.0 aiofile.h Go to the documentation of this file. /* * The Software License * ================================================================================= * Copyright (c) 2003-.The Terimber Corporation. All rights reserved. * ================================================================================= * Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * The end-user documentation included with the redistribution, if any, * must include the following acknowledgment: * "This product includes software developed by the Terimber Corporation." * ================================================================================= * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE TERIMBER CORPORATION OR ITS CONTRIBUTORS BE LIABLE FOR * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ================================================================================ */ #ifndef _terimber_aiofile_h_ #define _terimber_aiofile_h_ #include "base/primitives.h" #include "base/stack.h" #include "base/list.h" #include "base/map.h" #include "threadpool/threadpool.h" #include "threadpool/thread.h" #include "aiofile/aiofilefactory.h" #include "aiocomport/aiocomport.h" BEGIN_TERIMBER_NAMESPACE #pragma pack(4) class aiofile_block : public OVERLAPPED { public: aiofile_block(); aiofile_block(const aiofile_block& x); aiofile_block& operator=(const aiofile_block& x); void clear(); void set_timeout( size_t timeout ); public: aiofile_type _type; char* _buf; size_t _len; size_t _file_ident; size_t _processed; int _err; void* _userdata; #if OS_TYPE == OS_WIN32 size_t #else timeval #endif _timeout; sb8_t _expired; }; typedef HANDLE aio_file_handle; class aiofile : public terimber_thread_employer, public terimber_aiofile { typedef node_allocator< base_list< aiofile_block* >::_node > aiofile_pblock_allocator_t; typedef _list< aiofile_block*, aiofile_pblock_allocator_t > aiofile_pblock_alloc_list_t; typedef list< aiofile_block* > aiofile_pblock_list_t; typedef node_allocator< aiofile_block > aiofile_block_allocator_t; class listener_info { public: listener_info( size_t curr_count, size_t max_count, void* userdata ) : _curr_count(curr_count), _max_count(max_count), _userdata(userdata) { } size_t _curr_count; size_t _max_count; void* _userdata; }; typedef map< size_t, listener_info > aiofile_listener_map_t; class aiofile_file { public: aiofile_file( aio_file_handle handle, terimber_aiofile_callback* callback ) : _handle(handle), _client_obj(callback), _callback_invoking(0) { } aiofile_file(const aiofile_file& x) : _handle(x._handle), _client_obj(x._client_obj), _callback_invoking(x._callback_invoking) {} ~aiofile_file() { assert(_incoming_list.empty()); } aio_file_handle _handle; terimber_aiofile_callback* _client_obj; aiofile_pblock_alloc_list_t _incoming_list; size_t _callback_invoking; }; typedef map< size_t, aiofile_file > aiofile_file_map_t; typedef map< size_t, aiofile_file >::iterator aiofile_file_map_iterator_t; typedef map< aio_file_handle, aiofile_file_map_iterator_t > aiofile_reverse_map_t; typedef map< aio_file_handle, aiofile_file_map_iterator_t >::iterator aiofile_reverse_map_iterator_t; typedef map< size_t, size_t > aiofile_delay_key_t; void _clear_block_lists() { if (!_outgoing_list.empty()) { for (aiofile_pblock_list_t::iterator out_iter = _outgoing_list.begin(); out_iter != _outgoing_list.end(); ++out_iter) { aiofile_block* block = *out_iter; _put_block(block); } _outgoing_list.clear(); } #if OS_TYPE == OS_WIN32 if (!_abounded_list.empty()) { for (aiofile_pblock_list_t::iterator tm_iter = _abounded_list.begin(); tm_iter != _abounded_list.end(); ++tm_iter) { aiofile_block* block = *tm_iter; _put_block(block); } _abounded_list.clear(); } #endif if (!_initial_list.empty()) { for (aiofile_pblock_list_t::iterator in_iter = _initial_list.begin(); in_iter != _initial_list.end(); ++in_iter) { aiofile_block* block = *in_iter; _put_block(block); } _initial_list.clear(); } } inline aiofile_block* _get_block() { aiofile_block* ptr = _block_allocator.allocate(); if (ptr) { new(ptr) aiofile_block(); } return ptr; } inline void _put_block(aiofile_block* block) { block->~aiofile_block(); _block_allocator.deallocate(block); } public: aiofile(size_t capacity, size_t deactivate_time_msec ); ~aiofile(); bool on(); void off(); virtual size_t open( const char* file_name, bool read_write, terimber_aiofile_callback* callback ); virtual void close( size_t handle ); virtual int write( size_t handle, size_t offset, const void* buf, size_t len, size_t timeout, void* userdata ); virtual int read( size_t handle, size_t offset, void* buf, size_t len, size_t timeout, void* userdata ); virtual void doxray(); protected: virtual bool v_has_job( size_t ident, void* data ); virtual void v_do_job( size_t ident, void* data ); private: bool resolve_socket_address(const char* address, unsigned short port, sockaddr_in& addr ); aio_file_handle find_socket_handle( size_t ident ); void process_timeouted_blocks(); void complete_block( size_t sock_key, aiofile_block* ov, int err, size_t processed ); int _activate_block( size_t ident, aiofile_block* block ); size_t _assign_file( aio_file_handle handle, terimber_aiofile_callback* callback ); void _cancel_file( aio_file_handle handle ); #if OS_TYPE != OS_WIN32 void _cancel_aio( aio_file_handle handle, OVERLAPPED* overlapped ); #endif void _close_file( aio_file_handle handle ); int _process_block( aiofile_block* block ); int _process_write( aio_file_handle handle, aiofile_block* block ); int _process_read( aio_file_handle handle, aiofile_block* block ); void wait_for_io_completion(); public: mutex _mtx; aiofile_file_map_t _file_map; aiofile_reverse_map_t _reverse_map; aiofile_delay_key_t _delay_key_map; unique_key_generator _file_generator; aiofile_pblock_allocator_t _incoming_list_allocator; aiofile_block_allocator_t _block_allocator; aiofile_pblock_list_t _initial_list; aiofile_pblock_list_t _outgoing_list; #if OS_TYPE == OS_WIN32 aiofile_pblock_list_t _abounded_list; #endif private: HANDLE _aiofile_io_handle; threadpool _thread_pool; size_t _capacity; thread _in_thread; static bool _port_init; bool _on; bool _flag_io_port; event _start_io_port; event _stop_io_port; }; #pragma pack() END_TERIMBER_NAMESPACE #endif // _terimber_aioport_h_

© Copyright Terimber 2003-.