ElementData.h 5.07 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
// ============================================================================
// ==                                                                        ==
// == AMDiS - Adaptive multidimensional simulations                          ==
// ==                                                                        ==
// ============================================================================
// ==                                                                        ==
// ==  crystal growth group                                                  ==
// ==                                                                        ==
// ==  Stiftung caesar                                                       ==
// ==  Ludwig-Erhard-Allee 2                                                 ==
// ==  53175 Bonn                                                            ==
// ==  germany                                                               ==
// ==                                                                        ==
// ============================================================================
// ==                                                                        ==
// ==  http://www.caesar.de/cg/AMDiS                                         ==
// ==                                                                        ==
// ============================================================================

/** \file ElementData.h */

#ifndef AMDIS_ELEMENTDATA_H
#define AMDIS_ELEMENTDATA_H

#include "Serializable.h"
#include "CreatorMap.h"

namespace AMDiS {

  const int ESTIMATABLE = 1;
  const int COARSENABLE = 2;
  const int PERIODIC = 3;
  const int ELEMENT_REGION = 4;
  const int SURFACE_REGION = 5;

  // ============================================================================
  // ===== class ElementData ====================================================
  // ============================================================================

  /** \brief
   * Base class for element data. To allow to assign arbitrary data to arbitrary
   * elements at run time, the decorator pattern in combination with the
   * chain-of-responsibility pattern is applied. So only data have to be managed 
   * at each element which are used for this element at this time.
   */
  class ElementData : public Serializable
  {
  public:
    /** \brief
     * constructor
     */
    ElementData(ElementData *decorated = NULL) 
      : decorated_(decorated)
    {};

    /** \brief
     * destructor
     */
    virtual ~ElementData() {};

    /** \brief
     * Refinement of parent to child1 and child2.
     */
    virtual bool refineElementData(Element* parent, 
				   Element* child1,
				   Element* child2,
				   int elType)
    {
      if(decorated_) {
	bool remove = 
	  decorated_->refineElementData(parent, child1, child2, elType);

	if(remove) {
	  ElementData *tmp = decorated_->decorated_;
	  delete decorated_;
	  decorated_ = tmp;
	}
      }
      return false;
    };

    /** \brief
     *
     */
    virtual void coarsenElementData(Element* parent, 
				    Element* thisChild,
				    Element* otherChild,
				    int elTypeParent)
    {
      if(decorated_) {
	decorated_->coarsenElementData(parent, 
				       thisChild, 
				       otherChild, 
				       elTypeParent);
	delete decorated_;
	decorated_ = NULL;
      }
    };

    /** \brief
     * Returns a copy of this ElementData object including all decorated data.
     */
    virtual ElementData *clone() const {
      if(decorated_) {
	return decorated_->clone();
      }
      return NULL;
    };

    /** \brief
     * Returns the name of element data type.
     */
    virtual const int getTypeID() const = 0;

    /** \brief
     * Returns whether the ElemnetData object is of the type specified by 
     * typeName. Must return true, even if typeName describes a base class.
     */
    virtual bool isOfType(int typeID) const = 0;

    /** \brief
     * Implements Serializable::serialize().
     */
Thomas Witkowski's avatar
Thomas Witkowski committed
124
    virtual void serialize(std::ostream& out);
125
126
127
128

    /** \brief
     * Implements Serializable::deserialize().
     */
Thomas Witkowski's avatar
Thomas Witkowski committed
129
    virtual void deserialize(std::istream& in);
130
131
132
133
134

    /** \brief
     * Returns first element data in the chain which is of the spcified type.
     */
    inline ElementData *getElementData(int typeID) {
Thomas Witkowski's avatar
Thomas Witkowski committed
135
      if (this->isOfType(typeID)) {
136
137
	return this;
      } else {
Thomas Witkowski's avatar
Thomas Witkowski committed
138
	if (decorated_) {
139
140
141
142
143
144
145
	  return decorated_->getElementData(typeID);
	}
      }
      return NULL;
    };

    inline ElementData *getDecorated(int typeID) { 
Thomas Witkowski's avatar
Thomas Witkowski committed
146
      if (decorated_) {
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
	return decorated_->getElementData(typeID);
      }
      return NULL;
    };

    inline bool deleteDecorated(int typeID) {
      if(decorated_) {
	if(decorated_->isOfType(typeID)) {
	  ElementData *tmp = decorated_;
	  decorated_ = decorated_->decorated_;
	  delete tmp;
	  return true;
	} else {
	  return decorated_->deleteDecorated(typeID);
	}
      } 
      return false;
    };

    inline ElementData *getDecorated() { return decorated_; };

  protected:
    /** \brief
     * Pointer to next ElementData object in the chain of responsibility.
     */
    ElementData *decorated_;
  };

}

#endif