7717e456a5507685719f76d04070b55ea3a361de
[scilab.git] / scilab / modules / api_scilab / includes / api_variable.hxx
1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) 2014 - Scilab Enterprises - Antoine ELIAS
4 *
5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13 */
14
15
16 #ifndef __API_VARIABLE_HXX__
17 #define __API_VARIABLE_HXX__
18
19 #include "dynlib_api_scilab.h"
20 #include "internal.hxx"
21
22 namespace api_scilab
23 {
24 class Variable
25 {
26 private :
27 protected :
28     bool created;
29 public :
30     Variable() {};
31     virtual ~Variable() {};
32
33     virtual types::InternalType::ScilabType getType() = 0;
34     void setReturnVariable()
35     {
36         created = false;
37     }
38
39     virtual void* getReturnVariable() = 0;
40     virtual int getSize() = 0;
41 };
42
43 class Matrix : public Variable
44 {
45 public :
46     Matrix() {};
47     virtual ~Matrix() {};
48
49     virtual int getDims() = 0;
50     virtual int* getDimsArray() = 0;
51     virtual int getRows() = 0;
52     virtual int getCols() = 0;
53     virtual int getSize() = 0;
54     virtual bool isScalar() = 0;
55     virtual bool isVector() = 0;
56     virtual bool isRowVector() = 0;
57     virtual bool isColVector() = 0;
58     virtual bool isHypermatrix() = 0;
59 };
60
61 template<class XType> //XType is types::Double for example
62 class VariableT : public Matrix
63 {
64 protected :
65     XType* data;
66
67 public :
68     VariableT() {};
69     virtual ~VariableT() {};
70
71     virtual void* getReturnVariable()
72     {
73         return (void*)data;
74     }
75
76 };
77
78 template<class Type, class XType> //Type is double and XType is Double
79 class MatrixT : public VariableT<XType>
80 {
81 public :
82     virtual Type* getReal()
83     {
84         return get();
85     }
86     virtual Type* get()
87     {
88         if (this->data)
89         {
90             return this->data->get();
91         }
92
93         return NULL;
94     }
95
96     virtual Type* getImg()
97     {
98         if (this->data)
99         {
100             return this->data->getImg();
101         }
102
103         return NULL;
104     }
105
106     virtual Type getReal(int _iIndex)
107     {
108         return get(_iIndex);
109     }
110     virtual Type get(int _iIndex)
111     {
112         if (this->data)
113         {
114             return this->data->get(_iIndex);
115         }
116
117         return 0;
118     }
119
120
121     virtual Type getImg(int _iIndex)
122     {
123         if (this->data)
124         {
125             return this->data->getImg(_iIndex);
126         }
127
128         return 0;
129     }
130
131     virtual Type getReal(int* _piCoordinates)
132     {
133         return get(_piCoordinates);
134     }
135     virtual Type get(int* _piCoordinates)
136     {
137         if (this->data)
138         {
139             int index = this->data->getIndex(_piCoordinates);
140             return this->data->get(index);
141         }
142
143         return 0;
144     }
145
146     virtual Type getImg(int* _piCoordinates)
147     {
148         if (this->data)
149         {
150             int index = this->data->getIndex(_piCoordinates);
151             return this->data->getImg(index);
152         }
153
154         return 0;
155     }
156
157     virtual void setReal(int _iIndex, Type _dbl)
158     {
159         set(_iIndex, _dbl);
160     }
161     virtual void set(int _iIndex, Type _dbl)
162     {
163         if (this->data)
164         {
165             this->data->set(_iIndex, _dbl);
166         }
167     }
168
169     virtual void setImg(int _iIndex, Type _dbl)
170     {
171         if (this->data)
172         {
173             this->data->setImg(_iIndex, _dbl);
174         }
175     }
176
177     virtual void setReal(int* _piCoordinates, Type _dbl)
178     {
179         set(_piCoordinates, _dbl);
180     }
181     virtual void set(int* _piCoordinates, Type _dbl)
182     {
183         if (this->data)
184         {
185             int index = this->data->getIndex(_piCoordinates);
186             this->data->set(index, _dbl);
187         }
188     }
189
190     virtual void setImg(int* _piCoordinates, Type _dbl)
191     {
192         if (this->data)
193         {
194             int index = this->data->getIndex(_piCoordinates);
195             this->data->setImg(index, _dbl);
196         }
197     }
198
199     virtual void setReal(Type* _pdblCopy)
200     {
201         set(_pdblCopy);
202     }
203     virtual void set(Type* _pdblCopy)
204     {
205         if (this->data)
206         {
207             this->data->set(_pdblCopy);
208         }
209     }
210
211     virtual void setImg(Type* _pdblCopy)
212     {
213         if (this->data)
214         {
215             this->data->setImg(_pdblCopy);
216         }
217     }
218
219     virtual int getDims()
220     {
221         if (this->data)
222         {
223             return this->data->getDims();
224         }
225
226         return 0;
227     }
228
229     virtual int* getDimsArray()
230     {
231         if (this->data)
232         {
233             return this->data->getDimsArray();
234         }
235
236         return NULL;
237     }
238
239     virtual int getRows()
240     {
241         if (this->data)
242         {
243             return this->data->getRows();
244         }
245
246         return 0;
247     }
248
249     virtual int getCols()
250     {
251         if (this->data)
252         {
253             return this->data->getCols();
254         }
255
256         return 0;
257     }
258
259     virtual int getSize()
260     {
261         if (this->data)
262         {
263             return this->data->getSize();
264         }
265
266         return 0;
267     }
268
269     virtual bool isScalar()
270     {
271         if (this->data)
272         {
273             return this->data->getSize() == 1;
274         }
275
276         return false;
277     }
278
279     virtual bool isVector()
280     {
281         if (this->data)
282         {
283             return this->data->isVector();
284         }
285
286         return false;
287     }
288
289     virtual bool isRowVector()
290     {
291         if (this->data)
292         {
293             if (this->data->isVector() && this->data->getDimsArray()[0] != 1)
294             {
295                 return true;
296             }
297         }
298
299         return false;
300     }
301
302     virtual bool isColVector()
303     {
304         if (this->data)
305         {
306             if (this->data->isVector() && this->data->getDimsArray()[1] != 1)
307             {
308                 return true;
309             }
310         }
311
312         return false;
313     }
314
315     virtual bool isHypermatrix()
316     {
317         if (this->data)
318         {
319             return this->data->getDims() > 2;
320         }
321
322         return false;
323     }
324
325     virtual bool isComplex()
326     {
327         if (this->data)
328         {
329             return this->data->isComplex();
330         }
331
332         return false;
333     }
334
335     virtual void setComplex(bool _bComplex)
336     {
337         if (this->data)
338         {
339             this->data->setComplex(_bComplex);
340         }
341     }
342
343 };
344
345 template <class XType>
346 class Container : public VariableT<XType>
347 {
348
349 };
350 }
351 #endif /* ! __API_VARIABLE_HXX__ */
352