Generic Advice: On the Combination of AOP with Generative Programming in AspectC++

Lohmann, Daniel; Blaschke, Georg; Spinczyk, Olaf

doi:10.1007/978-3-540-30175-2_4

Cited by 32 publications

(33 citation statements)

References 12 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…In an environment where thousands of unit tests must be run, this increase in build and run time may not be acceptable, which could potentially limit the usefulness of the tool. However in [20] it was discussed that the runtime overhead introduced by aspect code may be disproportionately large in small code, making this overhead appear larger in the experiment than it actually would be in practice. Furthermore, the point cuts defined for introducing advice in the implementation of StaticMock are very aggressive: they catch all method calls, whether necessary to the unit test or not.…”

Section: Discussionmentioning

confidence: 98%

STATICMOCK : A Mock Object Framework for Compiled Languages

Bingham¹,

Walcott²

2018

IJSEA

View full text Add to dashboard Cite

Mock object frameworks are very useful for creating unit tests. However, purely compiled languages lack robust frameworks for mock objects. The frameworks that do exist rely on inheritance, compiler directives, or linker manipulation. Such techniques limit the applicability of the existing frameworks, especially when dealing with legacy code.We present a tool, StaticMock, for creating mock objects in compiled languages. This tool uses source-tosource compilation together with Aspect Oriented Programming to deliver a unique solution that does not rely on the previous, commonly used techniques. We evaluate the compile-time and run-time overhead incurred by this tool, and we demonstrate the effectiveness of the tool by showing that it can be applied to new and existing code.

show abstract

Section: Discussionmentioning

confidence: 98%

STATICMOCK : A Mock Object Framework for Compiled Languages

Bingham¹,

Walcott²

2018

IJSEA

View full text Add to dashboard Cite

show abstract

“…AspectC++ seems to support typesafe application of generic "around" advice and to avoid overhead when primitive type values are returned [25]. To our knowledge no Java aspect weaver has this property, and no C# aspect weaver has it except for the Yiihaw weaver presented in this paper.…”

Section: Related Work: Other Aspect Weaversmentioning

confidence: 91%

Zero-Overhead Composable Aspects for .NET

Johansen

Sestoft

Spangenberg

2008

Advances in Software Engineering

View full text Add to dashboard Cite

Abstract. We present a new static aspect weaver for C#. The weaver, which is called Yiihaw, works by transforming a program's bytecode and types, stored in so-called assemblies, and performs extensive checks at weave-time to ensure correctness of the resulting woven assembly. The design makes four contributions: (a) Application of generic advice is typesafe; (b) application of "around" advice incurs no runtime overhead; (c) woven assemblies can be further woven; and (d) advice can itself be woven before being applied to target code -in effect advice can be composed. These contributions are achieved by minimal means, basing much of the type checking on the bytecode's generic type system. Yiihaw's aspects are less expressive than those of AspectJ: an aspect does not have an identity of its own; only static join points are supported; and the pointcut language does not allow logical combinations of join points. However, Yiihaw is sufficiently expressive for many purposes, and for these purposes it provides statically typesafe weaving and highly efficient woven code.

show abstract

“…The most detailed discussion of aspects and C++ templates is described in [13], within the context of AspectC++ (an aspect language for C++) [17]. The effort to add aspects to templates in AspectC++ has been partitioned along two complimentary dimensions:…”

Section: Motivationmentioning

confidence: 99%

A Program Transformation Technique to Support AOP within C++ Template.

Roychoudhury¹,

Gray²,

Zhang³

et al. 2010

JOT

View full text Add to dashboard Cite

Aspect-oriented programming (AOP) provides assistance in modularizing concerns that crosscut the boundaries of system decomposition. Aspects have the potential to interact with many different kinds of language constructs in order to modularize crosscutting concerns. Although several aspect languages have demonstrated advantages in applying aspects to traditional modularization boundaries (e.g., object-oriented hierarchies), additional language concepts such as parametric polymorphism can also benefit from aspects. Many popular programming languages support parametric polymorphism (e.g., C++ templates), but the combination of aspects and generics is a topic in need of further investigation. The paper enumerates the general challenges of uniting aspects with C++ templates. It also underlines the need for new language constructs to extend AOP support to C++ templates and provides an initial solution to realize this goal.

show abstract

Generic Advice: On the Combination of AOP with Generative Programming in AspectC++

Cited by 32 publications

References 12 publications

STATICMOCK : A Mock Object Framework for Compiled Languages

STATICMOCK : A Mock Object Framework for Compiled Languages

Zero-Overhead Composable Aspects for .NET

A Program Transformation Technique to Support AOP within C++ Template.

Contact Info

Product

Resources

About