Home >> All >> net >> hivecell

•	net.hivecell.hive.* (271)

Package Samples:

• net.hivecell.hive.agent
• net.hivecell.hive.agent.filter
• net.hivecell.hive.agent.games.hunter
• net.hivecell.hive.agent.hiveui.remoteui
• net.hivecell.hive.agent.image
• net.hivecell.hive.agent.thing
• net.hivecell.hive.agent.wearable
• net.hivecell.hive.event
• net.hivecell.hive.shadow.sysinfo
• net.hivecell.hive.shadow
• net.hivecell.hive.shadow.thing
• net.hivecell.hive.support.pocketserver
• net.hivecell.hive.support
• net.hivecell.hive.agent.cell
• net.hivecell.hive.agent.hiveui.iconicui
• net.hivecell.hive.agent.hiveui
• net.hivecell.hive.agent.hiveui.treeui
• net.hivecell.hive.agent.service
• net.hivecell.hive

Classes:

• AgentImpl: Base class for Hive agent implementations. An agent has a life cycle. Once in its lifetime, the agent is constructed by the no argument constructor. The agent arrives on a server; its doLocalSetup() method is called. This happens whenever it first comes to a server, whether created by Cell.createNewAgent(Class) or when it moves to the server. The agent's doBehavior() method is called. This method is the agent's main loop, where it's behavior is implemented. The agent is free to do what it wants, but should respect timeToStop . The agent sould never exit this method, a convienience method waitUntilDeath ...
• ExternalInterfaceShadow: the external interface shadow listens for connections coming from an external source. the other source can connect to us and send events to us, and we can spit events out through the socket. because event sending is unreliable, these events may or may not get to the remote agent. eventually we will need to actually send an exception down the stream, but right now i don't want to deal with that to deal with events the device want to send out, we need XML which looks like this: ... ... . tags . . . the destination tag needs to be there, but only one of the syntatic or the semantic is necessary. the ...
• ExternalInterfaceShadowImpl: the external interface shadow listens for connections coming from an external source. the other source can connect to us and send events to us, and we can spit events out through the socket. because event sending is unreliable, these events may or may not get to the remote agent. eventually we will need to actually send an exception down the stream, but right now i don't want to deal with that to deal with events the device want to send out, we need XML which looks like this: ... ... . tags . . . the destination tag needs to be there, but only one of the syntatic or the semantic is necessary. the ...
• CellAddress: This immutable class represents the URL of a Hive Cell. The protocol portion of the url is defined to be "hive", and will not allow the construction of urls with a different protocol. CellAddress follows the CISS (Common Internet Scheme Standard) Spec, although currently the file and ref portions of the URL are not used by the Hive system. WARNING: Java deviates from it's spec (at least on windows) in the DNS lookup behavior. Doing a InetAdderss.getByName(host).getHostName() does NOT return the fully qualified hostname as it should. Rather, some wierd caching behavior is causing the original argument ...
• IconicUIAgentImpl: The UIAgent for a boxes and lines style GUI. BUGS: - Test this (from uiCanvas): Let the Canvas know it shouldn't start any new renders, as its agent is being killed. This might only be necessary because of the IcUIAg icon hack, test later. - A monitors B, A goes down, A comes back up, A tries to monitor B again, B throws rmi errors (problem with rmi, but might be possible to do a workaround). (not me, not raffi, sun.) - A monitors B, A kills self, A throws null. OR EVEN A monitors B, A stops monitoring B, A kills self, A throws null. (not me) - IcUIAg stops monitoring its own cell, then AWTUI kills ...
• CellListAgentImpl: An agent that keeps a list of servers. Agents are in two flavours: a "master" agent that broadcasts events to whomever cares to listen, and "client" agents that subscribe to masters to track who is up or down. Eventually, the distinction between masters and clients might disappear, to make a more decentralized system. The agent sends events telling subscribers when servers are coming up or going down. Typically, only the master agent will be subscribed to. However, the slave agents can also rebroadcast these events, but -only- to other local agents The agent receives events from AgentMonitoringAgents ...
• EventReceivingDescription: this interface is used so the event receiving agent can list the objects that it can respond to best. event receiving agents are supposed to be designed so they can repsond to any generic event, and then take special notice of certain events (ie -- string display agents will display whatever event they will get mouse events, etc, etc -- but it will display a string if it gets a string. so the String object is a specific event that the StringDisplayAgentImpl can handle. so this interface allows agent authors to list the objects that it can specially handle. this information is not stuck in the Description ...
• EventSendingHelper: Helper class for EventSendingAgent interface; agent implementations can delegate methods to this class. This class maintains a list of listeners for events, as well as a count of events it has sent. When broadcastEvent is called by the client, the EventSendingHelper delivers the message to all current listeners. By default these messages are sent asynchronously. Please be careful if creating Hive objects to send by hand -- use the getCount() method in this object to determine the value that the count field in the HiveEvent constructor can use. This is not the recommended way to send events -- it ...
• AgentMessagingShadow: this class will allow us to remove the need for each individual agent to do its own event sending and receiving through RMI -- this will allow us to remove the need to spawn off so many asynchronous messaging threads, and will also allow us to cut down on the number of sockets hive needs especuially when there is a significant amount of messaging occuring. by default, the event shadow will open a random port there will be an agent which will sit on the cell to help shadows negotiate what ports they are sending to. right now (and therefore probably never) the port on which the shadow is operating ...
• AgentMessagingShadowImpl: this class will allow us to remove the need for each individual agent to do its own event sending and receiving through RMI -- this will allow us to remove the need to spawn off so many asynchronous messaging threads, and will also allow us to cut down on the number of sockets hive needs especuially when there is a significant amount of messaging occuring. by default, the event shadow will open a random port there will be an agent which will sit on the cell to help shadows negotiate what ports they are sending to. right now (and therefore probably never) the port on which the shadow is operating ...
• AgentSet: NEW VISUALIZATION: 2/27/00, tucker This is an AgentSet, which stores a group of Agents, and has methods for querying them based on their descriptions. The reason it is now focused on the agent as opposed to the description is to guarantee that the agent and its description will always be in sync. Currently, the set was stored by the description, so that if an agent changed its description, that would not be reflected in the set. This way the description will always be in sync, as it is referenced through its agent. Also, this allows for agents with null descriptions to be included in set.
• AsyncCaller: This is the default implementation of the asynchronous caller. It first creates the AsyncResult object, then spawns a thread which will do the asynchronous call. If the delay time passed to the watching thread is non-negative, it will spin off another thread which will sleep for a specified amount of time. If the calling thread does not complete before the watching thread, then it is killed and the AsyncResult will contain an AsyncCallNotCompleteException. This class is implemented as a singleton because there is no need to have more than one object at a time running.
• Debug: The Debug class implements a simple debugging facility. Debugging messages are sent using one of the println methods, which are then sent out the debugging stream (by default, System.err ). Messages are tagged with a debugging level; if the message is less serious than the current debugging level, then the message is not printed. Hive code should use this facility for all debugging messages. The default debug level is NOTICE . Note: the class is entirely static, you should not instantiate it.
• CellAgent: This interface is used to tag those agents which are "privledged". The reason this is used is for the session management support. When the AgentGraph records the agents which are in the system, it will inevitably record the UIManagerAgent and the CellListAgent. These will be restored by the Cell itself, so the SerializingAgentGraph has to realize which ones it should not restore . I'm assuming (I'm hoping I'm right), is that only one type of a "privledged" agent will be active on a server at one time. Please tell me if I'm wrong.
• AutoMonitoringAgentImpl: this agent's sole purpose is to ask the agent monitoring agent to monitor any servers which have appeared on the scene (as according to the server list agent). this works by having this agent subscribe to the local server list agent and whenever it gets a message that a server goes up, it will ask the agent monitoring agent to monitor it. if a cell goes down or withdraws, then it will ask the agent monitoring agent to stop monitoring it
• BaseUIAgentImpl: the standard base class for all ui agents -- this class will handle the minimum amount of state maintainance, and it will also handles a lot of the communications to the agent monitoring agents todo list -- the ability to monitor less cells than the agent monitoring agent is monitoring -- this would require that we filter the information the agent monitoring agent is sending and we need to keep track of exactly who we are monitoring
• shadowc: this is the shadow compiler. the shadow compiler takes a shadow's class file, then generates a stub that can be used for that shadow. it takes a class file, first confirms that it is a Shadow, then it gets all the interfaces and makes sure that somewhere this shadow implements Shadow. then it generates a list of the methods from the shadow's interfaces and outputs some java code that when compiled will be the proxy to this shadow
• LocationServiceRequestAgent: This Agent takes in locations, represented as strings containing the MIT room number (e.g. "e15-305"). It then produces an AgentSet of services associated with that location. The right thing to do is allow a "Location" class to be sent as an event, which handles translation to and from bldg-room, GPS, address, zip-code, etc. In the meantime, we'll just use room numbers and strings (this should always be a fall-back anyway).
• SerializableImage: Each instance of this class represents an image stored as an array of ints. These images are not AWT images - they are device independent images that can be serialized. They can be created from AWT Images, or from subclasses such as PPM that read from files. The format is an array of integers - each integer is a pixel in ARGB format (the same that MemoryImageSource uses in the default color model).
• CellEvent: This is the event data for the server event -- it is designed to be able to be remitted. The case in which this becomes important is when then CellEventMonitor first creates this -- it will get a different sender and count code. These codes will be changed when they hit the agent that emits them, but the superclass will still contain the original code
• GenericFilterAgentImpl: This abstract class is the superclass for all image filters. Subclassers need merely to implement the abstract filter method to have a working filter. It is very important that filter return a NEW image, and not merely a modified copy of the argument, or else there will be a lot of issues with multiple agents sharing copies of the same image.
• BaseAWTGUIDisplayCellListButtonFrame: this class pops up a frame that has the servers listed in a choice field and then a button -- whatever extends this class can set what the title of the frame is, what the button label says, and the action performed when the button is pushed. right now this class is used for the shut down server and the stop monitoring server boxes
• BaseSwingGUIDisplayCellListButtonFrame: this class pops up a frame that has the servers listed in a choice field and then a button -- whatever extends this class can set what the title of the frame is, what the button label says, and the action performed when the button is pushed. right now this class is used for the shut down server and the stop monitoring server boxes

Home | Contact Us | Privacy Policy | Terms of Service