International Business Machines Corporation

I-Shin Andy Wang

Frederick Thomas Sharp

Judianto Sidik

John Shek-Luen Ng

Rita S Wu

Mir Hamid Pirahesh

Josephine Miu Cheng

Jyh-Herng Chow

Jy-Jine James Lin

Roni Korenshtein

HongHai Shen

Thanh Tan Pham

Shu-Huar Joseph Yeh

Kuo-Wei Hwang

John Luen Ng

Kenneth Carlin Nelson

Tawei Hu

David Mun-Hien Choy

Lily Liang

Mayank Vipin Shah

Kehsing J Chou

Howard Hao Zhang

Edward Joseph Perry

Gerald Herman Roth

Chin Hsiang Li

Wei Young

Tak-Ming Lo

Shu Huar Yeh

David Y Chen

Sudipta Deb Deb

Tak Ming Lo

Disclosed is a system, method, and program for generating an interface to elements in a document. The document defines a relationship of the elements and at least one attribute for each element. A class is generated for at least one element to implement methods from information provided on elements in the document and a mapping indicating at least one element in the document to map to a class. The at least one indicated element in the document for which the class is generated can be accessed and affected by the methods implemented in the class.

Method, system, and program for interfacing with elements in a document

A content management system provides versioning capability that can either be controlled by the client application or be transparent thereto. Control of document versions depends on the root and child component attributes that are defined by the hierarchical structure of the document. When a document is updated, the present system performs any or all of the following scenarios as desired by the user: replace the existing attribute values stored in the root component instance for a specified document; replace the existing attribute values stored in a specified child component instance for the specified document; add a new child component instance into the hierarchical structure for the specified document; or delete an existing child component instance from the hierarchical structure for the specified document.

System and method for item versioning in a content mangement system

A method, apparatus, and article of manufacture for a computer implemented modification system for supporting localized data changes in a computer. A change is executed to data in a computer having a local database. The change is performed by the computer to modify data in the local database stored within a data storage device at the computer. The change is indicated as being global. When the local database on the computer is synchronized with a main database on another computer, only global changes are transmitted from the local database to the main database.

Modification system for supporting localized data changes in a mobile device

The present invention discloses a method, apparatus, and article of manufacture for tracking and propagating state changes in a message-driven computer program. In accordance with the present invention, a program in the memory of a computer receives a notification signal indicating that an event has occurred and transitions a first component from a current state to a new state based on the notification signal, wherein the states are represented by discrete objects or components. The computer program propagates, to a second component subordinate to a first component representing the new state, a signal indicating the new state of the first component.

Tracking and propagating updates to a message-driven system of interdependent components

The present invention discloses a method, apparatus, and article of manufacture for generating a database application. In accordance with the present invention, a features list is built for the database application. The features list contains user-selected functions. The database application is dynamically configured based on the built features list.

Generating small footprint applications for mobile devices

A method, apparatus and article of manufacture for a universal calling interface for executing a stored procedure in a computer. Parameter information is retrieved from a database catalog and the computer performs type checking against the user-entered parameters. If there is not a type mismatch then the computer executes the stored procedure without the user entering information about the parameters such as address and type.

Stored procedure universal calling interface

A method and apparatus for generating a Common Gateway Interface (CGI) adaptor customized for a stored procedure. In accordance with the present invention, stored procedure application developers can provides their stored procedure to a builder, which creates a CGI adaptor customized for the stored procedure. To generate the CGI adaptor, the builder parses the stored procedure to identify the arguments of the stored procedure. Then, using the stored procedure arguments, the builder generates logic to extract variables from an input data stream, wherein the variables correspond to the arguments of the stored procedure. The builder also generates logic to invoke the stored procedure using the variables extracted from the input data stream. The generated logic comprises the customized CGI adaptor.

Generating a common gateway interface adaptor customized for a stored

A method, apparatus, and article of manufacture for passing a VisualBasic array argument to an SQL stored procedure executed by a computer. The VisualBasic array is first created in the memory of the computer and comprises an object. The array is then passed to a C or C++ function in the memory of the computer. The function to which the array is passed is declared as an alias for another function within VisualBasic. Execution of the function by the computer returns a handle for the passed array. Finally, the handle is passed to the SQL stored procedure in the memory of the computer, and is accessed by the stored procedure during execution by the computer.

Passing arrays to stored procedures

The present invention discloses a method, apparatus, and article of manufacture for providing object tracking capabilities in object-oriented programming environments using a tracker class and associated functions, and a memory for storing tracker objects. The tracker class, once defined as a base class of any target class that needs the tracking capability, automatically tracks all the objects instantiated from the target class in a linked list. Objects instantiated from classes derived from the tracker class are automatically tracked when the target objects are initialized, be it on a heap or on a stack, because the constructor of the tracker class is invoked by the constructor of the target class. The tracker class is defined as a template, so that it can be applied to any type of target object.

Tracker class for object-oriented programming environments

Generating a common gateway interface adapter customized for a stored

The present invention is a computer program product to avoid static variable initialization and reference conflicts in a multi-threaded computer system. There are four major problems that arise with computer programs containing static variable references and static variable initializations on a computer system with a multi-threaded operating system: (1) premature references made on an uninitialized static variable; (2) side effects caused by initialization competition among threads; (3) multiple initialization of the same static variable; and (4) server control of static variable reference and initialization. Each of these four problems is eliminated by the system and method of this invention. The invention operates by locking the CPU during identification of the first thread seeking to initiate a static variable operation, maintaining all other threads in a wait state, and unlocking the CPU thus releasing the waiting threads from their wait state. Another component of the invention provides an additional control mechanism to invoke the disclosed static variable controller to eliminate potential static variable conflicts among competing threads.

Computer program product for synchronizing static variable

A system and method for translating source code, comprising high level source code with embedded SQL statements, to p-code or machine-language instructions by a one-pass parsing mechanism. The one-pass parsing mechanism generates executable code without the need to generate an intermediate file. Additionally, the p-code or machine-language instructions are annotated with references to the line numbers of the corresponding source code, thereby allowing a source level debugger to debug the source code with embedded SQL statements.

No preprocessor and a source level debugger for embedded SQL in a 3GL

Described herein is a system and method for enabling an application to pass a structure containing a pointer member to an external entity, wherein the application represents a computer program executing in a computer system, and the computer program is written in a computer programming language that does not support pointers. The application declares a variable V, a structure type having a member P, and a variable M of the structure type. The application invokes a function written in a computer programming language that supports pointers. A reference to the variable V is passed to the function. The function, when executed, obtains and returns an address of the variable V. The application sets the member P in the variable M equal to the address of the variable V. The application then passes the variable M to an external entity. In this manner, the present invention enables a structure having a pointer embedded therein to be passed to the external entity.

System and method for enabling pointers to be passed from computer

The present invention discloses a method, apparatus, and article of manufacture for creating a universal pointer object capable of pointing to member functions having any type and belonging to any class creating. More specifically, the present invention provides a computer-implemented method for creating a universal pointer object having a first data member holding a pointer to a member function. To create and initialize the universal pointer object, a universal pointer object is first created in a memory of a computer. The member function is then stored in the first data member of the universal pointer object using the constructor function of the universal pointer class, wherein the member function pointer is stored in the first data member according to the type of the member function. To invoke the member function, the first data member is referenced through a member function of the universal pointer object.

Growing community of inventors

San Jose, CA, United States of America

I-Shin Andy Wang