• Journal of the Korea Institute of Information and Communication Engineering
• /
• v.11 no.3
• /
• pp.500-506
• /
• 2007

The Type Object Design Pattern is proposed to provide a solution on the situation in the case that one class has too many subclasses or the number of subclasses are undefined. Although this pattern has many advantages in terms of applicability and dynamic object behavior, it has a weak point in runtime pattern operation that it has to build and maintain a class reference mechanism in runtime to reference the class (de facto 'object') of instances. To solve that problem, this paper addresses the solution of the runtime class reference problem of Type Object Pattern. it defines a new class of Type Object Class (TOC) from Type Class and Object Class in Type Object pattern and presents the methods of creating, compiling, and memory-loading the TOC. It depends on built-in class reference mechanism of object-oriented programming language, and is not necessary to fit with the additional mechanism. Consequently, we need not to set up the additional class reference mechanism and system performance is enhanced due to it.

• The KIPS Transactions:PartD
• /
• v.8D no.6
• /
• pp.853-860
• /
• 2001

In the object-oriented software development, redesigning of classes and reorganizing of class hierarchy structures should be necessary to reduce many of the headaches of object-oriented software design and maintenance. To support this task, in this paper, we propose a theoretical foundation for class hierarchy reorganizations that is relatively complete, correct, formal and easy to understand and use. We introduce the flattened class hierarchy that characterizes the class hierarchy structures in object-oriented software evolution. And we also present an algorithm which transforms a given class hierarchy into the normalized form. The flattened class hierarchy helps us map the inheritance and aggregation paths in a class hierarchy to paths in an object hierarchy that is an instance of the class hierarchy. By applying the algorithm into a given class hierarchy, we can make a new, object-preserved, and flattened class hierarchy that is the cornerstone for reorganization of class hierarchy structure and plays an important role as a bridge on the incremental evolutionary changes and reuse of object-oriented software to reorganize class hierarchies.

• Proceedings of the IEEK Conference
• /
• 1999.11a
• /
• pp.426-429
• /
• 1999

Many similar class components are stored in object-storage but the object-storage has needed the retrieval function of correct component for reuse. Accordingly this paper designed the class component retrieval viewer of the object-storage by using the improved spreading activation strategy. Object-storage has made up of information of inheritance relation, superclass, subclass, and we defined the queries about each class function. Also we specified connectionist relaxation of the each class and query, finally we gained retrieval result which showed highest activation value order of class component information including the query function.

• The Transactions of the Korea Information Processing Society
• /
• v.7 no.3
• /
• pp.818-830
• /
• 2000

Automation tools for program analysis are needed in order to program understand and maintain, extract the characteristics of object-oriented program such as class name, member function and data member. In this paper, we carried out design and implementation of the automation tool for effective maintenance of object-oriented software. Being based on Reverse Engineering, this approach extracts class relationship information from C++ source code and generates object-oriented model of class diagram using UML as the standard object-oriented methodology. Therefore, this paper provides developers visualized including class information, definitions of classes, inheritance relationships, set relationships, and simple reference relationships. Finally in this paper, we propose a method that construct class relationship information to table in analysis state and make form of table construction to link form so tat developers can perform understanding and maintaining program efficiently. And this method enable to restructure and reuse in object-oriented model.

• 제어로봇시스템학회:학술대회논문집
• /
• 2004.08a
• /
• pp.960-964
• /
• 2004

During system resource improvement process that based on Object-Oriented technology could be affect to the continuous system performance if lack appropriate management and control objects mechanism. This paper proposes a methodology to support continuous system performance and its stability. The adoption is based on Java Container Framework and Collections Framework for object collection. Also includes Software Engineering, Object Migration and Multiple Class Loaders mechanism accommodate to construct Continuous Migration Container (CMC). CMC is a runtime environment provides interfaces for management and control to support upgrading object process. Upgrade object methodology of CMC can be divided into two phase are object equivalence checking and object migration process. Object equivalence checking include object behavior verification and functional conformance verification before object migration process. In addition, CMC use Multiple Class Loaders mechanism to support reload effected classes instead of state transfer in migration process while upgrading object. These operations are crucial for system stability and enhancement efficiency.

• Journal of the Korea Computer Industry Society
• /
• v.10 no.3
• /
• pp.73-78
• /
• 2009

This paper designed Object-orientid Meta_data operation module that introducted new Meta_class basis the Meta_Classfication model. In order to implement this Data model, we have introducted heurilistic class to traditional object-orinted database. And we designed Meta_data operation module for Inplemetated Meta_data that basis on the heurilistic classficasion model using stored Meta_data in extened object-oriend data model.

• The Journal of Information Systems
• /
• v.5
• /
• pp.149-173
• /
• 1996

This paper focus on the development of object-oriented model bases for Structured Modeling. For the model base organization, object modeling techniques and model typing concept which is similar to data typing concept are used. Structured modeling formalizes the notion of a definitional system as a way of dscribing models. From the object-oriented concept, a structured model can be represented as follows. Each group of similar elements(genus) is represented by a composite class. Other type of genera can be represented in a similar manner. This hierarchical class composition gives rise to an acyclic class-composition graph which corresponds with the genus graph of structured model. Nodes in this graph are instantiated to represent the elemental graph for a specific model. Taking this class composition process one step further, we aggregate the classes into higher-level composite classes which would correspond to the structured modeling notion of a module. Finally, the model itself is then represented by a composite class having attributes each of whose domain is a composite class representing one of the modules. The resulting class-composition graph represent the modular tree of the structured.

• Korean Journal of Computational Design and Engineering
• /
• v.13 no.3
• /
• pp.187-199
• /
• 2008

This paper describes a C++ class hierarchy of implicit objects for geometry modeling and processing. This class structure provides a software kernel for integrating many various models and methods found in current implicit modeling areas. The software kernel includes primitive objects playing a role of unit element in creating a complex shape, and operator objects used to construct more complex shape of implicit object formed with the primitive objects and other operators. In this paper, class descriptions of these objects are provided to better understand the details of the algorithm or implementation, and its instance examples to show the capabilities of the object classes for constructive shape geometry. In addition, solid modeling system shown as an application example demonstrates that the proposed implicit object classes allow us to carry out modern solid modeling techniques, which means they have the capabilities to extend to various applications.

• ETRI Journal
• /
• v.31 no.2
• /
• pp.140-150
• /
• 2009

Although mutation testing is potentially powerful, it is a computationally expensive testing method. To investigate how we can reduce the cost of object-oriented mutation testing, we have conducted empirical studies on class mutation operators. We applied class mutation operators to 866 classes contained in six open-source programs. An analysis of the number and the distribution of class mutants generated and preliminary data on the effectiveness of some operators are provided. Our study shows that the overall number of class mutants is smaller than for traditional mutants, which offers the possibility that class mutation can be made practically affordable.

• Journal of Korea Multimedia Society
• /
• v.9 no.6
• /
• pp.693-699
• /
• 2006

Object-oriented databases (OODBs) have been adopted for managing non-standard applications such as computer-aided design (CAD), office document management and many multimedia applications. One of the major characteristics of OODBs is class hierarchy where a subclass is allowed to inherit the definitions defined on its superclasses. In this paper, I present the evaluation metrics for class hierarchy quality in OODBs. These metrics are developed to determine if a concurrency control scheme can achieve good performance or not on a given class hierarchy. I first discuss the existing concurrency control schemes for OODBs. Then I provide evaluation metrics based on structural information and access frequency information in class hierarchies. In order to discuss significance of the proposed performance metrics, an analytical model is developed. Analysis results show that the performance metrics are important factor in concurrency control performance. I consider both single inheritance and multiple inheritance. The proposed metrics can be used to provide guidelines on how to design class hierarchy of an OODB for maximizing the performance of concurrency control technique.