Abstract: A dependency checking apparatus and method allows checking the version of classes in an object-oriented program to assure the proper version is being used for each release of the software. According to a first preferred embodiment, classes themselves include static code that checks dependencies when the class is loaded. The first embodiment is simple to implement for classes. According to a second preferred embodiment, information relating to version checking is stored separate from the classes and is used to check dependencies. This second embodiment is more flexible, allowing the checking of interfaces as well as classes, and allows the dependency information to be altered without recompiling the classes being checked.

Abstract: An apparatus and method allow using incomplete cached balance sets to be used to generate other cached balanced sets in certain circumstances. If a cached balance set is complete, a new cached balance set can be generated from it by condensing the existing cached balance set. If the cached balance set is incomplete, a new cached balance set can be created from the existing incomplete cached balance set if the query key meets certain criteria and if the existing cached balance set was condensed from the underlying data in the database itself, rather than from a different cached balance set. It is even possible to create a complete cached balance set from an incomplete cached balance set if certain criteria are met. By using both complete and incomplete cached balance sets to retrieve values in response to a query, the performance of the resulting system is significantly enhanced.

Abstract: An object oriented framework for source code processing provides an infrastructure that embodies the steps necessary to process source code and a mechanism to extend the framework to fit a particular scenario for processing source code. Certain core functions are provided by the framework, which interact with extensible functions provided by the framework user. The architecture of the framework allows a developer to select the native processing tool of their choice, and provides an infrastructure for using that processing tool with other platforms (e.g., targets, etc.) The extensible functions allow the processing tools of a new platform to be easily incorporated into the framework. The framework thus allows a programming environment with development on multiple platforms that targets multiple platforms, which may be easily customized to include new platforms and new processing tools.

Abstract: A clocked memory device includes a programming mechanism that allows the write recovery time during a command with auto precharge enabled to be dynamically set to some function of the input clock. In the preferred embodiments, the programming mechanism includes a control register with programmable bits that allows specifying the write recovery time according to the bit values written to the control register. For example, write recovery time could be specified as a whole or fractional number of clock cycles. By specifying the write recovery time as a function of the clock that may be dynamically set, the clocked memory device may be used at its highest performance capabilities over a wide range of operating frequencies.

Abstract: In an object oriented computer system, an object oriented mechanism and method defines a common interface to maintain elements on a collection while providing the capability of using virtually any suitable object as a key to the collection. A programmer defines an interface on a collection that includes suitable object methods for adding, removing, and replacing elements of the collection. The constraints that determine whether elements may be added, removed, or replaced is encapsulated in a policy that is defined by the programmer. The programmer identifies one or more keys, which may include any suitable object in the object oriented system. A maintainer class provides a client interface for maintaining elements on the collection according to the defined policy and according to the keys defined by the programmer.

Abstract: An apparatus and method allow a user to define a dynamically extendible table in a software application, such as a spreadsheet. In one embodiment of the invention, when a new row or column is added next to a dynamically extendible table, the new row or column is automatically added to the definition of the dynamically extendible table. In a second embodiment of the invention, when a new row or column is added to a dynamically extendible table, the user is queried to determine whether the row or column should be added to the dynamically extendible table. In yet another embodiment, a user adds a row or column, then invokes a command to add the row or column to a dynamically extendible table. In one embodiment, once a dynamically extendible table has been updated to include a new row or column, any objects that use the dynamically extendible table as a data source are updated to include the new data.

Abstract: In an object oriented computer system, a framework mechanism defines one or more run-time extensible items that may be dynamically reconfigured as required to support different interfaces at run-time. Each extensible item has one or more adapters that correspond to the extensions owned by the extensible item. The extensible item class defines a castTo( ) method. The castTo( ) method is invoked to logically cast an instance of the extensible item class to a desired class so that a selected method on that class can be called. When the castTo( ) method is invoked on an instance of the extensible item class, the extensible item object determines if any of its extensions have an adapter that supports the class specified in the castTo( ) method call. If an adapter does support the specified class, the adapter corresponding is returned, and the selected method is then invoked on the adapter. In this manner, class casting of run-time extensible items is achieved.

Abstract: A concrete-based building block has an attached wooden attachment layer on one or both exterior surfaces of the block that can receive and hold a penetrating fastener such as a nail, screw, staple, or the like. This allows surficial coverings such as wallboard, siding or other materials to be easily attached to a block wall made of the building blocks. The block includes substantially semi-cylindrical concave portions that form a cross-linked structure of channels when the blocks are assembled into a wall. Once the blocks have been stacked in place in a wall, grout or other suitable filling material is poured into the cross-linked structure of channels. When the filling material hardens, the blocks are locked together. Surficial covering materials may then be nailed, screwed, or stapled directly to the attachment layer of the blocks.

Abstract: A smart passive reference to an object oriented object provides control over creation and deletion of the object it references. A reference count is incremented when an active reference to an object is created, and is decremented when an active reference to the object is deleted. The smart passive reference allows suspending the activity of a thread until no threads have active references to the object. In addition, the smart passive reference can be used to invalidate the smart passive references in other threads, thereby allowing a thread to obtain exclusive access to an object. The smart passive reference also provides an interface to cause the managed object to be deleted when the reference count goes to zero.

Abstract: In an object-oriented or object-based computer system, a compiler mechanism allows a compiler to automatically select among multiple implementations of an object to optimize the performance of the compiled code. The selection may be made by assigning a weighted cost to each of the implementations, and selecting the implementation with the lowest weighted cost, where the weighted cost represents estimates of execution frequencies for each of the object's functions. In the alternative, for implementations that have different interfaces, the selection may be made based on an evaluation of the functions used in the program compared to the functions provided by the different implementations, and selecting an implementation that contains all functions issued against the object with a minimum of functions that are not issued against the object.

Abstract: A computer system on a network uses IP multicast to recruit other computer stems to share in the processing of a job. If a computer system on the network wants to be available to process shared jobs, it first registers for job sharing by invoking an IP multicast router at a particular IP address. All messages sent to the IP multicast router are broadcast to all computer systems that are registered with the router. When a computer system has ajob to share, it recruits other computer systems to help process the job by sending a message to the IP multicast router that corresponds to a request to share the job. The candidate computer systems that receive the recruiter's broadcast determine if they can share the job according to one or more job sharing parameters. These parameters may relate to the job itself, network performance, security, or other criteria for sharing. If a computer system meets the parameters for taking on the particular job, it responds to the recruiter.

Abstract: An apparatus and method for testing object oriented software includes a software test framework that includes one or more test drivers and one or more testcases for each test driver. Each testcase can also have multiple variations. A TestDriver abstract class and a Testcase class are defined. Each test driver is created as an extension of the TestDriver class, and each testcase is created as an extension of the Testcase class, thereby promoting uniformity between different test drivers and between different test cases. When an instance of the TestDriver class is run, it instantiates its testcases, determines which variations of the testcases should be run, runs the variations, and reports the results. By providing the software test framework in the same programming environment in which the software under test is developed, the application programmer can program the needed tests without requiring the specialized skills of a test programmer.

Abstract: An access mechanism and method for accessing objects in a distributed object system manages object accesses and causes all accesses within one transaction to be to either the home object or the local copy, whichever is accessed first. When an object is accessed for the first time in a given transaction, the requested access is granted. For example, if home access is requested to an object in a different process, a proxy is created to access the object in its home location. When the object is subsequently accessed within the same transaction, the access mechanism ensures that the same access is used to assure that changes are not being made to a home object and a local copy or to more than one local copy simultaneously. In an alternative embodiment an exception may be generated if the requested access cannot be provided.

Abstract: An apparatus and method for creating packages and for transferring packages between computer systems provides a graphical user interface that allows a user to define various attributes for a package. Logical packages may be defined, which specify package elements to include in the package. Physical packages may also be defined, which contain a copy of the package elements specified in the logical package. Once a user defines a logical package, the logical package may be transferred to an endpoint system. The endpoint system reads the logical package, and from the parameters in the logical package determines where to retrieve the package elements and what other actions are appropriate while retrieving the package elements and constructing a physical package. In this manner, the endpoint system retrieves the package elements as required. The preferred embodiment of the present invention defines a packager using an object oriented framework mechanism that defines both core and extensible functions.

Abstract: An object oriented computer apparatus and method provides a graphical user interface (GUI) for existing host-based (i.e., green screen) applications by defining some object oriented classes that reside on the client workstation, and by substituting function calls for display data in the green screen application with function calls that interface with the object oriented GUI defined by the classes. In this manner the present invention takes advantage of the processing power of client workstations in a network computing environment by having the client run the GUI. The underlying green screen application is modified to replace all display function calls with new function calls to the GUI, but this change is relatively minor and does not affect the underlying core logic of the application. In addition, the new function calls access the GUI screens directly without having to determine which screen is being displayed.

Abstract: A specification language allows a user to define platform-independent user interface panels without detailed knowledge of complex computer programming languages. The specification language is referred to herein as a Panel Definition Markup Language (PDML), which defines tags that are used in similar fashion to those defined in Hypertext Markup Language (HTML), that allow a user to specify the exact location of components displayed in the panel. A graphical editor allows the creation and modification of platform-independent user interface panels without programming directly in the specification language. A conversion tool may be used to convert platform-specific user interface panels to corresponding platform-independent user interface panels. A help generator tool also facilitates the generation of context-sensitive help for a user interface panel.

Abstract: A tool referred to herein as an archive maker operates on one or more existing archive files that contain multiple object oriented classes to generate one or more new archive files. The archive maker takes a list of required classes, analyzes those classes in one or more existing archive files to determine any classes upon which they depend, and creates a new archive file with all the required and dependent classes. This allows the classes that are not required to be stripped out of the archive file. The archive maker may also be used to partition an existing archive file into multiple new archive files according to one or more partition criteria. In addition, the archive maker may be used to consolidate multiple existing archive files into a single new archive file.

Abstract: A model view controller has a model and a view with one or more listeners, and each listener may register with the model when the listener desires to be notified of a change of state in the model. In the preferred embodiment, when the model is about to change its state, it notifies all registered listeners, and after the model has changed its state, it notifies all registered listeners again. The present invention thus allows the model to notify the view when the state of the model changes, and the view can then decide what actions to perform, such as suitable indications to the user of the model state. The present invention thus achieves efficient user notification of the state of the model within the constraints of the model view controller paradigm.

Abstract: In an object oriented computer system, a framework mechanism defines a mechanism that separates the ability to complete a process from the results of that process. A task is defined in the framework in terms of a sequence of processes. The framework includes a coupling mechanism for flexibly coupling any of these processes together in any suitable order to define the run-time behavior of the framework without changing the core functions of the framework. The coupling mechanism includes the definition of a processable interface and a processing interface. A particular process generally takes detail information as input and produces detail information that is used in a subsequent process. The detail information input into a process is said to be “processable”, and therefore implements the “processable” interface. The detail information output from a process is said to be “processing” detail that is output to the next process, and therefore implements the processing interface.