Abstract: An information processing apparatus comprises a plurality of control units, a shared memory, a processing number table and a start-up time table. When a transaction is received, each of the control units determines whether the current time in the shared memory coincides with the most recent start-up time in the processing number. If the current time does not coincide with the most recent start-up time, each of the control units updates the most recent start-up time with current time and if or not, adds 1 to the number of transactions being processed in the processing number table so as to update the number of transactions being processed. After the number of transactions is updated, each of the control units sums up the number of transactions being processed in the processing number table. Each of the control units determines whether the number of transactions is not more than the threshold value in the shared memory.

Abstract: An information processing device includes a processing unit which manages an association processing network formed by image processing devices. The processing unit includes a service evaluation content generating unit which acquires requirement performance information of a service to be stored from a service requirement performance managing unit and generates an evaluation content to be evaluated for the service by including the requirement performance information in an evaluation object, a service evaluation unit which evaluates the evaluation content of the service according to a predetermined requirement, and an association object managing unit which registers the service as a new association object the evaluation content of the service the predetermined requirement of which has been met by the evaluation of the service evaluation unit.

Abstract: Interoperability software modules comprise an architected .NET layer, an architected interpreter, an automatic interpreter and a library of COM objects. The architected interpreter where they are mapped to intermediate .NET interfaces compatible with the automatic interpreter by means of a Runtime Callable Wrapper (RCW). The architected interpreter also comprises an architected COM Callable Wrapper (CCW) that maps the intermediate COM interfaces into architected interfaces.

Abstract: An interactive computer architecture is provided that can be employed as a bridge between a mainframe-based computing environment and a distributed server-based computing environment. A request/reply contract can be expressed within the mainframe-based environment and employed as the basis for generating a web service in the distributed computing environment.

Abstract: A container service is capable of hosting large numbers of middleware components for multiple tenants. A central container manager controls a plurality of compute nodes. The central container manager receives middleware components from external devices or services and assigns the components to containers on one or more designated compute nodes. Each compute node has a container management agent and one or more containers. The container management agents activate and manage the appropriate number of containers to run the assigned middleware components. The container management agent assigns each container on its compute node a limited set of privileges to control access to shared resources. The central container manager and each node's container management agent monitor container load levels and dynamically adjust the placement of the middleware components to maintain balanced operation. The compute nodes are grouped into clusters based upon the type of middleware components hosted on each compute node.

Abstract: Disclosed is an architecture that allows business objects to communicate across deployment unit boundaries. A runtime object may be defined to listen for a trigger event in an offering business object. The runtime object then assemble and communicate a message for processing by a consuming business object. User interfaces allow a user to configure a service integration definition to generate the runtime object.

Abstract: A method of and an apparatus are provided for signaling a transmission code set in data broadcasting. A client using the transmission code set signaling method includes a demultiplexer demultiplexing a packetized elementary stream (PES) packet corresponding to a program selected by a user from the broadcasting stream received by the system interface, an image decoder decoding the demultiplexed PES for images, a sound decoder decoding the demultiplexed PES for sound, and a CPU fetching information about a transmission code set of a character string used in an object carousel message from the demultiplexed message PES and decoding the character string used in the object carousel message based on the fetched information about the transmission code set.

Abstract: An object is promoted by a governance domain, e.g., to a non-governance domain, by monitoring the object for a lifecycle state transition, publishing, using a processor, an alert as a feed if the monitored object transitions from one lifecycle state to another lifecycle state and exposing an application programming interface through which a production service registry obtains a copy of the monitored object. Correspondingly, a non-governance domain obtains an object through feed-based promotion by subscribing to a feed including information about lifecycle state transitions of an object of interest to the non-governance domain, where the feed is from a governance domain, monitoring the feed for alerts on the object transitioning lifecycle states, notifying a promotion handler on the non-governance domain that the object has transitioned lifecycle states and obtaining the object from the governance domain.

Abstract: On a parallel processing system by an OS for single processors which operates, on a multiprocessor, an OS for single processors and an existing application to realize parallel processing by the multiprocessor with respect to the application, each processor includes a communication proxy unit which transfers data between tasks spreading over the processors by proxy and the communication proxy unit on a processor in which a task on a transmission side operates holds information about an address, on a processor, of a task on a reception side to receive data transferred from the task on the transmission side as proxy for the task on the reception side.

Abstract: The present invention provides methods, apparatus and systems for reusing an application object for use with an application program, in which the object can be reused without causing nonconformity in the consistency or security, even if the object to be reused is updated. An example of a method includes detecting that the application program ends referring to the application object, detecting that the application object is updated by the application program, deciding to reuse the application object in response to detecting no update of the application object, making the application object reusable in response to the end of referring to the object, and decision to reuse the application object.

Abstract: A method for terminal configuration and management includes: acquiring a configuration file, where the configuration file includes server account information; configuring the server account information in the acquired configuration file onto a Device Management Tree (DMT) of a terminal; based on the server account information, establishing a management session between the terminal and the server, and performing management and subsequent configuration on the terminal during the session. A corresponding terminal device and a corresponding system are also provided. Through the method, the terminal can determine, according to protocol version information supported by or corresponding to the corresponding server and carried in a configuration packet, a protocol that should be used for communication with a server, and perform configuration according to the correct protocol version, thus improving the operation efficiency.

Abstract: In a method for managing a Customer Premises Equipment (CPE), an Auto-Configuration Server (ACS) designates a first designated instance number for a first instance object. A message is then sent to the CPE. The message carries the first designated instance number for the first instance object and is adapted to notify the CPE to take the first designated instance number as an instance number for the first instance object.

Abstract: Systems, methods and computer program products for dynamically binding data from a remote data source in a container-based mobile application are described herein. The method includes the steps of: 1) defining a metadata source that references both a mobile business object (MBO) and the mobile application, the MBO being connected to the remote data store; 2) binding an attribute from the MBO to the mobile application using the metadata source; and 3) changing, dynamically, the binding of the attribute while the mobile application is executing.

Abstract: A system and method for synchronous operation of linked command objects in a software application. The software application manages data objects in a number of contexts. Each context manages a number of command objects. Each command object operates on data objects in its context. To support synchronous operations that affect the state of data objects in more than one context, command objects are linked to each other. When a command object is executed, its context identifies a command object linked to the executed command object and initiates the execution of the linked command object. This synchronization allows for synchronous undo and redone operations. The delete states of the command objects are also synchronized. When one command object is deleted the command object linked thereto is also deleted, thereby preventing the linked command object from being independently undone resulting in an inconsistent state of the contexts.

Abstract: In one embodiment the present invention includes a systems and methods of accessing information across distributed computing components. In one embodiment, a first software component has associated information and references to information associated with other software components that provide inputs to the first software component. Information about downstream software components may be accessed through the references. In one embodiment, a first software service such as a web service may include metadata that describes the service and pointers to other services consumed by the first software service. Embodiments of the invention provide automated auditing and searching across related software components.

Abstract: The method determines whether a particular process is currently executing or not executing. The method embeds process identification information and a process name in a process pathname that binds to a socket. The method creates a socket and binds to the socket a process name and associated process identifier if that process is currently executing. A status file may store the socket pathnames of those processes currently executing. A socket pathname appears in the status file if a corresponding process is executing, but does not appear in the status file if the process is not executing. To determine if a particular process is currently executing, the method tests the status file to determine if the status file contains a match for the socket pathname associated with the particular process under test. The presence of a match for the socket pathname in the status file indicates that the particular process associated therewith is currently executing.

Abstract: Techniques to perform garbage collection in an environment where more than one software programming language is in use are described. A technique may include creating a managed proxy object in one language that creates an unmanaged object in memory in a different language. A collection of nodes is generated and maintained, where a node comprises: a reference to the managed proxy object, and a reference to the unmanaged object. A count of the nodes in the collection is maintained. When the count exceeds a threshold, the collection is traversed, and garbage collection is performed on any unmanaged object in a node when the managed proxy object in the same node has been collected. Other embodiments are described and claimed.

Abstract: Some aspects relate to systems and methods to receive a first metamodel conforming to a first meta-metamodel associated with first modeling unit types. A second metamodel conforming to a second meta-metamodel is generated based on the first metamodel and on a mapping between the first meta-metamodel and the second meta-metamodel, where the second meta-metamodel is associated with second modeling unit types, and where the first modeling unit types are different from the second modeling unit types.

Abstract: A computing system and method is a specification of user-defined business logic is provided as JAVA program instructions (or another programming language) which does not natively provide for specification of full transactionality, to accomplish a fully transactional application, including executed managed objects. The managed objects are persisted in a shared memory of the computing system, such that a scope of the objects is global to the fully transactional application. Furthermore, a catalog of the managed object is maintained. A query interface is provided for querying the managed objects, in order to receive a query from an application, to process the catalog, and to provide a result indication of at least one of the managed objects back to the querying application. Thus, for example, the application may process the managed objects that are indicated in the query result.

Abstract: A network routes update messages containing updates to properties of live objects from input sources to clients having the objects. When the clients receive live objects, the clients identify the object IDs associated with the objects and register the object IDs with the routing network. The routing network is adapted to selectively send update messages to nodes in the network and the nodes forward the messages to the clients. One implementation uses a hierarchy of registries to indicate which nodes and clients receive which update messages. Another implementation assigns update messages to one or more of N categories and nodes to one or more of M types, and the gateways maintain mapping between categories and types. To ensure that clients receive all of the update messages for which they register, the clients connect to client proxies that in turn connect to at least one node of each type.

Abstract: This disclosure describes, generally, methods and systems for implementing agile and dynamic help, defect tracking, and support frameworks for composite applications. The method includes implementing, on a computer system including a storage database, a composite application including a plurality of application components and establishing, in the computer system's storage database, a storage container for each of the plurality of application components. The storage containers are configured to store support information for each of the component applications. The method further includes storing, in the storage database, support data for each of the plurality of component applications, removing at least one of the plurality of component applications from the composite application, and maintaining, in the storage database, the support data for the remaining component applications of the composite application.

Abstract: A method and device for managing an object instance label relate to network management technologies, and can implement uniform configuration for instances under different customer premises equipments (CPEs). The method for associating an object instance label includes: receiving a message for associating an object instance label, where the message includes an object instance and a corresponding label; and associating the label with the object instance according to the message, where the label is used to identify the object instance. The present invention is applicable to batch configuration for instances under different CPEs.

Abstract: An improved system and method is disclosed for making the Common Information Model (CIM), produced by the Distributed Management Task Force (DMTF), more flexible and extensible without requiring changes to it or its existing implementations. MultipleInheritance associations are implemented to define extension abstract classes for managed element information and to create static and dynamic add-in classes, all operable to reference the CIM schema class. Ambiguity is mitigated by not allowing properties of different data types to have the same name in super classes that are used for MultipleInheritance associations. Data integrity is facilitated by merging class properties of the same name and data type through the use of a Min algorithm. Concrete user classes are derived from new abstract classes such that management functionality is enabled for managed element properties.

Abstract: A computer-implemented system for receiving an incoming message including a message header and a message body in General Inter-ORB Protocol (GIOP) type format, the system comprising: an external ORB element based on a computer configured to convert the header of the incoming message to an implementation-specific format, and configured to provide the header in implementation-specific format with the body in GIOP type format to a distribution mechanism for identifying an appropriate target server for processing the body of the incoming message; and an internal ORB element based on an originating server configured to convert the body of the outgoing message to CORBA GIOP type format to a distribution mechanism.

Abstract: Various embodiments provide an interface between a Web browser's layout engine and a scripting engine. The interface enables objects from the layout engine to be recognized by a memory manager in the scripting engine and interact in a streamlined, efficient manner. In accordance with one or more embodiments, the interface allows browser layout engine objects to be created as objects that are native to the scripting engine. Alternately or additionally, in some embodiments, the native objects are further configured to proxy functionality between the layout engine and the scripting engine.

Abstract: An update system configured to provide software updates, software patches and/or other data packets to one or more computer systems via a network is disclosed. The update system may interact with a network management system, such as an enterprise management system, to distribute data packets and gather configuration information. The update system may generate and send commands to the network management system. The network management system may carry out the commands to distribute data packets and/or gather configuration information.

Abstract: A computer system, in which cancellation status models are used. The computer system receives a request to cancel a parent data object node instance and accesses a first cancellation building block that models a first cancellation subprocess for the first type of data object node and that is integrated in a first status schema defined for the first type of data object node. The computer system executes cancellation of the parent data object node instance by accessing data that indicates whether or not a child data object node instance is able to be cancelled and conditioning cancellation of the parent data object node instance on the accessed data indicating that the child data object node instance is able to be cancelled.

Abstract: A system using proxy actions to handle requests for actions that are not yet registered with a broker. When an action request is received and the action is not registered in the broker, a proxy action object is created and stored on a proxy action queue. Proxy action objects stored on the queue are read periodically and a check is made as to whether the actions they refer to have been registered yet. If an action for a queued proxy action object has been registered, the action request represented by the proxy action object delivered to the appropriate service provider component. If a proxy action object remains on the proxy action queue without the corresponding action being registered before a corresponding proxy action queue element lifetime timer expires, the proxy action object is removed from the proxy action queue without the action being performed.

Abstract: Embodiments relate to generating sets of model objects having data messaging pipes. A modeling client can host modeling logic and an application programming interface (API) to create, access, manipulate, and import/export modeling objects used in modeling applications, such as engineering, medical, financial, and other modeling platforms. The source data accepted into the modeling client can include consumer or business-level applications, whose spreadsheet, database or other content can be extracted and encapsulated in object-oriented format, such as extensible markup language (XML) format. A set of modeling objects can be connected via data messaging pipes on a selective basis, so that individual objects can transmit or receive data outputs generated by other objects. The model objects can share, exchange, or combine computational outputs, internal data, and other information from other model object(s). Multiple pipes can be established at various levels or dimensions between objects or groups of objects.

Abstract: A computer readable medium embodying instructions executable by a processor to perform a method for hosting components implemented in different computer readable languages within one process. The method includes instantiating a container within a single process, creating a hosting environment for each of a plurality of components, and wherein loading the components by respective environments and wherein the hosting environments are objects instantiated within the container and within the one process, and wherein the plurality of components are implemented in respective a computer readable language, and instantiating a container communication framework object within the container and the one process for processing serialized messages of the components, wherein specific language adapters convert data types of the components to a common implementation, wherein the messages of the plurality of components are processed within the container.

Abstract: Systems, methods, and computer readable media are disclosed for providing a generic audit trail service for a plurality of business objects, at least two of the plurality of business objects being of different business object types. In one implementation, a computer-implemented method is provided that comprises receiving, at an application server, a notification of a change associated with at least one of the plurality of business objects, and requesting, in response to receiving the notification, auditing data from the at least one business object, the at least one business object implementing an auditable function set to interface with the application server. Further, the method includes receiving, through a called method of the auditable function set, the requested auditing data, and storing the received auditing data in a repository.

Abstract: Systems and techniques for providing a master data framework. The framework receives user input and automatically generates, in accordance with the input, a persistent definition of a business object type. The input can be simple declarations and need not be provided in any particular programming language. Definitions generated by the framework adhere to a same data model, regardless of the business object type they are defining. The framework allows the user to create a definition of a business object type by associating two or more definitions of other business object types. The framework provides services that can be applied, without further customization, to any definition of business object types generated by the framework. These services, for example, can be used by a calling application to instantiate business objects or to change a state of a business object instance.

Abstract: A system and method provide for synchronous operation of linked command objects in a general purpose software application. The software application provides a user with a variety of operations that manipulate available data objects. The software application manages the data objects in a number of contexts. Each context manages the existence and execution of a number of command objects. Each command object operates on one or more data objects in its context. To support synchronous operations that affect the state of data objects in more than one context, command objects are linked to each other. When one command object is executed, the context of the command object identifies a command object linked to the executed command object and initiates the execution of the linked command object via the context that manages that command object. This synchronization allows for synchronous undo and redone operations. The delete states of the command objects are also synchronized.

Abstract: Methods, apparatuses, and systems are presented for automating organization of multiple processes involving maintaining a uniform record of process threads using at least one server, each process thread comprising a representation of a collaborative process capable of involving a plurality of users, enabling at least one of the plurality of users to carry out a user action while interacting with one of a plurality of different types of application programs, and modifying at least one process thread in the uniform record of process threads in response to the user action carried out by the user. Modifying the at least one process thread may comprise generating the at least one process thread as a new process thread. Alternatively or in addition, modifying the at least one process thread may comprise modifying the at least one process thread as an existing process thread. At least one of the process threads may reflect user actions carried out by more than one of the plurality of users.

Abstract: Fluent API Patterns promote balance in managing object persistence. Code which obtains an object-relational mapper session contains API Patterns that manipulate persistence ignorant objects using calls to a fluent interface. When the developer's code executes, it may manipulate an object state, a property state, and/or a persistent relationship of the persistence ignorant object. The code may implement API Patterns such as find-change-save, current-value-original-value, nested-property, incremental-graph-load, incremental-graph-filtered-load, property-modification, dictionary, and/or other API Patterns. Additional examples of API Patterns include an API Pattern to read current, original, and database values for all properties of an entity; an API Pattern to set current and/or original values from another object; and an API Pattern to create a cloned object containing current, original, and/or database values.

Abstract: A method of serialization in a data processing system includes serializing a mutable object utilizing a full serialization process, caching primitive data and metadata regarding the mutable object in binary format in cache and then checking whether primitive fields of the mutable object are modified. Thereafter, the mutable object is again serialized utilizing an abbreviated serialization process by reference to the cached primitive data and metadata if the primitive fields of the object are not modified. In the event that primitive fields of the object are modified, the full serialization process is utilized. Thereafter, the serialized mutable object is communicated to a distributed code element.

Abstract: Object marshaling techniques in a marshaling system for computer networks are disclosed. A gesture is provided to the object marshaling system that a reference object has expired on a sender side and a target side when the reference object is closed. Parent and child relationships are recognized in a descendent reference object to the reference object. The descendent reference object closes when the reference object closes.

Abstract: Various methods and systems for automatically restoring links to a directory service's object when that object is restored from backup are disclosed. One method involves receiving user input selecting an individual directory service object for restoration from backup; restoring the directory service object from the backup; and automatically creating a forward link to the directory service object from a source object. The need to restore the forward link can be detected by either finding the forward link in a copy of the link table within the backup or finding a corresponding backward link in an attribute of a backed-up copy of the directory service object.

Abstract: In one example, a system to integrate a first application with a second application may associate a component type in the first application with an engine object type in the second application. The component type and the engine object type may be program object types. The system may determine a hierarchical structure that includes an engine object of the engine object type from configurable rules that are associated with the component type. The system may initiate a copy of the engine object in the second application in response to receipt of a request to copy a component of the component type in the first application.

Abstract: A method of automatically defining a new class in a class hierarchy includes creating a descendent class that descends from one or more specified ancestor classes; sequentially analyzing each class along each inheritance path from the specified ancestor classes to a specified similar class to identify each class item in each class that is not selected from the specified ancestor classes; storing a respective pointer for each class item identified in each class that is not inherited by the class referencing the class item and associated with the class; storing a respective pointer for each class item identified in each class that is inherited and redefined by the class referencing the class item and being associated with the class if a pointer referencing the class item is not already stored; and copying each class item referenced by a stored pointer to the descendent class.

Abstract: A framework whereby mobile terminals are configured and managed by a central server. In accordance with one aspect of the present invention, there is provided a mobile telecommunications terminal including a first execution environment and a second execution environment, each execution environment being arranged to execute a respective device management agent and each agent issuing, in accordance with instructions from a device management server, management actions that act upon one or more respective management entities running within one or more of the execution environments; wherein the management entities of the second execution environment are grouped into a management structure, the management structure being one of the management entities within the first execution environment, whereby the he first and second execution environments permit the device management server is permitted to manage applications and/or services running within both.

Abstract: Provided is a method, system, and program for providing an object discovery agent (ODA) client. There is one object discovery agent (ODA) client and at least one ODA, wherein each ODA is associated with one application and includes: (i) application programming interfaces (APIs) to communicate with the associated application to discover definition information on objects maintained by the application and (ii) code to communicate with the ODA client. The ODA client communicates with one of the at least one ODA to cause the ODA to gather definition information on at least one object used by one application. The gathered object definition information is provided to an integration server to integrate the object in an environment including heterogeneous objects from different applications.

Abstract: Policy controls for Web service resource objects in a hierarchical resource space are loosely coupled so that policy changes are applied and enforced across the objects. This technique ensures that different policies are not applied unintentionally to the same resource (for example, one at the Web services entry level, and the other at the resource level). By synchronizing the object in the manner described, neither the entity that deploys the application nor the security administrator need to be aware of the differences between the various types of requests that occur within a Web services environment. In a representative embodiment, resource objects are linked within a hierarchical resource space to provide synchronized policy control, where the policy is an audit policy, a quality-of-service (QoS) policy, a service level agreement (SLA) policy, a governance policy, a compliance policy, a patch management/vulnerability management policy, a user management policy, or a rights management policy.

Abstract: A system and method for generating application code and an external interface for a service class, in an enterprise resource planning (ERP) system is provided. The system receives a definition of a service class from a user via a user interface tool. The definition of the service class specifies a query for the service class and operations that are to be enabled for the service class. The system automatically generates application code for the service class, which enables the service class to be used by an internal endpoint of the ERP system. The application code is customizable by the user; the user may add additional operations to the service class. In addition, the system automatically generates an external interface for the service class, which enables the service class to be used by an external endpoint of the ERP system without needing knowledge of the application code.

Abstract: A client connected to a communication network performs an access request to an object. An application server performs an application by an actual object according to the client request. An object pool connected to the client and the application server pools a proxy object corresponding to the actual object and holds the actual object management information. The application server notifies the object pool of an event according to the status change of the application. The object pool automatically updates the actual object management information according to the notification of the event from the application server.

Abstract: A method and system for automated remote submission of jobs to host systems generate a single executable file having a user program specified in a command line. A separate thread is used to submit the single executable file to the host system. The separate thread monitors progress of the single executable file on the host system and posts information associated with the monitored progress of the single executable file.

Abstract: Distributed searches in a casual server network may be provided. First it may be determined, at an originating server, that a first request cannot be fulfilled by information associated with the originating server. Then, from the originating server, the first request may be posted to a distributed request ring. Next, at a remote server on the distributed request ring, the first request may be received. The remote server may then query for current data on a data store associated with the remote server that may satisfy the first request. The remote server may next write a foreign reference in the data store. The foreign reference may indicate that the originating server requested the current data. Next, at the originating server, a response may be received to the first request from the remote server. The response may include the current data.

Abstract: A method for providing stand-in objects, where relationships among objects are automatically resolved in an object oriented relational database model without the necessity of retrieving data from the database until it is needed. A “fault” class is defined, as well as fault objects whose data haven't yet been fetched from the database. An object that's created for the destination of a relationship whenever an object that includes the relationship is fetched from the database. When an object is fetched that has relationships, fault objects are created to “stand-in” for the destination objects of those relationships. Fault objects transform themselves into the actual enterprise objects—and fetch their data—the first time they're accessed. Subsequently, messages sent to the target objects are responded to by the objects themselves.

Abstract: Disclosed are methods and threads for responding to a request to perform an operation on a server object as may be provided in software form within an object request broker (ORB) server library or an ORB server.

Abstract: Described are techniques for communicating between one or more producers and one or more consumers. A first consumer of an event queue registers for notification regarding occurrences of one or more events. A producer of the event queue posts one or more notifications to one or more consumers of the event queue regarding one or more occurrences of one or more events. Each of the consumers receive notification regarding occurrences of events for which the consumer is registered. The first consumer retrieves posted event notifications regarding events for which the first consumer is registered. If the first consumer is executing in user space and an event notification list to which the event notifications for the first consumer are posted is located in shared memory, the first consumer retrieves the posted event notifications without proxying into kernel space.