Branch data Line data Source code
1 : : /*
2 : : * property.cpp - generic property class implementation
3 : : *
4 : : * Copyright (C) 2003-2009 Stefan Jahn <stefan@lkcc.org>
5 : : *
6 : : * This is free software; you can redistribute it and/or modify
7 : : * it under the terms of the GNU General Public License as published by
8 : : * the Free Software Foundation; either version 2, or (at your option)
9 : : * any later version.
10 : : *
11 : : * This software is distributed in the hope that it will be useful,
12 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : : * GNU General Public License for more details.
15 : : *
16 : : * You should have received a copy of the GNU General Public License
17 : : * along with this package; see the file COPYING. If not, write to
18 : : * the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
19 : : * Boston, MA 02110-1301, USA.
20 : : *
21 : : * $Id$
22 : : *
23 : : */
24 : :
25 : : #if HAVE_CONFIG_H
26 : : # include <config.h>
27 : : #endif
28 : :
29 : : #include <stdio.h>
30 : : #include <stdlib.h>
31 : : #include <string.h>
32 : : #include <ctype.h>
33 : : #include <cmath>
34 : : #include <string>
35 : :
36 : : #include "complex.h"
37 : : #include "variable.h"
38 : : #include "property.h"
39 : :
40 : : namespace qucs {
41 : :
42 : : using namespace eqn;
43 : :
44 : : // Constructor creates an unnamed instance of the property class.
45 : 0 : property::property () :
46 : : name(),
47 [ # # ][ # # ]: 0 : str()
48 : : {
49 : 0 : type = PROPERTY_UNKNOWN;
50 : 0 : value = 0.0;
51 : 0 : var = NULL;
52 : 0 : next = NULL;
53 : 0 : def = false;
54 : 0 : }
55 : :
56 : : // Constructor creates a named instance of the property class.
57 : 0 : property::property (const std::string &n) :
58 : : name (n),
59 [ # # ][ # # ]: 0 : str ()
60 : : {
61 : 0 : type = PROPERTY_UNKNOWN;
62 : 0 : value = 0.0;
63 : 0 : var = NULL;
64 : 0 : next = NULL;
65 : 0 : def = false;
66 : 0 : }
67 : :
68 : : /* This full qualified constructor creates an instance of the property
69 : : class containing both the key and the value of the property. */
70 : 894 : property::property (const std::string &n, const std::string &val) :
71 : : name (n),
72 [ + - ][ # # ]: 894 : str(val)
73 : : {
74 : 894 : type = PROPERTY_STR;
75 : 894 : value = 0.0;
76 : 894 : var = NULL;
77 : 894 : next = NULL;
78 : 894 : def = false;
79 : 894 : }
80 : :
81 : : /* This full qualified constructor creates an instance of the property
82 : : class containing both the key and the value of the property. */
83 : 11850 : property::property (const std::string &n, nr_double_t val) :
84 : : name (n),
85 [ + - ][ # # ]: 11850 : str()
86 : : {
87 : 11850 : type = PROPERTY_DOUBLE;
88 : 11850 : value = val;
89 : 11850 : var = NULL;
90 : 11850 : next = NULL;
91 : 11850 : def = false;
92 : 11850 : }
93 : :
94 : : /* This full qualified constructor creates an instance of the property
95 : : class containing both the key and the value of the property. */
96 : 113 : property::property (const std::string &n, variable * val) :
97 : : name (n),
98 [ + - ][ # # ]: 113 : str ()
99 : : {
100 : 113 : type = PROPERTY_VAR;
101 : 113 : var = val;
102 : 113 : value = 0.0;
103 : 113 : next = NULL;
104 : 113 : def = false;
105 : 113 : }
106 : :
107 : : /* The copy constructor creates a new instance of the property class
108 : : based on the given property object. */
109 [ # # ][ # # ]: 0 : property::property (const property & p) {
110 : 0 : type = p.type;
111 [ # # ][ # # ]: 0 : this->name = p.name;
112 [ # # ][ # # ]: 0 : this->str = p.str;
113 : 0 : value = p.value;
114 : 0 : next = p.next;
115 : 0 : var = p.var;
116 : 0 : def = p.def;
117 : 0 : }
118 : :
119 : : // Destructor deletes the property object.
120 : 12857 : property::~property () {
121 : : #if 0 /* FIXME: do this at another code location */
122 : : if (type == PROPERTY_VAR) {
123 : : constant * c = var->getConstant ();
124 : : if (c->getType () == TAG_VECTOR) {
125 : : delete c;
126 : : delete var;
127 : : }
128 : : }
129 : : #endif
130 [ - + ][ # # ]: 25714 : }
131 : :
132 : : /* Goes through the chained list of the properties and looks for a
133 : : property matching the given key and returns its value if possible.
134 : : If there is no such property the function returns NULL. */
135 : 19535881 : property * property::findProperty (const char * const n) {
136 [ + - ]: 19535881 : const std::string tmp = std::string(n);
137 [ + + ]: 417799937 : for (property * p = this; p != NULL; p = p->getNext ())
138 [ + - ][ + - ]: 417206568 : if (p->getName() == n)
[ + + ]
139 : 18942512 : return p;
140 : 19535881 : return NULL;
141 : : }
142 : :
143 : : // Short macro in order to obtain the correct constant value.
144 : : #define D(con) ((constant *) (con))->d
145 : : #define S(con) ((constant *) (con))->s
146 : : #define V(con) ((constant *) (con))->v
147 : :
148 : : // Returns the property's value as vector.
149 : 7274 : qucs::vector * property::getVector (void) const {
150 [ + - ]: 7274 : if (var != NULL) {
151 [ + - ]: 7274 : if (var->getType () == VAR_CONSTANT)
152 : 7274 : return V (var->getConstant ());
153 [ # # ]: 0 : else if (var->getType () == VAR_REFERENCE)
154 : 0 : return V (var->getReference()->getResult ());
155 : : }
156 : 7274 : return NULL;
157 : : }
158 : :
159 : : // Returns the property's value as string.
160 : 112661 : const char * property::getString (void) const {
161 [ - + ]: 112661 : if (var != NULL)
162 : 0 : return S (var->getConstant ());
163 : 112661 : return str.c_str();
164 : : }
165 : :
166 : : // Returns the property's reference if it is a variable.
167 : 0 : const char * property::getReference (void) const {
168 [ # # ]: 0 : if (var != NULL)
169 : 0 : return var->getName ();
170 : 0 : return str.c_str();
171 : : }
172 : :
173 : : // Returns the property's value as double.
174 : 18055727 : nr_double_t property::getDouble (void) const {
175 [ + + ]: 18055727 : if (var != NULL) {
176 [ + - ]: 552443 : if (var->getType () == VAR_CONSTANT)
177 : 552443 : return D (var->getConstant ());
178 [ # # ]: 0 : else if (var->getType () == VAR_REFERENCE)
179 : 0 : return D (var->getReference()->getResult ());
180 : : }
181 : 18055727 : return value;
182 : : }
183 : :
184 : : // Returns the property's value as integer.
185 : 370805 : int property::getInteger (void) const {
186 [ - + ]: 370805 : if (var != NULL) return (int) std::floor (D (var->getConstant ()));
187 : 370805 : return (int) std::floor (value);
188 : : }
189 : :
190 : : // Sets the property's value being a double.
191 : 363038 : void property::set (const nr_double_t val) {
192 : 363038 : type = PROPERTY_DOUBLE;
193 : 363038 : value = val;
194 : 363038 : }
195 : :
196 : : // Sets the property's value being an integer.
197 : 0 : void property::set (const int val) {
198 : 0 : type = PROPERTY_INT;
199 : 0 : value = val;
200 : 0 : }
201 : :
202 : : // Sets the property's value being a variable.
203 : 0 : void property::set (variable * const val) {
204 : 0 : type = PROPERTY_VAR;
205 : 0 : var = val;
206 : 0 : }
207 : :
208 : : // Sets the property's value being a string.
209 : 8056 : void property::set (const std::string &val) {
210 : 8056 : type = PROPERTY_STR;
211 : 8056 : this->str = val;
212 : 8056 : }
213 : :
214 : : // This function returns a text representation of the property object.
215 : 0 : std::string property::toString (void) const {
216 [ # # # # : 0 : switch (type) {
# # ]
217 : : case PROPERTY_UNKNOWN:
218 [ # # ]: 0 : return "(no such type)";
219 : : break;
220 : : case PROPERTY_INT:
221 : 0 : return std::to_string(std::floor(value));
222 : : break;
223 : : case PROPERTY_STR:
224 : 0 : return std::string(this->str);
225 : : break;
226 : : case PROPERTY_DOUBLE:
227 : 0 : return std::to_string(value);
228 : : break;
229 : : case PROPERTY_VAR:
230 [ # # ]: 0 : return var->getName();
231 : : break;
232 : : }
233 [ # # ]: 0 : return "";
234 : : }
235 : :
236 : : } // namespace qucs
|
