indexing

	description: "[
		The EGS_SPACE_PROXY is the primary interface that allows you to connect to the space
		and perform space operations.

		The EGS_SPACE_PROXY is used with the different space topologies and runtime modes in a 
		transparent manner. You can use the EGS_SPACE_PROXY object with an embedded, remote, single, 
		or clustered replicated or partitioned space.

		The basic space operations include the following:
		write - Writes an EGS_ENTRY into the space. 
		read - Reads an EGS_ENTRY from the space that matches a given template. 
		take - Removes an EGS_ENTRY from the space that matches the given template.
		update - Updates an EGS_ENTRY in the space.
		notify - Notifies a specified listener object, when an EGS_ENTRY entry that 
		matches a given template is written/taken/updated/expires in the space. 
		For more information see EGS_DATA_EVENT_SESSION.

		A space entry is any object that inherit the EGS_ENTRY
		An EGS_ENTRY object type is defined in gs.xml file (for more information on gs.xml see http://www.gigaspaces.com/wiki/x/NYHcAQ). <br>
		Before performing any space operation using a new EGS_ENTRY object type, the type
		must be published to the space by creating a snapshot of this type.

		In some operations (for example, read) an entry template should be provided. 
		A template is an EGS_ENTRY object. Any field in the template that has a specific value is 
		used to match entries with the same value. 
		Any field that is not specified (and therefore has the default 'null' value)
		is used as a wildcard and will match any value.
		Note that gs.xml defines for each field its 'null' value.

		SqlQuery object is another way to specify a template. EGS_SPACE_PROXY includes appropriate
		methods that accept SqlQuery argument.

		The EGS_SPACE_PROXY supports single and batch space operations. Batch operations are 
		used to optimize space operations with multiple objects and can boost the application 
		performance when interacting with the space.

		The EGS_SPACE_PROXY supports EGS_TRANSACTION. All relevant space operations accept a EGS_TRANSACTION
		argument.
	
		A EGS_SPACE_PROXY is obtained using the EGS_SPACE_FINDER.

		@see EGS_SPACE_FINDER, EGS_ENTRY, EGS_TRANSACTION, EGS_TRANSACTION_MANAGER, EGS_DATA_EVENT_SESSION

	]"

	legal: "See notice at end of class."
	status: "See notice at end of class."
	date: "$Date$"
	revision: "$Revision$"

class

	EGS_SPACE_PROXY

inherit

	EGS_EXTERNAL_CPP_OBJECT

	EGS_SHARED_EXCEPTION_HANDLER

create

	make_from_external

feature

	snapshot (template: EGS_ENTRY) is
			-- Enable the space to recognize a given type of EGS_ENTRY object. Before performing
	 		-- any space operation using a new EGS_ENTRY type (EGS_ENTRY derived-class), the type
	 		--   must be published to the space by creating a snapshot of a template of this type.
	 		--
			-- @param template - template object
		require
			was_not_exception: not was_exception
			template_not_void: template /= Void
		do
			cpp_snapshot (exception_handler, object_ptr, template.object_ptr)
		end


 	read (template: EGS_ENTRY; txn: EGS_TRANSACTION; timeout: INTEGER_64; modifiers: INTEGER): EGS_ENTRY is
			-- Read (according to the modifiers) any matching entry from the space,
			-- blocking until one exists. Return Void if the timeout expires.
			-- To read an entry a template is provided in order to find a matching entry.
			-- Any field in the template that has a specific value is used to match entries
			-- with the same value. Any field that is not specified (and therefore has the default 'null' value)
			-- is used as a wildcard and will match any value.
			--
			-- @param template - template used for matching.
	 		--   Matching is done against template with null fields being wildcards ("match anything")
			--  other fields being values
	 		-- @param txn - The Transaction object, if any, under which to perform the operation.
			-- @param timeout - How much time (in milliseconds) the client is willing to wait for a
	 		--   proper matching entry.
			-- @param modifiers - Operation that provide the isolation level.
			--
			-- @return A space entry that matches the given template, or Void if timeout expires and none is found.
		require
			was_not_exception: not was_exception
			template_not_void: template /= Void
		local
			res: POINTER
			txn_pointer: POINTER
		do
			if txn /= Void then
				txn_pointer := txn.object_ptr
			end
			res := cpp_read_entry (exception_handler, object_ptr, template.object_ptr, txn_pointer, timeout, modifiers)
			if res /= default_pointer then
				create Result.make_from_external (res)
			end
		end

	write (entry: EGS_ENTRY; txn: EGS_TRANSACTION; timeout: INTEGER_64; modifiers: INTEGER): EGS_LEASE is
			-- Writes an object to this space and returns its Lease.
			--
			-- @param entry - object to be written.
	 		-- @param txn - Transaction object, if any, under which to perform the operation.
			-- @param lease - Requested lease time, in milliseconds.
			-- @param modifiers - Operation that provide the isolation level.
			--
			-- @return The Lease for the written entry
		require
			was_not_exception: not was_exception
			entry_not_void: entry /= Void
		local
			res: POINTER
			txn_pointer: POINTER
		do
			if txn /= Void then
				txn_pointer := txn.object_ptr
			end
			res := cpp_write_entry (exception_handler, object_ptr, entry.object_ptr, txn_pointer, timeout, modifiers)
			if res /= default_pointer then
				create Result.make_from_external (res)
				cpp_delete_lease (res)
			end
		end

	take (template: EGS_ENTRY; txn: EGS_TRANSACTION; timeout: INTEGER_64): EGS_ENTRY is
			--	Take any matching entry from the space, blocking until one exists. Return
	 		-- Void if the timeout expires.
	 		--
	 		-- @param template - template used for matching.
			-- @param txn - The Transaction object, if any, under which to perform the operation.
			-- @param timeout - How much time (in milliseconds) the client is willing to wait for a
	 		--   proper matching entry.
	 		--
	 		-- @return A space entry that matches the given template, or Void if timeout expires
	 		--   and none is found.
		require
			was_not_exception: not was_exception
			template_not_void: template /= Void
		local
			res: POINTER
			txn_pointer: POINTER
		do
			if txn /= Void then
				txn_pointer := txn.object_ptr
			end
			res := cpp_take_entry (exception_handler, object_ptr, template.object_ptr, txn_pointer, timeout)
			if res /= default_pointer then
				create Result.make_from_external (res)
			end
		end

	update (entry: EGS_ENTRY; txn: EGS_TRANSACTION; lease: INTEGER_64; timeout: INTEGER_64; modifiers: INTEGER): EGS_ENTRY is
 			-- Update an object in this space.
 			-- An update can be performed, with these modifiers listed in UpdateModifiers:
 			-- UPDATE_ONLY - pure update operation,
 			-- UPDATE_OR_WRITE - writes if absent or updates existing,
 			-- PARTIAL_UPDATE - updates only non-null fields.
 			--
			-- @param entry - object to be updated.
 			-- @param txn - Transaction object, if any, under which to perform the operation.
 			-- @param lease - Requested lease time, in milliseconds.
 			-- @param timeout - How much time (in milliseconds) the client is willing to wait for a
 			--   proper matching entry.
 			-- @param modifiers - Operation modifiers.
			--
 			-- @return the previous value on success, otherwise Void
		require
			was_not_exception: not was_exception
			entry_not_void: entry /= Void
		local
			res: POINTER
			txn_pointer: POINTER
		do
			if txn /= Void then
				txn_pointer := txn.object_ptr
			end
			res := cpp_update_entry (exception_handler, object_ptr, entry.object_ptr, txn_pointer, lease, timeout, modifiers)
			if res /= default_pointer then
				create Result.make_from_external (res)
			end
		end

	write_multiple (entries: ARRAY[EGS_ENTRY]; txn: EGS_TRANSACTION; lease: INTEGER_64): ARRAY[EGS_LEASE] is
			--  Writes the specified entries to this space and return their Leases.
			--
			-- @param entries - Array of EGS_ENTRY objects to write.
			-- @param txn - The Transaction object, if any, under which to perform the operation.
			-- @param lease - Requested lease time, in milliseconds.
			--
			-- @return ARRAY of Leases for the written entries.
		require
			was_not_exception: not was_exception
			entries_valid: entries /= Void and then entries.count /= 0
		local
			txn_pointer: POINTER
			entries_vector: POINTER
			res: POINTER
		do
			if txn /= Void then
				txn_pointer := txn.object_ptr
			end
			entries_vector := create_vector_from_entries_array (entries)
			res := cpp_write_multiple (exception_handler, object_ptr, entries_vector, txn_pointer, lease)
			cpp_delete_entries_vector (entries_vector);
			if res /= default_pointer then
				Result := create_array_from_lease_vector (res)
				cpp_delete_gs_lease_vector (res)
			end
		end

	read_multiple (template: EGS_ENTRY; txn: EGS_TRANSACTION; max_entries: INTEGER; modifiers: INTEGER): ARRAY[EGS_ENTRY] is
			-- Read any matching entries from the space. Matching is done as in
	 		-- read() without timeout (timeout = 0). Returns an array of matched entries.
	 		-- The amount of entries returned is limited by max_entries. Returns an empty array if no match was found.
			--
			-- @param template - a template used for matching.
	 		--   Matching is done against template with null fields being wildcards ("match anything")
	 		--   other fields being values
	 		-- @param txn - The Transaction object, if any, under which to perform the operation.
			-- @param maxEntries - Maximum number of entries to be returned.
	 		-- @param modifiers - Operation that provide the isolation level.
	 		--
			-- @return An array of all space entries that match the given template, limited by max_entries.
	 		--   The array is empty if no matching entry is found.
		require
			was_not_exception: not was_exception
			template_not_void: template /= Void
		local
			txn_pointer: POINTER
			res: POINTER
		do
			if txn /= Void then
				txn_pointer := txn.object_ptr
			end
			res := cpp_read_multiple (exception_handler, object_ptr, template.object_ptr, txn_pointer, max_entries, modifiers)
			if res /= default_pointer then
				Result := create_array_from_entries_vector (res)
				cpp_delete_gs_entries_vector (res);
			end
		end

	take_multiple (template: EGS_ENTRY; txn: EGS_TRANSACTION; max_entries: INTEGER): ARRAY[EGS_ENTRY] is
			-- Take any matching entries from the space. Matching is done as in
			-- take() without timeout (timeout = 0). Returns an array of matched entries.
			--
			-- @param template - a template used for matching.
	 		--   Matching is done against template with null fields being wildcards ("match anything")
	 		--   other fields being values
	 		-- @param txn - The Transaction object, if any, under which to perform the operation.
			-- @param maxEntries - Maximum number of entries to be returned.
	 		--
			-- @return An array of all space entries that match the given template, limited by max_entries.
	 		--   The array is empty if no matching entry is found.
		require
			was_not_exception: not was_exception
			template_not_void: template /= Void
		local
			txn_pointer: POINTER
			res: POINTER
		do
			if txn /= Void then
				txn_pointer := txn.object_ptr
			end
			res := cpp_take_multiple (exception_handler, object_ptr, template.object_ptr, txn_pointer, max_entries)
			if res /= default_pointer then
				Result := create_array_from_entries_vector (res)
				cpp_delete_gs_entries_vector (res);
			end
		end

	clear (template: EGS_ENTRY; txn: EGS_TRANSACTION) is
			-- Removes the entries that match the specified template from this space.
	 		-- If template is Void, all entries are removed.
	 		-- @param template - EGS_ENTRY template object
	 		-- @param txn - The Transaction object, if any, under which to perform the operation.
		require
			was_not_exception: not was_exception
	 	local
			txn_pointer: POINTER
			template_pointer: POINTER
		do
			if template /= Void then
				template_pointer := template.object_ptr
			end
			if txn /= Void then
				txn_pointer := txn.object_ptr
			end
			cpp_clear (exception_handler, object_ptr, template_pointer, txn_pointer)
		end

	create_local_transaction (lease_time: INTEGER_64): EGS_TRANSACTION is
	 		-- Create a Local Transaction.
			--
			-- @param lease_time - The time period in milliseconds until the transaction is discarded.
			--
	 		-- return New local transaction
		require
			was_not_exception: not was_exception
	 	local
	 		res: POINTER
		do
			res := cpp_create_local_transaction (exception_handler, object_ptr, lease_time)
			if res /= default_pointer then
				create Result.make_from_external (res)
			end
		end

	get_local_transaction_manager: EGS_TRANSACTION_MANAGER is
			-- Return a Local Transaction Manager through which a Local Transaction can be obtained.
			--
	 		-- @return Local Transaction Manager
		require
			was_not_exception: not was_exception
	 	local
	 		res: POINTER
		do
			res := cpp_get_local_transaction_manager (exception_handler, object_ptr)
			if res /= default_pointer then
				create Result.make_from_external (res)
			end
		end

	get_distributed_transaction_manager (config: EGS_CONFIG): EGS_TRANSACTION_MANAGER is
			-- Return a Distributed Transaction Manager through which a distributed Transaction
			-- can be obtained.
			--
			-- @param config - A EGS_CONFIG object that holds the properties relevant for
			--   the specific type of the Distributed Transaction Manager.
	 		--
			-- @return Distributed Transaction Manager
		require
			was_not_exception: not was_exception
			config_not_void: config /= Void
		local
			res: POINTER
		do
			res := cpp_get_distributed_transaction_manager (exception_handler, object_ptr, config.object_ptr)
			if res /= default_pointer then
				create Result.make_from_external (res)
			end
		end

	clean is
		require
			was_not_exception: not was_exception
		do
			cpp_clean (exception_handler, object_ptr)
		end

	thread_detach is
			-- Free the memory allocated in the SpaceProxy for the current thread.
			-- Call this before the thread exits.
		do
			cpp_thread_detach (exception_handler, object_ptr)
		end

feature {NONE} -- Implementation

	create_array_from_entries_vector (vector: POINTER): ARRAY[EGS_ENTRY] is
			--
		require
			vector_not_null: vector /= default_pointer
		local
			entry_pointer: POINTER
			entry: EGS_ENTRY
			i, count: INTEGER
		do
			if vector /= default_pointer then
				count := cpp_get_gs_entry_vector_count (vector)
				create Result.make (1, count)
				from
					i := 0
				until
					i >= count
				loop
					entry_pointer := cpp_get_gs_entry_vector_item (vector, i)
					create entry.make_from_external (entry_pointer)
					Result.put (entry, i+1)
					i := i + 1
				end
			end
		end

	create_array_from_lease_vector (vector: POINTER): ARRAY[EGS_LEASE] is
			--
		require
			vector_not_null: vector /= default_pointer
		local
			lease_pointer: POINTER
			lease: EGS_LEASE
			i, count: INTEGER
		do
			if vector /= default_pointer then
				count := cpp_get_gs_lease_vector_count (vector)
				create Result.make (1, count)
				from
					i := 0
				until
					i >= count
				loop
					lease_pointer := cpp_get_gs_lease_vector_item (vector, i)
					create lease.make_from_external (lease_pointer)
					Result.put (lease, i+1)
					i := i + 1
				end
			end
		end

	create_vector_from_entries_array (array: ARRAY[EGS_ENTRY]): POINTER is
		require
			array_not_void: array /= Void
		local
			i: INTEGER
		do
			Result := cpp_create_entries_vector
			from
				i := array.lower
			until
				i > array.upper
			loop
				cpp_add_to_entries_vector (Result, array.item (i).object_ptr)
				i := i + 1
			end
		end

feature {NONE} -- Utility externals

	cpp_create_entries_vector: POINTER is
		external
			"C++ inline use <gigaspaces.h>"
		alias
			"new std::vector<OpenSpaces::IEntry*>"
		end

	cpp_add_to_entries_vector (obj_ptr: POINTER; entry: POINTER) is
		require
			obj_ptr_not_null: obj_ptr /= default_pointer
			entry_not_null: entry /= default_pointer
		external
			"C++ inline use <gigaspaces.h>"
		alias
			"((std::vector<OpenSpaces::IEntry*>*)$obj_ptr)->push_back((OpenSpaces::IEntry*)$entry)"
		end

	cpp_delete_entries_vector (obj_ptr: POINTER) is
		require
			obj_ptr_not_null: obj_ptr /= default_pointer
		external
			"C++ inline use <gigaspaces.h>"
		alias
			"delete ((std::vector<OpenSpaces::IEntry*>*)$obj_ptr)"
		end

	cpp_get_gs_lease_vector_count (vector: POINTER): INTEGER is
		require
			vector_not_null: vector /= default_pointer
		external
			"C++ inline use <egigs.h>"
		alias
			"((EGS_LeaseVector*)$vector)->getSize()"
		end

	cpp_get_gs_entry_vector_count (vector: POINTER): INTEGER is
		require
			vector_not_null: vector /= default_pointer
		external
			"C++ inline use <egigs.h>"
		alias
			"((EGS_EntryVector*)$vector)->getSize()"
		end

	cpp_get_gs_lease_vector_item (vector: POINTER; i: INTEGER): POINTER
		require
			vector_not_null: vector /= default_pointer
		external
			"C++ inline use <egigs.h>"
		alias
			"((EGS_LeaseVector*)$vector)->item($i)"
		end

	cpp_get_gs_entry_vector_item (vector: POINTER; i: INTEGER): POINTER
		require
			vector_not_null: vector /= default_pointer
		external
			"C++ inline use <egigs.h>"
		alias
			"((EGS_EntryVector*)$vector)->item($i)"
		end

	cpp_delete_lease (obj_ptr: POINTER) is
		require
			obj_ptr_not_null: obj_ptr /= default_pointer
		external
			"C++ inline use <gigaspaces.h>"
		alias
			"delete ((OpenSpaces::Lease*)$obj_ptr)"
		end


feature {NONE} -- Current object specific externals

	cpp_delete (obj_ptr: POINTER) is
		external
			"C++ inline use <EGS_ExceptionHandler.h>"
		alias
			"[
				delete ((OpenSpaces::SpaceProxyPtr*)$obj_ptr);
			]"
		end

	cpp_delete_gs_entries_vector (obj_ptr: POINTER) is
		external
			"C++ inline use <egigs.h>"
		alias
			"[
				egs_delete_entries_vector((EGS_EntryVector*)$obj_ptr);
			]"
		end

	cpp_delete_gs_lease_vector (obj_ptr: POINTER) is
		external
			"C++ inline use <egigs.h>"
		alias
			"[
				egs_delete_leases_vector((EGS_LeaseVector*)$obj_ptr);
			]"
		end

	cpp_read_entry (eh: EGS_EXCEPTION_HANDLER; obj_ptr: POINTER; entry_template: POINTER; txn: POINTER; timeout: INTEGER_64; modifiers: INTEGER): POINTER is
		require
			eh_not_void: eh /= Void
			obj_ptr_not_null: obj_ptr /= default_pointer
			template_not_null: entry_template /= default_pointer
		external
			"C++ inline use <EGS_ExceptionHandler.h>"
		alias
			"[
				try {
				  return (*((OpenSpaces::SpaceProxyPtr*)$obj_ptr))->read(((OpenSpaces::IEntry*)$entry_template), ($txn != 0?(*((OpenSpaces::TransactionPtr*)$txn)):OpenSpaces::NULL_TX), $timeout, OpenSpaces::ReadModifiers($modifiers));
				} catch(OpenSpaces::XAPException& e) {
				  EGS_HANDLE_XAP_EXCEPTION($eh, e);
				  return 0;
				}
			 ]"
		end

	cpp_write_entry (eh: EGS_EXCEPTION_HANDLER; obj_ptr: POINTER; entry: POINTER; txn: POINTER; timeout: INTEGER_64; modifiers: INTEGER): POINTER is
		require
			eh_not_void: eh /= Void
			obj_ptr_not_null: obj_ptr /= default_pointer
			entry_not_null: entry /= default_pointer
		external
			"C++ inline use <EGS_ExceptionHandler.h>"
		alias
			"[
				try {
				  return new OpenSpaces::Lease((*((OpenSpaces::SpaceProxyPtr*)$obj_ptr))->write(((OpenSpaces::IEntry*)$entry), ($txn != 0?(*((OpenSpaces::TransactionPtr*)$txn)):OpenSpaces::NULL_TX), $timeout, OpenSpaces::UpdateModifiers($modifiers)));
				} catch(OpenSpaces::XAPException& e) {
				  EGS_HANDLE_XAP_EXCEPTION($eh, e);
				  return 0;
				}
			 ]"
		end

	cpp_snapshot (eh: EGS_EXCEPTION_HANDLER; obj_ptr: POINTER; entry: POINTER) is
		require
			eh_not_void: eh /= Void
			obj_ptr_not_null: obj_ptr /= default_pointer
			entry_not_null: entry /= default_pointer
		external
			"C++ inline use <EGS_ExceptionHandler.h>"
		alias
			"[
				try {
				  (*((OpenSpaces::SpaceProxyPtr*)$obj_ptr))->snapshot(((OpenSpaces::IEntry*)$entry));
				} catch(OpenSpaces::XAPException& e) {
				  EGS_HANDLE_XAP_EXCEPTION($eh, e);
				}
			 ]"
		end

	cpp_take_entry (eh: EGS_EXCEPTION_HANDLER; obj_ptr: POINTER; entry_template: POINTER; txn: POINTER; timeout: INTEGER_64): POINTER is
		require
			eh_not_void: eh /= Void
			obj_ptr_not_null: obj_ptr /= default_pointer
			entry_template_not_null: entry_template /= default_pointer
		external
			"C++ inline use <EGS_ExceptionHandler.h>"
		alias
			"[
				try {
				  return (*((OpenSpaces::SpaceProxyPtr*)$obj_ptr))->take(((OpenSpaces::IEntry*)$entry_template), ($txn != 0?(*((OpenSpaces::TransactionPtr*)$txn)):OpenSpaces::NULL_TX), $timeout);
				} catch(OpenSpaces::XAPException& e) {
				  EGS_HANDLE_XAP_EXCEPTION($eh, e);
				  return 0;
				}
			 ]"

		end

	cpp_update_entry (eh: EGS_EXCEPTION_HANDLER; obj_ptr: POINTER; entry: POINTER; txn: POINTER; lease: INTEGER_64; timeout: INTEGER_64; modifiers: INTEGER): POINTER is
		require
			eh_not_void: eh /= Void
			obj_ptr_not_null: obj_ptr /= default_pointer
			entry_not_null: entry /= default_pointer
		external
			"C++ inline use <EGS_ExceptionHandler.h>"
		alias
			"[
				try {
				  return (*((OpenSpaces::SpaceProxyPtr*)$obj_ptr))->update(((OpenSpaces::IEntry*)$entry),($txn != 0?(*((OpenSpaces::TransactionPtr*)$txn)):OpenSpaces::NULL_TX), $lease, $timeout, OpenSpaces::UpdateModifiers($modifiers));
				} catch(OpenSpaces::XAPException& e) {
				  EGS_HANDLE_XAP_EXCEPTION($eh, e);
				  return 0;
				}
			 ]"
		end

	cpp_write_multiple (eh: EGS_EXCEPTION_HANDLER; obj_ptr: POINTER; array: POINTER; txn: POINTER; lease: INTEGER_64): POINTER is
		require
			eh_not_void: eh /= Void
			obj_ptr_not_null: obj_ptr /= default_pointer
			array_not_null: array /= default_pointer
		external
			"C++ inline use <EGS_ExceptionHandler.h>, <egigs.h>"
		alias
			"[
				try {
				  return egs_space_proxy_write_multiple(
				    (OpenSpaces::SpaceProxyPtr *)$obj_ptr,
				    *((std::vector<OpenSpaces::IEntry*>*)$array),
				    ($txn != 0?(*((OpenSpaces::TransactionPtr*)$txn)):OpenSpaces::NULL_TX), $lease);
				} catch(OpenSpaces::XAPException& e) {
				  EGS_HANDLE_XAP_EXCEPTION($eh, e);
				  return 0;
				}
			 ]"
		end

	cpp_read_multiple (eh: EGS_EXCEPTION_HANDLER; obj_ptr: POINTER; entry: POINTER; txn: POINTER; max_entries: INTEGER; modifiers: INTEGER): POINTER is
		require
			eh_not_void: eh /= Void
			obj_ptr_not_null: obj_ptr /= default_pointer
			entry_not_null: entry /= default_pointer
		external
			"C++ inline use <EGS_ExceptionHandler.h>"
		alias
			"[
				try {
				  return egs_space_proxy_read_multiple(
				    (OpenSpaces::SpaceProxyPtr *)$obj_ptr,
				    (OpenSpaces::IEntry*)$entry, 
				    ($txn != 0?(*((OpenSpaces::TransactionPtr*)$txn)):OpenSpaces::NULL_TX),
				    $max_entries,
				    OpenSpaces::ReadModifiers($modifiers));
				} catch(OpenSpaces::XAPException& e) {
				  EGS_HANDLE_XAP_EXCEPTION($eh, e);
				  return 0;
				}
			 ]"

		end

	cpp_take_multiple (eh: EGS_EXCEPTION_HANDLER; obj_ptr: POINTER; entry: POINTER; txn: POINTER; max_entries: INTEGER): POINTER is
		require
			eh_not_void: eh /= Void
			obj_ptr_not_null: obj_ptr /= default_pointer
			entry_not_null: entry /= default_pointer
		external
			"C++ inline use <EGS_ExceptionHandler.h>"
		alias
			"[
				try {
				  return egs_space_proxy_take_multiple(
				    (OpenSpaces::SpaceProxyPtr *)$obj_ptr,
				    (OpenSpaces::IEntry*)$entry, 
				    ($txn != 0?(*((OpenSpaces::TransactionPtr*)$txn)):OpenSpaces::NULL_TX),
				    $max_entries);
				} catch(OpenSpaces::XAPException& e) {
				  EGS_HANDLE_XAP_EXCEPTION($eh, e);
				  return 0;
				}
			 ]"

		end

	cpp_clear (eh: EGS_EXCEPTION_HANDLER; obj_ptr: POINTER; entry_template: POINTER; txn: POINTER) is
		require
			eh_not_void: eh /= Void
			obj_ptr_not_null: obj_ptr /= default_pointer

		external
			"C++ inline use <EGS_ExceptionHandler.h>"
		alias
			"[
				try {
				  (*((OpenSpaces::SpaceProxyPtr*)$obj_ptr))->clear(((OpenSpaces::IEntry*)$entry_template), ($txn != 0?(*((OpenSpaces::TransactionPtr*)$txn)):OpenSpaces::NULL_TX));
				} catch(OpenSpaces::XAPException& e) {
				  EGS_HANDLE_XAP_EXCEPTION($eh, e);
				}
			 ]"

		end

	cpp_create_local_transaction (eh: EGS_EXCEPTION_HANDLER; obj_ptr: POINTER; lease_time: INTEGER_64): POINTER is
		require
			eh_not_void: eh /= Void
			obj_ptr_not_null: obj_ptr /= default_pointer
		external
			"C++ inline use <EGS_ExceptionHandler.h>"
		alias
			"[
				try {
				  return new OpenSpaces::TransactionPtr((*((OpenSpaces::SpaceProxyPtr*)$obj_ptr))->getLocalTransaction($lease_time));
				} catch(OpenSpaces::XAPException& e) {
				  EGS_HANDLE_XAP_EXCEPTION($eh, e);
				  return 0;
				}
			 ]"
		end

	cpp_get_local_transaction_manager (eh: EGS_EXCEPTION_HANDLER; obj_ptr: POINTER): POINTER is
		require
			eh_not_void: eh /= Void
			obj_ptr_not_null: obj_ptr /= default_pointer
		external
			"C++ inline use <EGS_ExceptionHandler.h>"
		alias
			"[
				try {
				  return new OpenSpaces::ITransactionManagerPtr((*((OpenSpaces::SpaceProxyPtr*)$obj_ptr))->getLocalTransactionManager());
				} catch(OpenSpaces::XAPException& e) {
				  EGS_HANDLE_XAP_EXCEPTION($eh, e);
				  return 0;
				}
			 ]"
		end

	cpp_get_distributed_transaction_manager (eh: EGS_EXCEPTION_HANDLER; obj_ptr: POINTER; config: POINTER): POINTER is
		require
			eh_not_void: eh /= Void
			obj_ptr_not_null: obj_ptr /= default_pointer
			config_not_null: config /= default_pointer
		external
			"C++ inline use <EGS_ExceptionHandler.h>"
		alias
			"[
				try {
				  return new OpenSpaces::ITransactionManagerPtr((*((OpenSpaces::SpaceProxyPtr*)$obj_ptr))->getDistributedTransactionManager((*((OpenSpaces::IConfigPtr*)$config))));
				} catch(OpenSpaces::XAPException& e) {
				  EGS_HANDLE_XAP_EXCEPTION($eh, e);
				  return 0;
				}
			 ]"

		end

	cpp_thread_detach (eh: EGS_EXCEPTION_HANDLER; obj_ptr: POINTER) is
		require
			eh_not_void: eh /= Void
			obj_ptr_not_null: obj_ptr /= default_pointer
		external
			"C++ inline use <EGS_ExceptionHandler.h>"
		alias
			"[
				try {
				  (*((OpenSpaces::SpaceProxyPtr*)$obj_ptr))->ThreadDetach();
				} catch(OpenSpaces::XAPException& e) {
				  EGS_HANDLE_XAP_EXCEPTION($eh, e);
				}
			 ]"

		end

	cpp_clean (eh: EGS_EXCEPTION_HANDLER; obj_ptr: POINTER) is
		require
			eh_not_void: eh /= Void
			obj_ptr_not_null: obj_ptr /= default_pointer
		external
			"C++ inline use <EGS_ExceptionHandler.h>"
		alias
			"[
				try {
				  (*((OpenSpaces::SpaceProxyPtr*)$obj_ptr))->clean();
				} catch(OpenSpaces::XAPException& e) {
				  EGS_HANDLE_XAP_EXCEPTION($eh, e);
				}
			 ]"

		end

indexing

	library:	"egigs-cpp: Library for accessing the GigaSpaces platform, POCO library based implementation."
	copyright:	"Copyright (c) 2008, Eiffel Software and others"
	license:	"Eiffel Forum License v2 (see http://www.eiffel.com/licensing/forum.txt)"
	source: "[
			 Eiffel Software
			 356 Storke Road, Goleta, CA 93117 USA
			 Telephone 805-685-1006, Fax 805-685-6869
			 Website http://www.eiffel.com
			 Customer support http://support.eiffel.com
		]"

end