Abstract: A method for matching an object key is described. The method includes the steps of calculating one or more values determined by one or more portions of the object key and comparing the values with a plurality of stored data. The method also includes the step of selecting a stored datum matching the largest portion of the object key.

Abstract: According to one aspect of the present invention, a system is provided to support a web-based application. The system comprising a set of server-side objects managed by an object manager (OM), the set of server-side objects including a global session object providing access to a repository, a server-side business object, and server-side business components contained in the server-side business object. The system further comprises a set of browser-side objects running on a browser, the set of browser-side objects including a browser-side application object that exists throughout a user-session to manage other browser-side objects. The system also comprises a remote procedure call (RPC) mechanism and a notification mechanism to facilitate communication and synchronization between the browser-side objects and the server-side objects.

Abstract: Improved frameworks for implementing class files that are particularly useful in virtual machine based computing systems will be described. In one aspect of the invention, each method within a class file is associated with a corresponding “reference cell.” The reference cells typically include sufficient information to facilitate the invocation of the corresponding method. By way of example, each reference cell may include a class pointer field, a method name field, a signature field and potentially other fields. In another aspect of the invention, a process for loading class files into a virtual machine based computing system is described. Each method invocation within the class file is translated into an internal invocation that references a reference cell associated with the internal class representation that contains the method.

Abstract: The present invention provides a method for devices to be remotely accessed over a network. A remote device drive is coupled to a bus device driver at a network client. The remote device driver communicates to a remote bus proxy to a driver service in the server domain. A device manager provides responsibility for discovering services on network clients, enabling driver services to use the devices, notifying other driver services of the availability of devices, notifying clients of the permission to use a device by a service, and tracking connected devices.

Abstract: A method and system are disclosed for platform-independent file system interaction that can abstract the system-level idiosyncrasies associated with multi-platform, multi-language, multi-encoding file system interactions. One embodiment of the method of this invention can comprise instantiating a string object via a development environment coded calling process and setting a file name and a file path, having an easily-identifiable format, for the string object with the calling process. The string object can determine the encoding of the file name and the file path and the calling process can forward the string object and an associated file operation to an operating system level file system interface handler. The operating system level file system interface handler can call an operating system naming function to format the string object. The string object naming function can be compiled along with an encoding marker indicating the target operating system for the desired file operation.

Abstract: An environment for developing clientside/serverside code is disclosed. The environment supports the perception that the server space and client space are seamlessly joined into a single program execution space. An outgrowth of the single execution space includes effective event handing on the server through enabling created objects to migrate effectively between the server and client.

Abstract: A system and method of assembling an application for processing image or image-derived data is disclosed. The system includes a base operator configured to interface with one or more derivative operator classes, each operator class including an operator object for executing a processing function on the image or image-derived data. A base multiport node class is provided, which is configured to provide a multiport node for each operator object. The multiport nodes instantiates a pluggable operator for connecting the multiport nodes together at runtime according to user-defined parameters. The connection of multiport nodes implements the processing functions of the operator objects to execute the application.

Abstract: A computing system for performing stateful distributed computing includes a client machine having a Client Runtime Environment (CRE) that is adapted to maintain the state of an application in the client machine. The CRE maintains state of the application by first retrieving a first markup document of the application, creating and storing a first object oriented representation of information contained in the first markup document. The first object oriented representation defines a first state of the application. Next, retrieving a second markup document, creating and storing a second object oriented representation of information contained in the second markup document. Finally merging the first and second object oriented representations thereby forming a new object oriented representation of information contained in the first or the second markup documents. This new object oriented representation defines a new state of said application.

Abstract: A system and method is provided for bridging disparate object systems. The system includes a first wrapper to bridge communications between a first object system and a second object system and a second wrapper to bridge communications between the second object system and the first object system. The first wrapper insulates the first object system from interface implementations in the second object system and the second wrapper insulates the second object system from interface implementations in the first object system to facilitate transparent communications between the first and second object systems. The first object system may be at least one of a managed object system and an unmanaged object system, and the second object system may be at least one of a managed object system and an unmanaged object system.

Abstract: A method and system for responding to requests for static web documents including saving the response as a packet train comprising one or more IP compliant packets. Upon a subsequent request for the static web document, the saved packet train may be retrieved and the header information updated. In this manner, the network protocol processing required to respond to the request is reduced. The server may include code for determining whether a referenced web object is a static object and a directory of recently accessed static web objects and a copy of the corresponding packet trains. The web server may be configured to consult the directory to determine if an object is a static object that has been recently accessed. If the object has been recently accessed, the server may retrieve the corresponding packet train from its system memory or from disk and update the packet headers prior to transmission.

Abstract: The present invention provides a universal information appliance management system capable of utilizing a distributed object system without regard to whether the appliance is embodied as a hardware device or embodied as software capable of being executed by any other hardware device such that the hardware device is indistinguishable from the software device. In addition, the invention provides a virtual reality interface including a dynamic virtual reality object capable of adapting to interaction by the user. Additionally, the invention provides a system and method for providing distributed functionality over a network including receiving a request to perform a task on a first digital information appliance, the task requiring a resource not included on the first digital information appliance. The digital information appliance locates a second digital information appliance over a network, the second digital information appliance including the resource.

Abstract: In an object-oriented data processing system, methods and systems in accordance with the present invention provide a proxy class dynamically generated at runtime that implements a list of interfaces specified at runtime such that a method invocation through an interface on an instance of the class is encoded and dispatched uniformly to an object that performs the invocation of the requested method. The generation of the proxy class at runtime and the specification at runtime of the list of interfaces implemented by the proxy class allow the interfaces to be used to be chosen at runtime before generation of the proxy class. Since the proxy class does not need to be created before compile time, the interface list implemented by the proxy class does not need to be known at the time the source code is written.

Abstract: A method and apparatus that includes processing for providing reliable interoperation of the plurality of independent software modules. Such processing begins by determining selection of an object by one of a plurality of independent software modules to produce a new object selection. The processing then continues by determining object selection status, which indicates a selected object and an associated one of the plurality of independent software modules. In other words, the object selection status indicates which independent software module is currently managing a particular object. The processing then continues by updating the object selection status when a difference occurs between at least one of the independent software modules identified currently in the object selection status and the independent software module selecting the object, and/or the newly selected object is different from the object identified in the object selection status.

Abstract: An Object-Based Contact List (OBCL) allows users to interact with multiple Notification Service Providers (NSP) on a network simultaneously. The NSPs provide smart events wherein notification of the user may be governed by response logic as defined in an NSP-based program.

Abstract: An asynchronous programming environment is disclosed. In one embodiment, the environment comprises a dynamic object storage scheme, a dynamic dispatch scheme, and an object recognition scheme. The dynamic object storage scheme stores a plurality of objects. The dynamic dispatch scheme is presence one of a certain number objects. The object recognition scheme describes the plurality of objects.

Abstract: A common information model (CIM) enables management application programs to receive uniformly rendered results regardless of the source of the information. A CIM object manager isolates the applications from internal components which retrieve the information from various sources and through various other components, and provides refinements to that model that improve the exchange of information. In addition to providing uniform rendering of management information to a client applications, the CIM object manager dynamically adapts to complement the capabilities of the information providers, whereby the information providers may do so in a highly flexible manner. The CIMOM also decomposes a client query to determine the appropriate source or sources of information necessary to resolve that query, and further handles client queries having inherited object classes to render appropriate results in a uniform manner.

Abstract: A method and system for declarative user interface dependency-based object property system are provided. A source object property change is obtained. Steady-state values for all dependent properties are obtained. Any dependent properties whose value is not affected by the source property change are eliminated or which are duplicate properties are eliminated. The remaining steady-state post modification dependent object property changes are implemented.

Abstract: A hierarchical method is provided for fault tolerance in a distributed computer system. A plurality of data centers is provided having a plurality of objects in each of the plurality of data centers. A local sub-protocol is used for dissemination of messages within a data center in the plurality of data centers and the local sub-protocol is activated from another data center of the plurality of data centers in a single round-trip message in the absence of faults.

Abstract: A system is described which provides the capability for high-level extensible scripting language interpreters to incorporate and employ Web browser plug-ins as components within script-based programs. A script interpreter extension is described which simulates the plug-in API interface of a Web browser, from the point of view of the browser plug-in, to allow program scripts to cause browser plug-ins to be launched and manipulated, in a manner similar to the scripting platform's native widgets, from within the executing program script. This system allows embedded external program objects to be used to display and enable interactive processing of embedded data objects.

Abstract: As a solution to the problem of distributed knowledge of data object definitions, data object definitions are removed from the source code. A Meta Data Service is created and made available on a network which knows the definitions of all of the objects that are used by applications that are designed to use the Meta Data Service. When an object is created, the Meta Data Service creates and stores a meta definition for the object. Data objects are passed over a network in a “soft” format. Applications within a distributed data processing system are designed in such a manner such that, at any stage of object processing, an application does not assume to understand the definition or structure of an object, nor is an application hard-coded with the object definitions. At each stage, an application queries the Meta Data Service for the meta definition of the object before proceeding with the processing of an object.

Abstract: A system and method are disclosed for utilizing a computer with a first operating system to access and perform operations on a second computer having a different operating system, using a web-based adapter routine. A Java console accesses a web based adapter routine to implement a set of Java based APIs to perform CIM operations. The adapter routine, in conjunction with a Java Native Interface and a CIM to WMI mapper enables CIM operations to be performed on a managed server having for example, a Microsoft Operating System or XML based communications.

Abstract: Remote access to a target object, in particular a target bean object, is provided by generating a client object or objects forming a representation of a target object. The client object(s) identify(ies) methods of the target object which are accessible remotely and implements the remotely accessible methods. The target object is associated with a network adaptor for a network protocol at the remote station. The client object is associated with a network adaptor for the network protocol at the client machine. A client application can then access the target object by instantiating the client object. The target object does not need to be modified or to include specific communications code to be manipulated by a remote object.

Abstract: The invention relates to implementing data transmission between at least two sets of software used in one or more devices which comprise means for establishing a connection to a telecommunications system. The communication is partly carried out with method calls including a service request. A service broker supplies the service request included in the method call to indicated server, which responds to the method call by sending required information back to the sender of the method call via the service broker. At least some of the programs participating in data transmission are implemented with a script-based programming language in the devices. The arrangement comprises an application which transmits service requests and responses to the requests between the service broker and the software that needs data transmission, and renders data transmission requests and responses to the requests compatible between script-based software and another system.

Abstract: Run time sampling techniques have been developed whereby representative object lifetime statistics may be obtained and employed to adaptively affect tenuring decisions, memory object promotion and/or storage location selection. In some realizations, object allocation functionality is dynamically varied to achieve desired behavior on an object category-by-category basis. In some realizations, phase behavior affects sampled lifetimes e.g., for objects allocated at different phases of program execution, and the dynamic facilities described herein provide phase-specific adaptation tenuring decisions, memory object promotion and/or storage location selection. In some realizations, reversal of such decisions is provided.

Abstract: A system and method for display of and interaction with local and remote data objects in a distributed data processing system is disclosed. In an embodiment, given sufficient information or “meta data” (i.e. data about data) for a local system and a remote system, a data object viewer may combine both local and remote data objects in a single view. In an embodiment, a user may interact with these local and remote data objects in a context sensitive manner such that, in dependence on the selected data object, either a local action, a remote action, or both local and remote actions may be performed on the selected data object.

Abstract: A slide show presentation “plug-in” that permits the user to control an animated dynamic situation display during a PowerPoint slide-show presentation without interrupting the slide-show mode to edit the slide. A dynamic situation display file is encapsulated in a Slide object linked to a second window. A Replay Plug-In object is embedded in the PowerPoint slide to intercept user interface device (UID) events in the first slide show presentation window. These events are transferred through a COM Server object to the Slide object running in the second window, which uses a Dynamic Display object to control and edit the attributes of the dynamic situation display for replay in the second window overlapping the slide-show window.

Abstract: A software development toolkit allows a user to create one or more real-time interactive control and communication software objects for use in connection with a computer and a machine which communicate pursuant to a standard communication protocol for process control. The toolkit allows, for example, a user to create ActiveX controls that are OPC compliant.

Abstract: An automatic context association system includes a context association schema for representing context associations between objects. The schema comprises a series of tables, including association tables with type-independent entries to support the association of objects of different types, and object tables that define the various objects. The schema supports the observation of user interaction with various system objects, including documents, photos, web pages, and interaction with other people, in order to find and utilize meaningful associations between them.

Abstract: The MIST provides a mechanism to dynamically determine and characterize the status of distributed objects that communicate in a complex, multiple sub-system, and systems integration environment. At run time, objects that should be participating in the environment are determined. A static database or dynamic learning mechanism is used to characterize the platform's interface graph. The status of event channels and servers, and their corresponding interfaces, are continuously determined and depicted. Status is graphically displayed by using various filtering, a circular interface display, and 2-D graph displays to allow a user to rapidly identify the occurrence, source, and impact of system interface faults.

Abstract: Methods, software, and apparatus for transparently pairing data with a command object, with respect to the application which wishes to present the data, are disclosed. In one aspect of the present invention, a computer-implemented framework for associating data with a command object includes a data handler mechanism arranged to interface with an application which wishes to use the data. The framework also includes a data retriever mechanism that is arranged to obtain the data, and is in communication with the data handler mechanism, as well as a mapping mechanism, which is also in communication with the data handler mechanism, and is arranged to obtain the command object. In one embodiment of the present invention, the data is a stream of bytes, and the data handler mechanism is used to bind the stream of bytes to the command object.

Abstract: A system and method for continually updating dynamic data on a web-page of a user on a real-time basis and without requiring refreshment of the web-page by employing a contribution, distribution and display tier.

Abstract: Methods, systems and computer program products are provided which provide data to an end user from a host application or a database application by providing a plurality of integration objects which communicate with the host application or the database application and which provide information for communication with a browser application of the end user. At least two of the integration objects are chained such that instantiation of a first one of the integration objects provides an intermediate state as a start state for use by the second one of the integration objects. Furthermore, at least one of the two integration objects provides data for display by the browser application of the end user.

Abstract: A system and method for managing network devices. The framework may provide a suitable system for managed object data type conversions between various data description languages, such as an interface definition language (e.g., OMG IDL) and an abstract syntax notation (e.g., ASN1). This conversion facility may be used in both request and event network traffic, so common libraries may be used. Two separate libraries may be used: a converter framework library and a converter implementation library. The framework library provides a collection classes that may be used by the clients of the converter libraries. Most classes in the converter framework library are handle classes (or wrappers) to the real implementation (or body) classes in the converter implementation library. Framework classes hide the details of the real implementation classes and provide a simple, consistent interface to any data type converter via IDL.

Abstract: A method and system thereof for supporting multiple versions of software, such as software organized as components or objects. In one embodiment, a software component (e.g., a new object) is implemented on a server node. A translator is created on the server node. The translator provides an interface to the new object for an invocation request associated with a different version of the object (e.g., an older version of the object). The new object is referenced by one identifier, and the translator is referenced by another identifier. In essence, the translator provides a form of version transparency.

Abstract: A system and method for establishing associative relationships between properties of a contained object and corresponding parameters of a container application. The system contemplates establishment of mutual and unilateral associative relationships, with a particular relationship being specified via a user interface created upon instantiation of the contained object. Such associative relationships may be advantageously established without modification of the code comprising the contained object. In one aspect the system facilitates implementation of selected functionality of a container application prescribed by an event script. In this context an association is created between an event arising within a contained object instantiated in a computing environment and a script associated with the container application. An event indication is generated in response to occurrence of a particular event within the contained object.

Abstract: A cache server is provided in a network for storing Java objects for retrieval by one or multiple application servers. Application server(s) are configured to request an object from the cache server, rather than requesting the Java object directly from a database, so as to reduce processing load on the database and free up database resources. Responsive to a request for a Java object from an application server, e.g., in an HTTP request, the cache server determines if the object is stored in memory and if so, serializes the requested object and sends the serialized object to the requesting server, e.g., in an HTTP response. The requesting server then deserializes the Java object. If the object is not stored in memory, the cache server instantiates the object (typically by requesting the object from the database), serializes the instantiated object and sends it to the requesting server. Cache coherency methods are also provided.

Abstract: The present invention provides a performance monitoring method of a processing flow that, in a distributed object system, a processing is completed after going by way of processing of several objects through objects. A collector collects, as performance data, a receiving time of a message from the other object and a sending time of a message to the other for an object that becomes a measurement target on each computer. A manager puts received performance data together and calculates and displays a processing time of each object that constitutes a processing flow and a communication time between objects.

Abstract: An enterprise JavaBeans architecture is provided which includes an application server having a container and a plurality of enterprise beans residing in the container, a remote server having a container and a plurality of proxy beans residing in the container and configured to communicate with the application server, and a plurality of client systems configured to communicate with the plurality of proxy beans of the remote server. The plurality of proxy beans are deployed on the remote server. A method of using proxy beans is provided which includes generating a plurality of proxy beans, deploying the plurality of proxy beans into the container of the remote server, and performing a method call on at least one of the plurality of proxy beans. The method also includes transmitting the method call to one of the plurality of enterprise beans located at the application server and accessing the enterprise bean having the method call.

Abstract: A system, method, and computer program product are disclosed for providing a four-tier CORBA architecture. A three-tier CORBA network is provided. The three-tier CORBA network includes a first CORBA ORB coupled to a second CORBA ORB, and the second CORBA ORB coupled to a third CORBA ORB. The first CORBA ORB occupies a first level of a network hierarchy. The second CORBA ORB occupies a second level of the network hierarchy. And, the third CORBA ORB occupies a third level of the network hierarchy. A global CORBA ORB is coupled to the three-tier CORBA network, wherein the global CORBA ORB occupies a top level of the network hierarchy.

Abstract: The present invention discloses a message logging framework comprising a log object created by a destination log class extending a log base class and the log base class implementing a log interface. The log base class comprises a method for formatting a message and the destination log class comprises a method to log the formatted message to a destination log. In a preferred embodiment, the log base class further comprises a method for filtering the message by comparing a severity attribute of the message to a filter severity criterion. The present invention also discloses a message logging framework comprising a group log object created by a group log class extending a log collection class and implementing a log interface. The group log class comprises a method to log the message to a plurality of destination logs.

Abstract: With better knowledge of the behavior of objects in a running application, it is possible to improve execution environment decisions that affect management of such objects. For example, if available, object lifetime statistics could be employed in decisions that affect how and where objects are placed, e.g., on allocation or during operation of automatic dynamic memory management facilities such as a garbage collector. Typically, instrumenting all objects to sample lifetimes or other characteristics would impose an impractical level of overhead. We present a technique for dynamic sampling of a subset of allocated objects that incurs low runtime overheads. Coupled with automatic memory management or collection facilities, this technique allows us to improve the efficiency of a collector by segregating objects, sampled and non-sampled alike, based on observed characteristics such as object lifetime. The sampling techniques facilitate tracking of many kinds of object information.

Abstract: A system and method for defining MES interface to process a transaction between a server and a client from an XML base, the transaction between the server and the client based on a communication protocol, the server having an MES, the system for defining the MES interface comprising an IDL file for executing a plurality of service objects of the MES, an XML tag set file, wherein the XML tag set file uses XML for defining interfaces of the plurality of service objects and an XML schema file, wherein the XML schema file is within a web server for validating an output content generated by executing IDL file and the XML tag set file, wherein the XML tag set file is adapted to serve at least one argument of the plurality of service objects within the IDL file.

Abstract: Dynamic object behavior for object-oriented environments. In one embodiment, a system having an object, a data store, and application. The object has a plurality of dynamic behaviors. The data store data regarding the plurality of dynamic behaviors. The application instantiates the object from data stored in the data store regarding the plurality of dynamic behaviors.

Abstract: A system includes a portal connected to user interface (UI) components, application logic linking the UI components to a repository layer and connectivity layer through an object access layer, and source systems linked to the repository layer and the connectivity layer.

Abstract: A network navigator interface system and method incorporating a client/server architecture in which a network coarse-grained model (or single object) (NameSpaceObject) is used to create a fine-grained object model is disclosed. The disclosed invention permits a client application to discover the detailed interface provided by each object instance in the fine-grained model. A client application wishing to invoke an operation on a server-side object first obtains an object reference (IOR) to a NameSpaceObject instance. Each NameSpaceObject instance stores a pointer to an object in the fine-grained model. The NameSpaceObject interface provides operations to move this pointer around in a hierarchical model. Once the pointer is set to reference a certain object in the fine-grained model, this object becomes the target for all further operations. The available operations include object contents discovery/manipulation, object interface discovery and operation invocation.

Abstract: The present invention provides a method and apparatus for accessing and using services and applications from a number of sources into a customized application. The present invention accomplishes this through an entity referred to as a web service. The web services architecture maintains a directory of services available to provide processing or services, along with the location of the services and the input/output schemas required by the services. When a request for data or services is received, appropriate services are invoked by a web services engine using service drivers associated with each service. A web services application is then generated from a runtime model and is invoked to satisfy the request, by communicating as necessary with services in proper I/O formats. In one embodiment, the web services application provides responses in the form of HTML that can be used to generate pages to a browser.

Abstract: Server-side control objects corresponding to client-side user interface elements are created in a control object hierarchy. Properties of the control objects may be data bound to properties of a server-side data source (e.g., a server-side database). Hierarchical data binding relationships are established between properties of control objects and properties of a data source. Template declarations are used to define the configuration of binding container objects that correspond to data objects in the data source. An iterating control object determines the number of data objects in the data source increase according number of binding container objects. A simple data binding types include without limitation: (1) unidirectional data binding from the data source to a control object; (2) unidirectional data binding from a control object to the data source; and (3) bidirectional data binding between a control object and the data source.

Abstract: In one aspect of the present invention a framework is presented for the generation and execution of code performing conversion to and from an arbitrary native or “wire” data format. The code facilitates a business application using a service provided by a service implementation in accordance with a native language of the implementation which may be different from the language of the business application. The main components of the framework include a model of the information necessary for the formatting of data which may be represented through the extensions to WSDL; a tool time support environment providing structured support for the generation of format handlers; and runtime support for the generated format handlers. In an alternative to this static invocation model, a dynamic usage scenario provides for invocation of format handlers dynamically obtained from a format handler factory.

Abstract: A system and method for dynamically creating and cleaning up correlation circuits connecting effect events, such as a system failure, with their corresponding cause events. Object instances are created to act upon cause and effect events. A particular object instance can be both a cause event for another object as well as an effect event for another causal event and adapted to monitor network devices. When a cause event occurs in the system, it publishes messages to other objects subscribed to it. A correlation circuit is dynamically created by linking effects with their causes, those causes with their causes, until a root cause is located. Correlation circuits dynamically change depending upon the events occurring in the system.

Abstract: The present invention, sometimes referred to as an Application Message Wrapper Generation Wizard or Wizard (for short), is a tool to help application developers map Cobol or Natural copybooks into a message command for an ASCII-based text messaging service. In this sense, the Wizard facilitates communication between client applications and server applications by allowing the client to use generic requests and allowing the Wizard generated files providing the correct protocol and syntax for communication with the destination server application. The Wizard generates Java classes that will mine/plant data a runtime between business objects and a message string that corresponds to the copybook's data structure, and vice versa. The Wizard recognizes different data types of copybook fields respectively, and converts them to/from ASCII.