Decorator Design Pattern Research Articles

A Prototype Development of a Mobile Schedule Viewer Integrating QR Code Technology and Decorator Design Pattern for Effective Dissemination of Class Schedules

Class schedules undergo continuous changes with each new release, making manual scheduling a complex task. To address this issue, this study proposes integrating a mobile application that enables students to promptly access their accurate class schedules. A prototype mobile schedule viewer was developed to identify and resolve conflicts arising from conflicting schedules. The study confirmed the functionality and stability of the spreadsheet application, as the mobile schedule viewer successfully employed the decorator design pattern and integrated QR code generator plugins. These plugins facilitated the extraction of existing schedule files from the University Integrated Information System (UIIS). The overall findings indicate that the applications are 95 percent complete in terms of degree of completeness (DOC) and boast a record level of accuracy (RLA) of 95 percent.

CORBA-Based Class Scheduling Framework Using Decorator and Facade Design Patterns

Class scheduling problem has been regarded as one of the most difficult yet important challenges for developers developing timetabling applications. Different algorithms or schemes were devised to address such problems. Yet, considering the growing complexity of the input factors, it contributes to difficulties in maintaining the said system. In order to aid in the development and maintenance of such a system, this paper presents an object-oriented approach to designing a class scheduling paradigm using decorator and facade design patterns with CORBA architecture. This technique was based on the concepts of several existing object-oriented components of Windows GUI platforms. The paradigm designs are expressed using Unified Modeling Language (UML) and illustrated in a Java programming environment. The result of the study is a simplified method for designing an efficient and reusable component for the class scheduling model.

A Design Pattern Approach to Improve the Structure and Implementation of the Decorator Design Pattern

Reusability is a technique used to unify the abstract representation of real world entities. In object-oriented design and programming, inheritance mechanism plays an important role in software reusability. The Decorator Design Pattern (DDP), invented by GoF, was an alternative solution to the inheritance mechanism. It uses the concept of decorating objects instead of inheritance. The aim of this study is to present the DDP, showing its advantages and disadvantages and offer a new innovative approach, called Decorator Pattern Approach (DPA), in order to improve the structure and implementation of DDP. The main objective of DPA is to provide a way to separate, dynamically, the decorating objects from the objects to decorate.

Implementing design patterns as parametric aspects using ParaAJ: The case of the singleton, observer, and decorator design patterns

Implementation of a design pattern can take many forms according to the programming language being used. Most of the literature presents design patterns in their conventional object-oriented implementations. Several other studies show the implementation in aspect-oriented languages such as AspectJ, EOS, and Caesar. In this work, we compare the implementation of three design patterns: singleton, observer, and decorator design patterns in these languages and also discuss the possibility of implementing them in ParaAJ: an extension to the AspectJ language that implements the idea of parametric aspects. We found that ParaAJ helps in making the implementation of the singleton and observer patterns reusable but it fails to help in the decorator case. The problem with the decorator pattern exists because of the current translation mechanism of ParaAJ׳s aspects to normal AspectJ׳s aspects. This opens the door for further work in ParaAJ to better support the idea of parametric aspects.

Abstract Factory and Singleton Design Patterns to Create Decorator Pattern Objects in Web Application

Software Design Patterns are reusable designs providing common solutions to the similar kind of problems in software development. Creational patterns are that category of design patterns which aid in how objects are created, composed and represented. They abstract the creation of objects from clients thus making the application more adaptable to future requirements changes. In this work, it has been proposed and implemented the creation of objects involved in Decorator Design Pattern. (Decorator Pattern Adds Additional responsibilities to the individual objects dynamically and transparently without affecting other objects). This enhanced the reusability of the application design, made application more adaptable to future requirement changes and eased the system maintenance. Proposed DMS (Development Management System) web application is implemented using .NET framework, ASP.NET and C#.

Application of refactoring and design pattern in land information system development

The unceasing change problem of land information systems can be resolved through the refactoring and design pattern. To promote the implementation of design pattern and refactoring methods in developing land information systems reusing software design, applying refactoring methods to the abstract factory and decorator design patterns in land information system development is discussed.

Dynamic topology processing in a radial distribution system

A dynamic topology processor for a radial distribution system using object-oriented methodology is presented. The potential of object-oriented design patterns is also employed to obtain an extendible design. The decorator design pattern is used to separate the topology-based attributes from the attributes representing physical characteristics of the objects. Using decorator pattern, responsibilities can be dynamically attached to or removed from the objects. The state design pattern is used to model the switching states of the tie and sectionalising switches. The proposed topology-processor algorithm is a local updating technique, hence less time consuming. The proposed algorithm has been implemented in C++ and tested with a modified 69-bus system. It has been found that the average CPU time required to modify the links between the objects following a switching operation is only 0.4 ms.

The Imperion Threading System.

This paper describes the use of the command, facade and decorator design patterns to alter the interface and add new responsibilities to threads. Termed Project Imperion, the threads are developed with the same design patterns as previously reported for Imperion GUI components [Lyon 2004b]. The benefits of Imperion threading include: simplifying code, easing maintenance, separation of thread management logic from the business logic and improved reliability. Our experience shows that threads are often run more than once. They are frequently stopped and then restarted. However, the present mechanisms for doing this are both low-level and exception-prone. Imperion threads have built-in support for iteration. They support killing and restarting threads by introducing a new class called the RunJob. The RunJob tracks the number of times it has been run, and can be set to run only so many times before it dies. It can be set to start automatically, or be set to wait until explicitly started (or restarted). The Imperion threading system is a more reliable threading system than the normal java.lang.Thread. Imperion removes dangerous methods and guards’ inputs in order to avoid exceptions. For example, the daemon property can only be set during construction, priorities are guarded for correctness and restarting is safe. This avoids a fruitful source of complex run-time errors that have been bugging both novice and seasoned programmers since the release of JDK 1.0. Project Imperion was named for the Latin root, imperium, which means the power to command. Like the Intel use of the word CELERON, the on suffix was added to give the word a high-tech look (like electron, proton or muon). It was first conceived at the skunk works of DocJava, Inc., in the late 1990’s.

Extending Java to dynamic object behaviors

Class inheritance and dynamic binding are the key features of object-oriented programming and they permit designing and developing complex systems. However, standard class inheritance is essentially static and cannot be directly employed for modeling dynamic object behaviors. In this paper we propose a linguistic extension of Java, called Dec-Java, that is partially inspired by the decorator design pattern. This extension permits easily separating the basic features of objects (that are likely not to change during the application) from their behaviors (that, instead, can be composed dynamically at run-time). Thus, Dec-Java enables a dynamic extension and specialization of object responsibilities.

Design patterns for sorting

Drawing on Merritt's divide-and-conquer sorting taxonomy [1], we model comparison-based sorting as an abstract class with a template method to perform the sort by relegating the splitting and joining of arrays to its concrete subclasses. Comparison on objects is carried out via an abstract ordering strategy. This reduces code complexity and simplifies the analyses of the various concrete sorting algorithms. Performance measurements and visualizations can be added without modifying any code by utilizing the decorator design pattern. This object-oriented design not only provides the student a concrete way of unifying seemingly disparate sorting algorithms but also help him/her differentiate them at the proper level of abstraction.