source: src/CodePatterns/ManipulableClone.hpp@ 163eec

Last change on this file since 163eec was 9b8fa4, checked in by Frederik Heber <heber@…>, 14 years ago

Huge update of file structure to place installation header files into right folder.

  • The problem ist that we desire use as include "CodePatterns/...". For this to work, especially with the new Observer subfolder structure, it has been necessary to place all header files away from their source files into a distinct folder called CodePatterns. This emulates the later, after make install present structure.
  • essentially all source and header files had to be changed to adapt the include.
  • all Makefile.am's had to be changed.
  • nobase_ ... was removed such that header files are installed flat and not creating their subfolder along the process.
  • We placed Observer into its own convenience library and own folder Observer away from Patterns.

Some other changes:

  • FIX: MemDebug.hpp inclusion has been removed in all stubs.
  • Property mode set to 100644
File size: 2.0 KB
Line 
1/*
2 * ManipulableClone.hpp
3 *
4 * Created on: Jan 6, 2011
5 * Author: heber
6 */
7
8#ifndef MANIPULABLECLONE_HPP_
9#define MANIPULABLECLONE_HPP_
10
11/** \section <ManipulableClone> (ManipulableClone Howto)
12 *
13 * Prototypes serves as templates in object creation, i.e. new objects are
14 * created by coping the prototype. Therefore each prototypical type has to
15 * implement a clone() function. Here, we go one step further: In order to
16 * allow for changing member variables a clone contains which is not possible
17 * by member functions but only through ythe constructor, you may instantiate
18 * a ManipulableClone, i.e. implement a manipulatedclone(set) function which
19 * uses a parameter struct \a set containing new values to be used in the
20 * constructor call.
21 *
22 * By inheriting this pattern and implementing the clone function you make
23 * sure that the prototypes, e.g. to be stored in a factory table, can be
24 * safely copied (the factory just calls clone of the prototype) and can
25 * be handed out by the abstract and common interface.
26 *
27 * <h2> Howto </h2.
28 *
29 * Basically, you if you have your Prototype types, e.g. \a Prototype1 that
30 * all have a common interface, \a IPrototype, you just inherit additionally
31 * the specific ManipulableClone<IPrototype> class as follows:
32 *
33 * @code
34 * class Prototype1 :
35 * public IPrototype,
36 * public ManipulableClone<IPrototype,ParameterSet>
37 * {
38 * public:
39 * IPrototype clone()
40 * {
41 * ... do something to clone the class ...
42 * };
43 * IPrototype clone(const ParameterSet &_params)
44 * {
45 * ... do something to clone the class ...
46 * ... while using _params ...
47 * };
48 * };
49 * @endcode
50 *
51 * Note that ParameterSet should be a structure containing public member
52 * values.
53 *
54 */
55template <class interface, class parameterset>
56class ManipulableClone
57{
58public:
59 virtual ~ManipulableClone() {};
60 virtual interface* clone() const = 0;
61 virtual ManipulableClone<interface, parameterset>* manipulatedclone(const parameterset &_parameters) const = 0;
62};
63
64#endif /* MANIPULABLECLONE_HPP_ */
Note: See TracBrowser for help on using the repository browser.