61 results about "Object oriented applications" patented technology

A graphical user interface on a computer system is provided for displaying objects in an object-oriented application and data stored in tables of a database. The graphical user interface displays a class view corresponding to one or more classes in the object-oriented application that in turn corresponds to tables in the database and displays a table view having one or more tables in a database corresponding to classes in the object-oriented application. In addition, the graphical user interface also displays a combination table-and-class view having database elements from the database adjacent to the object-oriented elements from the object-oriented application.

A method, apparatus, and article of manufacture for generating class specifications for an object-oriented application that accesses a hierarchical database. The class specifications are generated using a command line interface of a class definition tool. A database description and a record layout associated with the hierarchical database are captured and associated to define a specification for the database. Class definitions are then generated from the database specification, wherein the class definitions are instantiated as objects in the objects framework that encapsulate data retrieved from the database.

A distributed fabrication system for creating, while promoting strategic alignment between information technology departments and business units' objectives, a business application compatible with XInternet technologies via a communication network. The distributed fabrication system supported by an applicative framework system supplying a generic dynamically adaptable N-Tier client-server object-oriented applicative infrastructure constructed on top of a third party software system infrastructure to support a business application compatible with XInternet technologies via a communication network, the third party software system infrastructure being complemented by database management system components.

A “helpHelper” bean is attached (using the VisualAge visual editor) to a panel for which help is to be provided. The custom editor for the helpHelper bean brings up the target panel, along with a help editor panel that shows which component of the target panel is selected, allowing help for that part to be assigned. At run time, the helpHelper bean listens to which part of the panel is selected, and brings up the help for that part when it is requested (if F9 is hit). The runtime help can also operate in “hover” mode. This offers a very simple and convenient way to add the help for the panel, and it also makes delivery of the help an integral part of the application, so that it does not require anything apart from the Java code to display the help.

It is desirable for software developers to be able to conveniently obtain feedback from users of applications. It is known for developers and others to use code instrumentation for gathering various types of data relating to applications and their uses. The use of compile time instrumentation may be practical for some situations but it has significant drawbacks when used to provide indications of user interaction with applications. The present invention relates to the use of run time instrumentation for providing feedback from users of object oriented applications where the applications have unique object identifiers and support dynamic data exchange. The invention utilizes a setup software tool to create a monitor input file which indicates which objects of the application should be monitored when a user interacts with them.

An object-oriented design program provides is configured to instantly render in a three-dimensional interface user CAD designs received as CAD-based design elements (e.g., CAD blocks or lines). The object-oriented program renders the user CAD designs regardless of whether the user designs are practical, or use finishes or colors that are in-stock for the selected design elements. In addition, the object-oriented program can also create intelligent software objects for the CAD-based elements at a later time, upon request by the user. The intelligent software objects can be configured to automatically resolve themselves in view of one or more system limitations and rules in related components, and to replicate any such resolution back to the CAD-based blocks if desired. Thus, a user can have the benefits of instant 3D rendering of CAD drawings with or without the automatic resolution provided by intelligent software objects, depending on the situation.

The present invention is capable of accurately extracting multiple applications with respect to a class library. The invention relies on a configuration file for an application program and / or library, which describes how program components in the program / library should be preserved under specified conditions. The invention may be used in application extraction tools, and in tools that aim at enhancing performance using whole-program optimizations. The invention may be used as an optimization to reduce application size by eliminating unreachable methods. In the alternative, the invention may be used as a basis for optimizations that reduce execution time (e.g., by means of call devirtualization), and as a basis for tools for program understanding and debugging.

A low overhead method for identifying memory leaks is provided. The low overhead method includes a) detecting completion of a garbage collection cycle; and b) identifying a boundary between used objects in memory and free memory space. The steps of a) and b) are repeated and then it is determined if there is an existing memory leak based upon evaluation of boundary identifiers. A computer readable media and a system for identifying memory leaks for an object-oriented application are also provided.

Embodiments of a system and method for transactional memory (TM) with automatic object versioning are described. Embodiments described herein include a TM system and method that facilitates the execution of object-oriented application programs in a transactional environment, including automatically versioning objects to enhance efficiency. Embodiments of the TM automatically designate versions of objects using pointers, accurately identifying usable and unusable versions. Object versioning as described herein allows the garbage collector to easily and efficiently determine which objects may be moved, freeing memory space and reducing the number of objects traversed by a transaction before finding a useable version of an object. Other embodiments are described and claimed.

An improved source-level debugger for object-oriented application programs which may include linked native language dynamic load libraries. The debugger is compatible with the Java Platform Debugger Architecture (JDPA), and provides new capabilities such as patching of Java variables and reading and writing strings from and to the application under test and being run by a local or remote Java Virtual Machine.

A mobile information device may execute a Java MIDlet or a non-MIDlet application. The mobile information device may further include an object-oriented application program interface that allows one or more object-oriented object classes to allow input and output data to be communicated between Java MIDlets in different MIDlet Suites and between non-MIDlet applications. The application program interface may be used to allow applications to access a universal message handler executing on the mobile information device.

A mobile information device may execute a Java MIDlet or a non-MIDlet application. The mobile information device may further include an object-oriented application program interface that allows one or more object-oriented object classes to allow input and output data to be communicated between Java MIDlets in different MIDlet Suites and between non-MIDlet applications. The application program interface may be used to push launch applications with context on the mobile information device.

The invention is directed to a method of replacing code in an object oriented application program running on a Virtual Machine (VM). The method comprises the steps of receiving at the virtual machine a request to replace code; in response to receipt of said request, examining each thread's call stack to determine if any thread includes a method that will be made obsolete by a proposed code replacement; and, if it is determined that there are no threads that include such a method in their call stacks, performing the code replacement. However, for a thread whose call stack is determined to include a method that will be made obsolete by the proposed code replacement, the method includes the step of allowing the thread to continue running until the thread unwinds past that method in its call stack and then suspending said thread. This comprises a part of a process of determining a safe state for code replacement. The invention is also directed to a method of initializing new variables in such replacement code. The variable initialization method comprises the steps of identifying the replaced code and prior to resuming threads containing the replacement code, initializing new variables in the replacement code to values consistent with the application semantics.

A method and structure for allowing object-oriented applications to create and configure caches for the objects used is disclosed. The method and structure use a general purpose cache integrated with object factories that provide the objects used by the application. The object factory can store objects in cache so that application requests for objects are returned in a fast and transparent manner to the calling application. A particular cache may support one or more object factories. The object factory that provides access to a cache is a specialized type of object factory, called a cacheable factory. The cacheable factory contains methods for adding, removing, and accessing objects in the cache associated with the cacheable factory object.

The universal, Web browser-based Enterprise JavaBean (EJB) test client is itself a Java 2 Enterprise Edition (J2EE) application packaged in a Web archive file. This archive, when extracted, consists of a set of files that are installed on a target application server. The installation makes it possible for a user of a Web browser on a workstation remote from the application server to perform a number of tests on, and invoke, methods in EJB beans that are installed on the staging, or even production, servers. It is also possible to perform tests in real time under real conditions.

A method of providing persistency for an object (O) to be a persistent object, in an object oriented application, comprising the steps of associating (102) a proxy object (PO) with said object (O), creating (103) a persistent object representation (111) of said object in a persistent data store (112), receiving a message (105), sent by a client object (CO) to said object (O), by said proxy object (PO), forwarding (107) said message to said persistent object by said proxy object (PO), receiving (108) a result of said forwarded message from said persistent object by said proxy object (PO), updating (109) said persistent object representation (111) by said proxy object (PO), and returning (110) said result of said message to said client object (CO) by said proxy object (PO).

An effective memory management method and device in an object-oriented application are provided. The memory management method in an object-oriented application includes: receiving a signal requesting allocation of a memory area to an object; receiving information on the object-oriented application including the object from an application manager; allocating a memory area to the object; and storing the information on the application and position information of the memory area allocated to the object.

A method and system for processing a text file in a computer application. The method comprises the steps of forming a template from fragments of the text file; using the template as an overlay for parsing incoming files, or as a prototype to generate a segment of an output file; and using a macro class to map data from the text file to an application. The macro class is embedded as a keyword within the template, so that when the template reaches the keyword, the template calls the macro class to further process the text file. The macro class may be used to reads in a segment of the text file and to use the segment to initiate application update processing. Also, the macro class may be used to derive data from the application and to format it into the text file. Preferably, an interface controller is provided to prevent structure clashes by placing text data into appropriate places in a complex object structure as the text file is processed.

An apparatus for enabling an object-oriented application to access in an object-oriented manner a procedural operating system having a native procedural interface is disclosed. The apparatus includes a computer and a memory component in the computer. A code library is stored in the memory component. The code library includes computer program logic implementing an object-oriented class library. The object-oriented class library comprises related object-oriented classes for enabling the application to access in an object-oriented manner services provided by the operating system. The object-oriented classes include methods for accessing the operating system services using procedural function calls compatible with the native procedural interface of the operating system. The computer processes object-oriented statements contained in the application and defined by the class library by executing methods from the class library corresponding to the object-oriented statements.

A managed class peer networking framework and associated object-oriented application programming interfaces are presented. An application uses the framework API to communicate with the various peer networking subsystem interfaces. These subsystems utilize lower level Win32 interfaces and services to provide access to the group database, security, and data transfer to other machines. Managed classes are provided for the peer name, identity, cloud, invitation, group, policy, data store, peer and record collections, peer, and record classes. Peer name resolution objects and record search objects are also provided. The peer networking framework of the present invention is particularly applicable to Microsoft's .NET Framework.

Systems and methods for relating network elements to customers in a communications network using an object-oriented relational structure. The present invention is directed to systems and methods for relating network elements to customers in a communications network using an object-oriented relational structure. According to one embodiment, the object-oriented system, for relating network elements to a customer or for relating a customer to the network elements, includes a network element data module containing network element data arranged in a form that can be manipulated using an object-oriented application; a customer data module; and a mapping module in communication with the network element data module and the customer data module for creating an object-oriented model of the network elements. The output of the mapping module comprises a plurality of sub-tree layers wherein each layer represents a layer of abstraction, and wherein a root represents the highest sub-tree layer and the highest level of abstraction and a plurality of unique customer identifiers assigned to network elements that relate the customer to certain network elements.

A store of interfaced software objects are distributed between a server computer and multiple client computers to support an object oriented application communication environment that provides communication between software applications on each client computer. The application communication environment may include a central shared object store of interfaced software objects that operate on a server computer and communicate with one or more software applications on the server computer. A local shared object store of interfaced software objects operates on each client computer and communicates with the central shared object store and one or more software applications on that client computer. Changes to interfaced software objects in the local shared object stores may be automatically propagated to the interfaced software objects in the central shared object store. A local private object store of interfaced software objects may operate on a client computer and communicate with one or more software applications on the client computer.

Implementations of the present invention allow a user to work within a record-based design environment while achieving the advantages provided by an object-oriented database. In particular, the user of components in accordance with the present invention can create designs within a record-based application program, within an object-oriented application program, or within a third application program linked by the object-oriented program, and still have the graphical representation thereof visibly displayed in the record-based application program.

A method and structure for an independent programming tool for analyzing business separations-of-duties conflicts for users and profiles in an object-oriented application, the tool including a database containing a matrix of transactions, descriptions, object authorization values, and transactional separations-of-duties conflicts; an analysis engine adapted to use data from the object-oriented application in conjunction with the matrix to analyze business conflicts and produce separations-of-duties conflict reports about the object-oriented application; and a user interface adapted to control the tool.