International Business Machines Corporation

Digi International Inc.

Steven Lester Halter

Steven Jay Munroe

Scott N Gerard

Erik Edward Voldal

Jeffrey Michael Ryan

Adam D Dirstine

Pamela A Wright

David J Hutchison

John Clarence Endicott

Xin Xu

Timothy James Graser

Paul Brian Monday

Christopher Glen Popp

Charles H Gordon

Robert Eugene Westland

A wireless mesh network server is operable to receive a message to one or more mesh network nodes from a client external to the mesh network, the message comprising an alias identifying the one or more mesh network nodes. The server is further operable to identify the one or more receiving mesh network nodes by the received message alias via an alias table, and forward the received message to the one or more mesh network nodes identified by the alias.

Mesh network bridge routing

An embedded processor system includes an integrated development environment and an embedded processor operating system. The embedded processor operating system is operable to run on the embedded processor system, and a command queue is operable to receive commands from a debugging module external to the embedded processor system. A command queue processing module is operable to change settings in the embedded processor system in response to commands in the command queue.

Embedded device program debug control

Apparatus, methods, and systems are disclosed to manage memory in an embedded system. The system registers video applications and video sources with a memory manager. The memory manager in turn provides memory to the video applications and video sources. The system has an input to receive an output from at least one video source. The memory manager receives a frame from the video source and transfers the frame to memory. Once the frame is in memory the video application may work with the frame. All of these operations are conducted with the memory manager actively managing and allocating the memory resources.

Video memory quality of service

A markup language file comprises software build options usable to determine at least one software build configuration setting. One or more software build options are specified in a markup language file to specify one or more software build configuration settings for use in compilation of software. The markup language is an XML file, is editable in an Integrated Development Environment such as via a Graphical User Interface, and includes settings specific to an embedded processor system configuration.

XML board support customization

In an object-oriented computer system, one or more run-time extensible items may be dynamically reconfigured as required to support different interfaces at run-time via one or more extensions owned by the extensible item. When an invokeMethod( ) method on an extensible item is invoked, specifying the method name, the extensible item cycles through its extensions, from newest to oldest, looking for an extension that supports the named method. Each extension determines whether a method table exists that corresponds to the extension class. If not, a method table corresponding to the extension class is created. When an extension is found that supports the named method, a method node that corresponds to the named method is returned. The method node then invokes the named method on the extension.

Implementation for an object oriented run-time extensible item

A preferred embodiment of the present invention provides an improved system and method for object persistence. The preferred embodiment facilitates the creation of persistent objects in a way that is orthogonal to class and does not require the use of persistent mixin classes. The preferred embodiment uses reference objects, which to the view of the system act as the object itself, and storage objects which persistently store the data for the persistent objets. The reference objects include pointers to the storage object, and provide address translation and indirection when accesses are to be made to the persistent object data stored in the storage object.

Method and apparatus for object persistence

The present invention utilizes a hardware Window Storage Protection Controller (WSPC) and an Object Encapsulation Enforcement Manager (OEEM) to limit access to object data to only those methods which are encapsulated by the object All of the objects of the computer system which require protection are stored in protected storage by a base storage protection mechanism so that only the mechanisms of the present invention can deny or permit access to the data encapsulated by the objects.

Object encapsulation protection apparatus

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.

Apparatus and method for checking dependencies among classes in an object-oriented program

A method and apparatus for providing persistence in a Java environment is provided. The method and apparatus provide object persistence in way that can be adapted for use in a wide variety of situations. In accordance with the preferred embodiment a StoragePlugin class is defined which includes the methods needed to provide orthogonal persistence in the Java environment. StoragePlugin objects are then instantiated as needed from the StoragePlugin class. Each StoragePlugin object implements the defined methods in a way that is compatible with a particular persistent storage system that is to be used (i.e., a particular hardware and database system).

Persistence mechanism and method for objects

In an object oriented computer system, one or more run-time extensible items are defined that may be dynamically reconfigured as required to support different interfaces at run-time. The behavior associated with these interfaces is supported by one or more extensions owned by the extensible item. Each extension class has a corresponding method table that is shared among instances of the extension class and that correlates the methods defined on the extension class to method node objects that carry out the method. A method repository is a static object that is created at run-time to correlate extensions to their corresponding method tables. When a client invokes an invokeMethod( ) method on an extensible item, specifying the name of the method to be invoked, the extensible item cycles through its extensions, from newest to oldest, looking for an extension that supports the named method. Each extension examines the method repository to see if the method repository contains a method table corresponding to the extension class. If not, a method table corresponding to the extension class is created and placed in the method repository. When an extension is found that supports the named method, a method node that corresponds to the named method is returned. The method node then invokes the named method on the extension.

The present invention provides an object-oriented disabling mechanism which selectively disables object methods. The object-oriented disabling mechanism prevents the selected methods from being called on an object by other programs or processes via various alternative embodiments. A first preferred embodiment of the object-oriented disabling mechanism works in conjunction with a plurality of method tables to restrict method calls on an object. An alternative preferred embodiment of the object oriented disabling mechanism works in conjunction with a read flag and a write flag to define which methods can be called on an object. Another alternative preferred embodiment of the object oriented disabling mechanism uses software &ldquo;locks&rdquo; and a lock conflict matrix associated with the object to determine which methods can be called on an object. A final alternative preferred embodiment of the object oriented disabling mechanism uses a transactional mechanism to commit or rollback changes made to an object as a result of method calls.

Apparatus and method for disabling methods called on an object

The present invention provides a method and apparatus for versioning persistent objects which updates the version of a persistent object by splitting the persistent object up into two sections, a header section and a data section. The header section has a data pointer to the data section. The header section determines the object identity of the persistent object and always remains in place. Since the header section of the object always remains intact, the object identity of the persistent object never changes. When updating the version of the persistent object, the persistent object versioning mechanism simply updates the pointer in the header section of the object to reference a newly created data section. Once the persistent object versioning mechanism updates the data pointer to reference the new data section, existing objects can reference the new version of the persistent object using the original object identity of the persistent object.

Apparatus and method for versioning persistent objects

According to the present invention, an apparatus and method for providing access to multiple object versions allows the system administrators to control which version of a given object is referenced by existing related objects. By providing an option for the system user to select and access different object versions, object upgrade policies can be flexible and accommodate the various needs of different object-oriented systems. The object versioning mechanism of the present invention provides several different options when modifying an existing object to create a new version. The various embodiments of the present invention provide a versioning mechanism to manage version updates for objects in an object-oriented system. The versioning mechanism disclosed herein implements the methods of the present invention by making a copy of an existing object whenever a new version of the existing object is to be introduced into an object-oriented system. After the copy of the existing object has been made, the existing object or the copy of the existing object can be modified to reflect the desired changes and to provide an updated version of the object. Whether the existing object or the copy of the existing object is modified depends on the specific system policy or objectives to be achieved. In addition, according to the desired system policy, the unmodified version of the object can be removed from the system, if desired. Alternatively, if both objects remain in the system, access to one or both of the objects may be further restricted by disabling all or at least some of the methods on the objects.

Apparatus and method for providing access to multiple object versions

According to the present invention, an object change manager includes methods afterCreation( ), beforeDeletion( ), beforeChange( ) and afterChange( ) that may be invoked when an object is changed. The object change manager automatically updates all data structures, such as indexes and has tables, that correspond to the object being changed when one of these methods is called. The object change manager is an extensible framework that allows a programmer to define custom change management environments. The object change manager of the preferred embodiments is a portion of code that automatically propagates changes to objects to their corresponding data structures in a way that is transparent to the programmer, without requiring excessive overhead in the object infrastructure code.

Apparatus and method for automatically propagating a change made to at least one of a plurality of objects to at least one data structure containing data relating to the plurality of objects

The method maintenance mechanism of the present invention is comprised of two submechanisms, a method update mechanism and a method call manager. The method update mechanism is used to make changes to existing methods. The method call manger manages calls to methods in a way that allows active programs to continue to use old versions of methods while at the same time providing access to new method versions when programs are reactivated or activated for the first time.

Growing community of inventors

Rochester, MN, United States of America

Steven Lester Halter