
	Where results make sense

Topic: Servant (CORBA)

Related Topics

CORBA name service

indentured servants

Public Servants Insurance Act

John Brown servant

public servant

George Smith Royal servant

Servants of the Light

The Naked Civil Servant

Servant leadership

Servants of Glaaki

William Herschel civil servant

The Three Arrows The Servants and the Snow

In the News (Sun 29 Nov 09)

Northern Trust

Marvin Harrison

Peter Chernin

Gary Locke

Match Play

Penelope Cruz

Mickey Rourke

AR Rahman

Danny Boyle

Hugh Jackman

	Servant - Wikipedia, the free encyclopedia
		A servant is another word for domestic worker, a person who is hired to provide regular household or other duties, and receives compensation.
		Servant was a Christian rock band of the 1970s and 1980s, known for their preachy style, calling the church to change and repent.
		In CORBA, a servant is a concrete object that incarnates a particular interface.
	en.wikipedia.org /wiki/Servant (191 words)

	CORBA - Wikipedia, the free encyclopedia
		CORBA therefore provides platform and location transparency for sharing well-defined objects across a distributed computing platform.
		In this sense, CORBA can be considered as a machine-readable documentation format, similar to a header file but with considerably more information.
		CORBA uses an interface definition language (IDL) to specify the interfaces that objects will present to the world.
	en.wikipedia.org /wiki/CORBA (624 words)

	Collocation
		As described in section 3.3, auto-generated stub classes package their parameters in a CORBA request, which is then transported by the ORB and decoded by the skeleton on the server side.
		The client cannot distinguish the servant from a stub: the interface matches, and the method signatures are the same.
		This is not possible for servant managers and adapter activators, which the specification requires to follow the ``usual'' semantics, so that users can derive their object implementation from the skeletons.
	www.fpx.de /fp/Uni/Diplom/node24.html (1560 words)

	(ootips) CORBA Basics
		In non-OO languages like C and COBOL, a servant is implemented as a collection of functions that manipulate data (e.g., an instance of a struct or record) that represent the state of a CORBA object.
		Since servants ultimately perform client requests, activation requires that the CORBA object be associated with a suitable servant.
		From the server perspective, the servants for factory objects are implemented such that they invoke operations on the OA in order to associate servants with the CORBA objects they create, as well as to create object references for those new objects.
	ootips.org /corba-basics.html (971 words)

	Managing Servants
		The active object map retains the mapping between the object and its servant until the object is deactivated.
		Because a servant activator depends on the active object map to maintain the servants that it supplies, its usefulness is generally limited to minimizing an application's startup time.
		Servant activators are generally useful when a server can hold all its servants in memory at once, but the servants are slow to initialize, or they are not all needed each time the server runs.
	www.mnlab.cs.depaul.edu /TDC568/corba/pguide_cpp/html/ManageServants.html (2544 words)

	Overview of CORBA
		CORBA automates many common network programming tasks such as object registration, location, and activation; request demultiplexing; framing and error-handling; parameter marshalling and demarshalling; and operation dispatching.
		Object -- This is a CORBA programming entity that consists of an identity, an interface, and an implementation, which is known as a Servant.
		CORBA IDL stubs and skeletons -- CORBA IDL stubs and skeletons serve as the ``glue'' between the client and server applications, respectively, and the ORB.
	www.cs.wustl.edu /~schmidt/corba-overview.html (976 words)

	Joint Client/Servers
		Thus, the servant already exists and the object is activated before a request for the object arrives.
		If used with a BEA Tuxedo CORBA Notification Service application, for example, these are callbacks that correspond to the concept of a persistent subscription; that is, the Notification Service remembers the callback reference and delivers events any time the client is up and declares that it is again ready to receive events.
		Create a servant (that is, an instance of the C++ implementation class for the interface).
	e-docs.bea.com /tuxedo/tux80/cref/wrapper.htm (4240 words)

	Programming:CORBA - Wikibooks
		A CORBA object is defined using the CORBA IDL progamming language.
		Another nice feature of the CORBA concept is that you don't need to use the object with the same programming language as the one the object is implemented in.
		A CORBA interface is the public part of the class - the part of the class you can interface with.
	en.wikibooks.org /wiki/Programming:CORBA (2178 words)

	ORB Basics
		In CORBA, the Object Request Broker or ORB takes care of all of the details involved in routing a request from client to object, and routing the response to its destination.
		Although CORBA allows (in fact, requires) the client to assume that every valid object reference corresponds to a running instance, it is likely that the code of the instance is not running.
		The association between a servant and an object is a run-time concept, and may be set as frequently as as per-invocation.
	www.omg.org /gettingstarted/orb_basics.htm (2883 words)

	: Class Tobj_Servant
		Whenever a request comes in for an inactive CORBA object, the object is activated and the activate_object method is invoked on the servant.
		This causes the Portable Object Adapter (POA) to assign a servant to the CORBA object.
		Invocations on other CORBA objects are not allowed because an invocation to a CORBA object that is in another process would require that the process join the transaction; since the transaction manager is already executing the prepare phase, an error would occur.
	e-docs.bea.com /wle/wle42/javadoc/com/beasys/Tobj_Servant.html (1467 words)

	An Eiffel Language Mapping for CORBA IDL: Eiffel Mapping
		Note: the CORBA specification apparently requires a maximum size to be passed for an unbounded sequence: [3.8.3 Template Types (Corba2.0)].
		CORBA describes two sorts of objects for an interface: the object implementation, and object references through which an implementation is accessed.
		CORBA exceptions are normally raised intentionally, so it would seem appropriate to allow an object implementation to continue to serve requests after returning an exception which is declared in the IDL.
	www.melvaig.co.uk /icl/IDLtoEiffel-3.html (5604 words)

	Distributed Objects - OMG/OMA/CORBA
		A servant is executed within a thread of a POA or as a process forked by the POA.
		Corba supports a registry with ongoing persistence, while RMI's registry is restarted everytime the server is restarted.
		Corba's registry is distinguished in a Interface Repository, where are kept the IDL definitions for all the objects, and a Implementation Repository, where are kept the executables for all the objects.
	www.cis.temple.edu /~ingargio/old/cis307f98/readings/corba.html (3134 words)

	PortableServer::POA Interface (Site not responding. Last check: 2007-10-14)
		The servant locator incarnates a servant for an inactive object each time the object is requested; the servant locator must etherealize the object and delete the servant from memory after the request returns.
		In a multi-threaded environment, all calls by a single-threaded POA to implementation code (servants and servant managers) are made in a manner that is safe for code that does not account for multi-threading.
		Returns the servant that is associated with object ID oid in the active object map.
	www.iona.it /support/docs/orbix/mainframe/6.0/pref/cpp/POA.html (3372 words)

	Servant (Java 2 Platform SE v1.4.2)
		It serves as the base class for all POA servant implementations and provides a number of methods that may be invoked by the application programmer, as well as methods which are invoked by the POA itself and may be overridden by the user to control aspects of servant behavior.
		Returns the root POA from the ORB instance associated with the servant.
		Allows the servant to obtain the object reference for the target CORBA object it is incarnating for that request.
	java.sun.com /j2se/1.4.2/docs/api/org/omg/PortableServer/Servant.html (447 words)

	Object Computing, Inc. - CORBA News Brief - July 2002
		Because servant managers (locators and activators) are now defined as local interfaces, the implementation and use of these objects are dependent on the local object language mapping.
		TAO is implemented using the normal local object mapping for servant managers and the rest of this section assumes this mapping.
		Almost all CORBA developers will use local objects and many are going to need to define their own local interfaces and implement them.
	www.ociweb.com /cnb/CORBANewsBrief-200207.html (2066 words)

	Common Object Request Broker Architecture by Gopalan Suresh Raj (Site not responding. Last check: 2007-10-14)
		CORBA defines a model that specifies interoperability between distributed objects on a network in a way that is transparent to the programmer.
		CORBA automatically handles a lot of network programming tasks such as object registration, object location, object activation, request demultiplexing, frame and error-handling, marshalling and operation dispatching.
		CORBA objects are accessed through the use of an interface.
	my.execpc.com /~gopalan/corba/corba.html (457 words)

	Object Computing, Inc. - CORBA News Brief - June 2002
		This month's CORBA News Brief from OCI provides a high-level overview of the OMG Notification Service and illustrates using the TAO 1.2a Notification Service interoperating with a JacORB v1.4 consumer.
		In depth information on CORBA programming with TAO can be found from the the recently released TAO 1.2a Developer's Guide.
		OMG, CORBA, IIOP, IDL, ORB, and all OMG marks and logos are trademarks or registered trademarks, service marks and/or certification marks of the Object Management Group, Inc. registered in the United States.
	www.ociweb.com /cnb/CORBANewsBrief-200206.html (2159 words)

	CORBA Java Code Clinic - Infowave (Thailand) - Portable Object Adapter (POA) with CORBA 2.3 IDL/Java Language Mapping (Site not responding. Last check: 2007-10-14)
		The Portable Object Adapter Specification was introduced in CORBA 2.2 (released in Feb 1998).
		Association of a servant body with a virtual CORBA object so that it may service requests.
		Destruction of the association between the CORBA object and its servant.
	www.waveman.com /etac/corba/page12.html (195 words)

	Activating CORBA Objects (Site not responding. Last check: 2007-10-14)
		The ORB runtime remains unaware of the existence of the servant and the corresponding CORBA object.
		Because the servant is already registered in the POA with an object ID, the method simply returns an object reference.
		The object reference returned by _this() is independent of the servant itself; you must eventually call release() on the object or hold it in a _var reference in order to avoid resource leaks.
	iona.com /support/docs/e2a/asp/5.1/corba/pguide_cpp/ServerBasics6.html (351 words)

	Loaders
		Servant activator: Triggered only when the target CORBA object cannot be found in memory.
		A servant locator can also be used to replace the Orbix 3 loader.
		In general, the servant locator is more flexible than the servant activator and offers greater scope for implementing sophisticated loader algorithms.
	www.iona.ie /support/docs/orbix/migration/html/O2kO3Prop9.html (195 words)

	VisiBroker VisiNotify Guide: Using the Publish Subscribe Adapter (PSA) (Site not responding. Last check: 2007-10-14)
		Note: CORBA is not the only distributed object middleware that does not provide support for non-classic communication models at the same object abstraction level.
		Passive suppliers need to be published with a valid object id and the publish servant should be activated or able to be activated (for example, by the servant manager) in the publishing PSA (such as, POA).
		The pull_typed_event() operation of this servant using reflective callback to generate typed event using the original IDL interface stub.
	info.borland.com /techpubs/bes/v6/html_books/vb_notify/psa.html (8165 words)

	[OB-Users] How to dynamically load Corba object(servant) (Site not responding. Last check: 2007-10-14)
		Following are some Corba features came to my mind but each one has its own drawbacks: (note: There is an Inventory application that does the initialization, starting up of orb,....)..
		The main drawback with this approach is, n of process are started for n number of Corba objects, which is not acceptable.
		I guess the implementation of Corba objects has to be available to incarnate() function of ServantActivator to create a servant(new Device1(str)) during compilation which is not possible, since some of the objects will be created during runtime.
	www.ooc.com /pipermail/ob-users/2000-March/009869.html (281 words)

	VisiBroker for C++ Developer's Guide: Using POAs (Site not responding. Last check: 2007-10-14)
		When an abstract object is assigned to a servant, it is called an active object and the servant is said to incarnate the active object.
		When CORBA objects are associated with an active servant, if the POA's Servant Retention Policy is RETAIN, the associated object ID is recorded in the Active Object Map and the object is activated.
		The servant ID is entered into the active object map, and the response is returned to the client.
	info.borland.com /techpubs/bes/v6/html_books/vbcpp_dg/poa.html (5364 words)

	J2SE 1.4 breathes new life into the CORBA community, Part 2
		In the CORBA world, an object is a programming entity with an identity, an IDL (interface definition language)-defined interface, and an implementation.
		The fact that a client has an object reference does not mean that a servant is incarnating the object at that time.
		A persistent object is a CORBA object that can live beyond the process that creates or activates it.
	www.javaworld.com /javaworld/jw-09-2002/jw-0927-corba.html (1619 words)

	CORBA: Servant Invocation with the POA (Site not responding. Last check: 2007-10-14)
		To achieve this we need to separate the lifecycle of a CORBA Object, which has a unique id and possibly persistent state, from the lifecycle of the servant, which is the code that implements an interface.
		To achieve persistence, a CORBA Object could be incarnated by more than one servant in its lifetime.
		But the Account Servant Activator is not accessed since active servants matching these references are found in the Account POA Active Object Map.
	www.cs.ucl.ac.uk /staff/ucacwxe/lectures/Z23-04-05/poa/poaLabSession.htm (914 words)

	guile-gnome: docs: CORBA
		Somewhere between then and 0.5.0, CORBA got broken (I suspect changes in ORBit2 to be at fault).
		CORBA servants can be implemented either in C or in scheme - but you cannot mix them - to make it clear, an example:
		vector in a CORBA servant - and to be able to poke around in the vepv to override methods.
	www.gnu.org /software/guile-gnome/docs/tutorial/corba (902 words)

	CORBA object as JAX-RPC Web Service (Site not responding. Last check: 2007-10-14)
		The interface to the CORBA object is written in IDL (Interface Definition Language) which helps to abstract the services provided by the object from the actual object implementation.
		The implementation of the object (also called as Servant) can be in any programming language like Java, C++,Smalltalk etc. The client can also be written in variety of languages as long as it adheres to the IDL interface and there is mapping provided by CORBA IDL between the client and the target object programming languages.
		The CORBA servant (CORBA back-end Object) is developed using JDK1.4 from the IDL file.
	www.oracle.com /technology/sample_code/tech/java/codesnippet/webservices/corba/index.html (1004 words)

	[OB-Users] How to dynamically load Corba object(servant) (Site not responding. Last check: 2007-10-14)
		The > main drawback with this approach is, n of process are started for n number > of Corba objects, which is not acceptable.
		I guess > the implementation of Corba objects has to be available to incarnate() > function of ServantActivator to create a servant(new Device1(str)) during > compilation which is not possible, since some of the objects will be > created during runtime.
		I think that a combination of servant activators and shared libraries is the best approach for this.
	www.ooc.com /pipermail/ob-users/2000-March/009870.html (381 words)

	CORBA and the Object Model
		CORBA is the Common Object Request Broker Architecture, is the middleware that establishes the client-server relationships between objects.
		At that time (beginning of September '98) CORBA is not widely deployed inside Gnome, but the newly introduced package "ORBit" is very promising and Gnome developers claims to use it very wide.
		CORBA is designed to transfer objects through the network.
	www.ecsl.cs.sunysb.edu /~andrew/LinuxDocModel/index/c87.html (1050 words)

	[omniORB] about make a servant both CORBA client and CORBA server (Site not responding. Last check: 2007-10-14)
		Hi all, I have a problem on how to make a servant as both a CORBA client and CORBA server.
		I published one servant a as CORBA object A, within the publish program I init one ORB orb1 and make it orb1->run(); in one function of the servant a, I need to call another CORBA object.
		In this functin I init another ORB orb2, by using orb2->string_to_object(ref) I access another CORBA object, but I can not shutdown the orb2 or destroy it after finishing the remote call in the function.
	www.omniorb-support.com /pipermail/omniorb-list/2002-July/021128.html (237 words)

	A sample container
		function which is passed as parameter the container servant.
		The ClientSite stores a pointer to its embeddable and to its container servant in its embeddable and container_servant fields.
		void activate_view (impl_POA_GNOME_ViewFrame * servant) { CORBA_Environment ev; CORBA_exception_init (and ev); GNOME_View_activate (servant->view, 1, and ev); servant->client_site_servant->active = servant; servant->client_site_servant->container_servant->active = servant->client_site_servant; CORBA_exception_free (and ev); }
	developer.gnome.org /doc/guides/corba/html/x1192.html (1162 words)

Try your search on: Qwika (all wikis)