← Back to branch summary

~njansson/dolfin/hpc

« back to all changes in this revision

Viewing changes to src/kernel/parameter/Parameter.cpp

  • Committer: Johannes Ring
  • Date: 2008-03-05 22:43:06 UTC
  • Revision ID: johannr@simula.no-20080305224306-2npsdyhfdpl2esji
The BIG commit!

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/kernel/parameter/Parameter.cpp
1
 
// Copyright (C) 2003-2005 Anders Logg.
2
 
// Licensed under the GNU LGPL Version 2.1.
3
 
//
4
 
// First added:  2003-05-06
5
 
// Last changed: 2005-12-21
6
 
 
7
 
#include <dolfin/dolfin_log.h>
8
 
#include <dolfin/ParameterValue.h>
9
 
#include <dolfin/Parameter.h>
10
 
 
11
 
using namespace dolfin;
12
 
 
13
 
//-----------------------------------------------------------------------------
14
 
Parameter::Parameter(int value) : value(0), _type(type_int)
15
 
{
16
 
  this->value = new IntValue(value);
17
 
}
18
 
//-----------------------------------------------------------------------------
19
 
Parameter::Parameter(uint value) : value(0), _type(type_int)
20
 
{
21
 
  this->value = new IntValue(static_cast<int>(value));
22
 
}
23
 
//-----------------------------------------------------------------------------
24
 
Parameter::Parameter(real value) : value(0), _type(type_real)
25
 
{
26
 
  this->value = new RealValue(value);
27
 
}
28
 
//-----------------------------------------------------------------------------
29
 
Parameter::Parameter(bool value) : value(0), _type(type_bool)
30
 
{
31
 
  this->value = new BoolValue(value);
32
 
}
33
 
//-----------------------------------------------------------------------------
34
 
Parameter::Parameter(std::string value) : value(0), _type(type_string)
35
 
{
36
 
  this->value = new StringValue(value);
37
 
}
38
 
//-----------------------------------------------------------------------------
39
 
Parameter::Parameter(const char* value) : value(0), _type(type_string)
40
 
{
41
 
  std::string s(value);
42
 
  this->value = new StringValue(s);
43
 
}
44
 
//-----------------------------------------------------------------------------
45
 
Parameter::Parameter(const Parameter& parameter)
46
 
  : value(0), _type(parameter._type)
47
 
{ 
48
 
  switch ( parameter._type )
49
 
  {
50
 
  case type_int:
51
 
    value = new IntValue(*parameter.value);
52
 
    break;
53
 
  case type_real:
54
 
    value = new RealValue(*parameter.value);
55
 
    break;
56
 
  case type_bool:
57
 
    value = new BoolValue(*parameter.value);
58
 
    break;
59
 
  case type_string:
60
 
    value = new StringValue(*parameter.value);
61
 
    break;
62
 
  default:
63
 
    error("Unknown parameter type: %d.", parameter._type);
64
 
  }
65
 
}
66
 
//-----------------------------------------------------------------------------
67
 
const Parameter& Parameter::operator= (int value)
68
 
{
69
 
  *(this->value) = value;
70
 
  return *this;
71
 
}
72
 
//-----------------------------------------------------------------------------
73
 
const Parameter& Parameter::operator= (dolfin::uint value)
74
 
{
75
 
  *(this->value) = value;
76
 
  return *this;
77
 
}
78
 
//-----------------------------------------------------------------------------
79
 
const Parameter& Parameter::operator= (real value)
80
 
{
81
 
  *(this->value) = value;
82
 
  return *this;
83
 
}
84
 
//-----------------------------------------------------------------------------
85
 
const Parameter& Parameter::operator= (bool value)
86
 
{
87
 
  *(this->value) = value;
88
 
  return *this;
89
 
}
90
 
//-----------------------------------------------------------------------------
91
 
const Parameter& Parameter::operator= (std::string value)
92
 
{
93
 
  *(this->value) = value;
94
 
  return *this;
95
 
}
96
 
//-----------------------------------------------------------------------------
97
 
const Parameter& Parameter::operator= (const Parameter& parameter)
98
 
{
99
 
  delete value;
100
 
 
101
 
  switch ( parameter._type )
102
 
  {
103
 
  case type_int:
104
 
    value = new IntValue(*parameter.value);
105
 
    break;
106
 
  case type_real:
107
 
    value = new RealValue(*parameter.value);
108
 
    break;
109
 
  case type_bool:
110
 
    value = new BoolValue(*parameter.value);
111
 
    break;
112
 
  case type_string:
113
 
    value = new StringValue(*parameter.value);
114
 
    break;
115
 
  default:
116
 
    error("Unknown parameter type: %d.", parameter._type);
117
 
  }  
118
 
 
119
 
  _type = parameter._type;
120
 
 
121
 
  return *this;
122
 
}
123
 
//-----------------------------------------------------------------------------
124
 
Parameter::~Parameter()
125
 
{
126
 
  if ( value ) delete value;
127
 
}
128
 
//-----------------------------------------------------------------------------
129
 
Parameter::operator int() const
130
 
{
131
 
  return *value;
132
 
}
133
 
//-----------------------------------------------------------------------------
134
 
Parameter::operator dolfin::uint() const
135
 
{
136
 
  return *value;
137
 
}
138
 
//-----------------------------------------------------------------------------
139
 
Parameter::operator real() const
140
 
{
141
 
  return *value;
142
 
}
143
 
//-----------------------------------------------------------------------------
144
 
Parameter::operator bool() const
145
 
{
146
 
  return *value;
147
 
}
148
 
//-----------------------------------------------------------------------------
149
 
Parameter::operator std::string() const
150
 
{
151
 
  return *value;
152
 
}
153
 
//-----------------------------------------------------------------------------
154
 
Parameter::Type Parameter::type() const
155
 
{
156
 
  return _type;
157
 
}
158
 
//-----------------------------------------------------------------------------
159
 
dolfin::LogStream& dolfin::operator<<(LogStream& stream,
160
 
                                      const Parameter& parameter)
161
 
{
162
 
  switch ( parameter.type() )
163
 
  {
164
 
  case Parameter::type_int:
165
 
    stream << "[Parameter: value = " 
166
 
           << static_cast<int>(parameter) << " (int)]";
167
 
    break;
168
 
  case Parameter::type_real:
169
 
    stream << "[Parameter: value = "
170
 
           << static_cast<real>(parameter) << " (real)]";
171
 
    break;
172
 
  case Parameter::type_bool:
173
 
    if ( static_cast<bool>(parameter) )
174
 
      stream << "[Parameter: value = true (bool)]";
175
 
    else
176
 
      stream << "[Parameter: value = false (bool)]";
177
 
    break;
178
 
  case Parameter::type_string:
179
 
    stream << "[Parameter: value = \""
180
 
           << static_cast<std::string>(parameter) << "\" (string)]";
181
 
    break;
182
 
  default:
183
 
    error("Unknown parameter type: %d.", parameter._type);
184
 
  }
185
 
  
186
 
  return stream;
187
 
}
188
 
//-----------------------------------------------------------------------------