Ex Parte Arnold et al - Page 9



               Appeal 2007-0506                                                                             
               Application 09/998,511                                                                       
               definitions of functions tightly associated with that type, where the functions              
               implement the operations on that type and are called methods or member                       
               functions (col. 6, ll. 19-35).  Objects are created from a class by a process                
               called instantiation (col. 6, ll. 36-43).  All objects of a given type (ADT)                 
               share their functions (col. 8, ll. 16-17).  Figure 5 of Coplien discloses an                 
               ADT for the class Window having data for position and size and functions                     
               for move, refresh, create, and delete.  The functions for refresh, create, and               
               delete are not implemented in the Windows class.  A class XWindow is used                    
               to implement the semantics for manipulating a window created using the                       
               X window system (col. 8, ll. 62-64).  It contains declarations of data that                  
               hold information pertinent to the details of maintaining windows (pixel                      
               depth, color, etc.) and defines the functions to do what needs to be done to                 
               X windows (refresh, create, delete, etc.) (col. 8, ll. 64-68).                               
                      There is no question, and Appellants admit, that Coplien discloses the                
               general concept of an interface-implementation relationship in object-                       
               oriented programming.  Appellants do not allege that they invented the                       
               interface-implementation programming structure illustrated in their Figure 7.                
               However, we do not agree with the Examiner's finding that Coplien                            
               discloses setting a breakpoint in a function of the first program entity and                 
               halting execution during debugging in response to reaching an                                
               implementation of the method defined in the second program entity.  (If it                   
               did, it would in fact anticipate.)  Column 8, lines 45-53, which the Examiner                
               relies on, only states that when there are two different objects of the same                 
               class, modifications to their shared text to insert a breakpoint will cause what             
                                                     9                                                      



Page:  Previous  1  2  3  4  5  6  7  8  9  10  Next

Last modified: September 9, 2013