Abstract:
A language processing environment provides facilities for defining and using handle classes. A handle class is a class that always and only exists as a handle to stored data, yet that data is accessed in the same manner as with non-handle classes. The language processing environment provides syntax such that all values in the language are members of some class and all classes are defined using the same syntax. Methods and properties are supported on both handle and non-handle classes.
Abstract:
An improved method and system for developing a reinsurance administration system. Developers may build application programs for reinsurance administration with increased re-use of existing functionality and decreased development time. A business process framework may include common functionality for a plurality of business processes. and a template for executing steps in the business processes. The business processes may be combined to build one or more application programs. A multi-dimensional reinsurance contract framework may permit the handling of various dimensions of a reinsurrance contract such as handling different version of the reinsurance contract (e.g., yearly periods), handling multi-level specialization hierarchy (e.g., different conditions for different sections of the reinsurance contract, handling the change of conditions within a period, and processing inheritance of contracted structure and conditions from an abstract or master reissue contract An object-oriented condition component framework may represent a condition dimension of a reinsurance contract. The condition component framework may permit the addition and/or modification of condition components of the reinsurance contract.
Abstract:
The loading or operation of a specialized class may trigger the specialization of other classes. A compiler may be configured to recognize dependency relationships between generic classes and to describe the classes in terms of the type variables of the triggering types (e.g., the types and/or type parameterizations) that trigger the specialization of classes based on the specialization of a first class. A compiler may include information, such as structural references, indicating dependency relationships between classes when generating class files. Thus, the class file may include information indicating that a class extends a class resulting from applying a specialization code generator to an argument. Loading a first class may trigger the loading of a second class described by a structural description such that a specializer (and/or class loader) may apply the structural description to generate and load the second class for the particular parameterization.
Abstract:
A method and system for instructing a computer in a system of a declarative computer programming language. Unlike traditional declarative languages, the programming language may be neither relational nor functional, neither procedural nor imperative. The declarative programming elements may be defined as a meta-description of logic and data. The basic morphology of this meta-description may be a data construct known as a Lattice (100, 110, 150). Lattices derive declarative power from their inclusion of "Attributes" (130) and "Sites" (120). Attributes are declarative properties that determine the internal behavior of a Lattice; while Sites (120) are declarative data access points that establish the external relationship a Lattice may have with other Lattices, Lattice Containers (150), and Lattice Elements. Each of these data constructs are highly adaptable, recursive, and expandable, providing the entire language with a degree of flexibility that facilitates a very high level of abstraction.
Abstract:
A method and a device for component expansion are provided, which relate to the field of software development, can avoid additional upgrade script development during upgrading an underlying component, and eliminate the coupling and relevance modification of an upper component and the underlying component. The method comprises: obtaining the description file of each component loaded in the process of software system starting; analyzing the description file of each component, and obtaining the expansion identification information of the profile of each component; loading the profiles belonging to the same base class to the memory according to the base class identification in the expansion identification information and combining them to get an expanded profile. The technical solution is mainly used in the process of component expansion.
Abstract:
A method, computer program and system for generating an editor to be executed through a graphical user interface of a computer, for editing the persistent data of an application, said persistent data being described and stored in a data object model using a modeling language defining a hierarchical organization of classes, their attributes and the relations between classes, said method comprising the steps of retrieving the root class and starting from the root class, creating a page per class for creating the instances of the class. Each page of a current class comprises an Edit section for editing the attributes of the class, a Table section which lists all the instances of the class when they will be created and an Hyperlink section for listing pointers to the other pages corresponding to the target classes in relation with the current class. The user of the editor, navigating in the pages with the use of the Hyperlink section pointers, will be able to instantiate all the classes of the model.
Abstract:
A technique is described that allows a software client to create at run-time a software object that appears to extend or alter the functionality of an existing software class definition. For example, a decorator factory generates a proxy object that dynamically implements a set of interfaces specified by the software client at runtime. From the perspective of the client, the proxy object is logically a child object of the original existing base object. The child object appears to be enhanced by the methods and attributes defined by the set of interfaces and the methods implemented by the delegate object. However, the proxy object does not have actual parent classes. Instead, an invocation transparently intercepts method invocations from the client to the proxy object and invokes the appropriate method, regardless of whether the method is implemented in the base object, the delegate object, or within the proxy object itself.
Abstract:
Method and system for interface checking and interface method dispatching for wireless devices. Relationships between classes and objectoriented interfaces are analyzed and certain properties are exploited for use in performing interface checking and/or interface method dispatching.
Abstract:
An object-oriented component data structure and method of reconstructing, extending, assembling and modifying software components. The inventive component data structure provides a complete definition of a component including its identity (66), state (68), behavior (70) and containment (72) of other components, which are recursively nested instances of the inventive component data structure. The inventive component data structure supports inheritance, such that the definition of a component inherits from the definition of another component; contained component data structures likewise support inheritance. Moreover, the inventive component data structure and resulting software components are compatible with the Java Virtual Machine (JVM), Java Class File, Java Byte Code, JavaBean, and CORBA specifications. The inventive component data structure and method are particularly well suited for providing tools for software development, trouble-shooting and systems integration. Furthermore, the inventive component data structure minimizes the need for manual changes with respect to customized and localized software components when component revisions are made.
Abstract:
A method and apparatus are provided for extending the behavior and attributes of applications designed using a fourth generation language (4GL) programming tool. Specifically, a 4GL programming tool is provided that allows application designers to specify the implementation classes of the components that are used in the applications that they design using the 4GL programming tool. The implementation classes thus specified may define attributes and behaviors not supported by the corresponding component implementations provided with the 4GL programming tool. During runtime, methods in the specified implementation classes are invoked. To correctly invoke the methods of user-specified implementation classes, the interfaces of the methods must be known to the entity performing the invocations. Therefore, according to one aspect of the invention, all component implementations that are to be used by the application, including both the "standard" component implementations provided with the 4GL programming tool and the "custom" component implementations specified by the application designer, implement a common interface.