Package jade.core

This package contains the microkernel of JADE system.

See:
Description

Interface Summary

AgentContainer	This interface represents the local container as it is seen by JADE kernel level services installed in the underlying Node
AgentManager	This interface provides Agent Life Cycle management services to the platform AMS.
AgentManager.Listener	This callback interface is implemented by the AMS in order to be notified of significant platform-level events (e.g. container added or removed, agents birth or death, mtp configuration changes, etc.).
BackEnd
BECodec
BEConnectionManager
Command	The Command interface has to be implemented by all JADE kernel-level commands, used by the various platform services.
FEConnectionManager
FEListener	Interface to be implemented by classes that need to be notified about FrontEnd relevant events such as BORN_AGENT and DEAD_AGENT.
FrontEnd
HorizontalCommand	The HorizontalCommand interface represents those kernel-level commands that are exchanged among the slices of a given JADE service, and they are sent across the network by the platform IMTP.
IMTPManager
Location	Abstract interface to represent JADE network locations.
MainContainer
MessageQueue	The interface to be implemented by agent message queue implementations
Node	This interface represents a node of a JADE platform (i.e. a component that can host a slice of a platform-level service).
NodeEventListener	This interface is used to notify the JADE kernel of important events related to the platform nodes.
PlatformManager
ResourceManager	This is the interface that must be implemented by a class managing Thread resources on a Container
Service	The Service interface represents a centralized view of a JADE kernel-level service.
Service.Slice	The Slice nested interface represents that part of a service that is deployed at a given network node.
ServiceFinder	The ServiceFinder interface serves as an access point for kernel-level service discovery.
ServiceHelper	This interface is implemented by all the service helper classes, i.e.
ServiceManager	The ServiceManager interface serves as an access point for kernel-level service management.
Sink	The Sink interface has to be implemented by all the components that process JADE kernel-level commands in an exclusive and terminal way.
TimerListener	This interface is used by the JADE internal timing system to execute an action scheduled after a given amount of time.
VerticalCommand	The VerticalCommand interface represents those kernel-level commands that are sent to or through JADE kernel-level services.

Class Summary

Agent	The Agent class is the common superclass for user defined software agents.
AgentDescriptor	Hold all information about an agent
AgentState	This class represents the Life-Cycle state of an agent.
AID	This class represents a JADE Agent Identifier.
BackEndContainer
BackEndManager	This class is an auxiliary JADE Node that act as parent node for all back-ends in the local JVM
BaseNode	This class provides a partial implementation of the Node interface.
BaseService	The BaseService abstract class partially implements the Service interface, providing a simple and uniform mechanism for slice management and service discovery.
BehaviourID	This class represents an unique identifier referring to a specific agent behaviour.
CallbackInvokator	This class is used internally by the framework and is not accessible to users.
CaseInsensitiveString	A name string, with case insensitive comparison and equality operations.
Channel	This class represents a communication channel, over which ACL messages can travel.
ContainerID	A class identifying an aget container in the JADE platform.
FEService	JADE kernel services providing a service-helper and wishing this helper to be available in the split execution mode too, need to provide a FEService class.
Filter	Base class for command filters, that allow to set up an open-ended chain of platform services to process commands coming from the upper JADE layers.
GenericCommand	A generic implementation of the Command interface, operating at the meta-level to provide a generic transformation of method invocations.
LifeCycle	Common bas class for all agent life cycle states.
MainContainerImpl	This class is a concrete implementation of the JADE main container, providing runtime support to JADE agents, and the special, front end container where the AMS and the Default DF can run.
MicroRuntime	This class is used to start up the JADE runtime as a split (front-end) container.
NodeDescriptor	The NodeDescriptor class serves as a meta-level description of a kernel-level service.
NodeFailureMonitor	The abstract class NodeFailureMonitor provides a basic implementation for classes that are used to monitor the availability of nodes and detect node failures.
PlatformID	Description here
PlatformManagerImpl	The ServiceManagerImpl class is the actual implementation of JADE platform Service Manager and Service Finder components.
Profile	This class allows retrieving configuration-dependent classes.
ProfileImpl	This class allows the JADE core to retrieve configuration-dependent classes and boot parameters.
Runtime	The singleton instance (accessible through the instance() static method) of this class allows controlling the JADE runtime system from an external application.
ScalabilityTest
ScalabilityTest.BitrateReceiverAgent	Inner class BitrateReceiverAgent
ScalabilityTest.BitrateSenderAgent	Inner class BitrateSenderAgent
ScalabilityTest.RTTReceiverAgent	Inner class RTTReceiverAgent
ScalabilityTest.RTTSenderAgent	Inner class RTTSenderAgent
Service.SliceProxy	Deprecated. use the class jade.core.SliceProxy instead of this inner class
ServiceDescriptor	The ServiceDescriptor class serves as a meta-level description of a kernel-level service.
ServiceManagerImpl	The ServiceManagerImpl class is the actual implementation of JADE platform Service Manager and Service Finder components.
SliceProxy	An implementation of the Service.Slice interface, supporting routed dispatching of horizontal commands.
Specifier	This class represent a specifier and collects a name, a className, and an array of arguments.
Timer	This class is used by the JADE internal timing system to schedule actions after a given amount of time.
TimerDispatcher	This class implements the JADE internal timing system.

Exception Summary

IMTPException	This exception is thrown when an error occurs in the communication with a remote object
NameClashException	This exception is thrown when trying to create an agent with an already existing name.
NotFoundException	This exception is thrown when some component (agent, agent container, etc.)
PostponedException	This exception is thrown by the FrontEndStub to indicate that a commmand has been postponed due to a temporary disconnection and will be delivered as soon as the FrontEnd will reconnect.
ProfileException	This class represents an exception related to JADE profile creation or management.
ServiceException	Generic exception thrown by JADE kernel level services.
ServiceNotActiveException	This exception is thrown when trying to access a JADE kernel level service that is not installed in the local node.
UnreachableException	This exception is thrown when some agent container cannot be contacted.

Error Summary

Agent.Interrupted

Inner class Interrupted.

Package jade.core Description

This package contains the microkernel of JADE system. Three main assets are contained within this software package:

1. Base Agent class, with fundamental message passing and behaviour scheduling capabilities.
2. Distributed objects runtime environment to support agent platform.
3. Set of pre-built behaviours for basic task structuring needs.

This package features provide a simple message passing system with multiple transport protocols (Java events within the same Java Virtual Machine, RMI across Java Virtual Machines belonging to the same JADE platform, and standard IIOP protocol to communicate with different agent platforms) and a multithreaded execution environment for software agents, with preemptive inter-agent scheduling and cooperative intra-agent scheduling.