A Software Tool for Optimal Class-Hierarchy Design Based on the Use-Relationship Among Functions and Variables Nigel Gwee† Computer Science Department Southern University and A&M College Baton Rouge, LA 70813, USA [email protected] Sukhamay Kundu Computer Science Department Louisiana State University and A&M College Baton Rouge, LA 70803, USA [email protected] Abstract We present a software tool for creating an optimal class-hierarchy from the use-relationship among data-items and functions based on the method in Kundu and Gwee [3]. The tool determines the classes and their inheritance relationship, including the assignment of variables and functions to the various classes and their appropriate access levels (private, etc.). We define a class-design language for modeling the classes and the use-relationship and a script language for manipulating the classes. The input to the tool and its operations are based on the constructs of these languages. We illustrate the tool with a small non-trivial class design problem. 1 INTRODUCTION Although various metrics have been suggested [1, 2] to measure the quality of a class hierarchy, a general definition of an optimal class hierarchy remains elusive: an optimal class hierarchy for software efficiency may not necessarily be optimal for maintainability. Kundu and Gwee [3] consider a class hierarchy to be optimal if it minimizes unnecessary access of functions to data and to other functions, and if it avoids unduly long chains of single inheritance classes. Based on this, they presented a method to create an optimal class hierarchy design from a given use-relationship among a set of functions and data-items (which includes the inputs and outputs of those functions). Their method first extracts a partial ordering of the functions from the use-relationship and thereby creates an initial class hierarchy, and then uses a series of operations to improve the class hierarchy via refactoring and decomposition of classes and merging of variables and functions [5]. We present here a tool called OCHD (Optimal Class Hierarchy Designer) to demonstrate the feasibility of the method in [3]. We illustrate the tool with a small but non-trivial class design problem. The input to the tool OCHD can be a use-relationship or an arbitrary class hierarchy specified by the class-design language; in the second case, the tool first derives a use-relationship from the class hierarchy. The tool can be used interactively to manipulate the classes or run in batch mode, with the operations specified in the script language. A given class hierarchy H can have several faults with respect to the design specification described by a use-relationship. For example, H may fail to satisfy the basic properties: (1) It uses exactly the same functions and variables as given in the use-relationship: (2) It allows each function to access the variables it needs via the inheritance relationship in H. The OCHD tool can detect these faults in a given class hierarchy against a use-relationship. Moreover, it can show the best placement of missing variables and functions within the existing classes in H, or add new classes to the existing class hierarchy to accommodate them, or create a new class hierarchy from scratch. Our tool can also facilitate the integration of a group of class hierarchies designed separately (not illustrated in this paper owing to space limitations). 2 OUTLINE OF THE PARTIAL ORDER METHOD We briefly describe the method for creating a class hierarchy from the partial ordering of functions given in [3]. Given a finite set of functions F, a finite set of variables V, and a use-relationship U(F, V), where U = {〈f, v 〉: f ∈ F and v ∈ V, f reads or writes v}, let V(fi) = {vj : 〈fi, vj〉 ∈ U(F, V)}, and let [fi] be the equivalence class of all fj ∈ F for which V(fi) = V(fj). We define a partial ordering on F as follows: fi < fj if and only if V(fi) ⊃ V(fj). Clearly, this gives a partial ordering on the equivalence classes [fi]. We can now define a class Ci for each [fi], with Ci having member variables V(Ci) = V(fi) – ∪{V(fj) : fi < fj} and member functions F(Ci) = [fi]. We also make Ci a subclass of Cj if fi < fj. If we are given a class hierarchy CH, say in C++ style, then F = { fi: fi is a function in some class in CH} and similarly for V. We determine U(F, V), or equivalently, each V(fi), as follows: for each fi, we initialize V(fi) to be the variables directly used by fi (from the source code of fi). Then, we expand each V(fi) by letting V(fi) = V(fi) ∪ V(fj), the union taken over for all fj directly called by fi. Finally, we repeat this expansion step until none of the V(fi)’s change. Observe that for functions fi that are higher up in CH the final value of V(fi) will tend †This work is partially supported by the Louisiana Board of Regents under Contract Number LEQSF (2006-07)-ENH-TR-64 awarded to Southern University and A&M College, Baton Rouge, Louisiana.to be determined before those of functions that are lower down in CH. The above computations of F, V, and U(F, V) are essentially step (1) of the following algorithm to optimize CH. Steps (2)–(4) build an initial class hierarchy that may contain some redundant artifacts, which are eliminated in steps (5)–(7). Algorithm: Build Optimal Class Hierarchy (BOCH) Input: A class hierarchy CH, specified using the language CHSL given in section 3. Output: An optimal class hierarchy OptCH consistent with CH. 1. [Preprocessing] Extract F, V, and U(F, V) from CH. 2. [Build function equivalence classes] Collect all functions fi from F and partition them into equivalence classes based on U (F, V). 3. [Build classes from function equivalence classes] For each equivalence class, create a class containing the functions of that equivalence class and the variables these functions use (read, write, or read-write). 4. [Establish class-subclass relationship] For all pairs of functions fi and fj, if fi < fj then make Ci a subclass of Cj. 5. [Remove subclass transitivity] Form