source: cpp/frams/param/paramtrans.cpp @ 884

Last change on this file since 884 was 731, checked in by Maciej Komosinski, 6 years ago

Code formatting

File size: 5.8 KB
RevLine 
[729]1#include "paramtrans.h"
2#include <frams/util/extvalue.h>
3
4void TwoWayMap::printList(const SListTempl<int>& L)
5{
[731]6        for (int i = 0; i < L.size(); i++)
[729]7        {
[731]8                int x = L(i);
9                if (x >= 0) printf("%d", x);
10                else printf("x");
[729]11        }
12}
13
14void TwoWayMap::print()
15{
[731]16        printList(map);
17        printf("/");
18        printList(invmap);
[729]19}
20
21void TwoWayMap::reset(int size)
22{
[731]23        map.clear(); invmap.clear();
24        for (int i = 0; i < size; i++)
[729]25        {
[731]26                map.set(i, i);
27                invmap.set(i, i);
[729]28        }
29}
30
31/** @return -2 = out of bounds */
32int TwoWayMap::get(int pos)
33{
[731]34        if ((pos < 0) || (pos >= map.size())) return -2;
35        return map(pos);
[729]36}
37
38/** @return -2 = out of bounds */
39int TwoWayMap::invget(int pos)
40{
[731]41        if ((pos < 0) || (pos >= invmap.size())) return -2;
42        return invmap(pos);
[729]43}
44
45void TwoWayMap::insert(int i)
[731]46{
47        // map/invmap: 01234/01234 add(1) -> 0-1234/02345
48        //             1--40-2/406-3 add(1) -> 1---40-2/507-4
49        map.insert(i, -1);
50        for (int p = i + 1; p < map.size(); p++)
[729]51        {
[731]52                int x = map(p);
53                if (x >= 0)
54                        invmap.set(x, p);
[729]55        }
56}
57
58void TwoWayMap::remove(int i)
59{
[731]60        // map/invmap: 01234/01234 rem(1) -> 0234/0-123
61        //             1--40-2/406-3 rem(1) -> 1-40-2/305-2
62        int x = map(i);
63        if (x >= 0) invmap.set(x, -1);
64        map.remove(i);
65        for (int p = i; p < map.size(); p++)
[729]66        {
[731]67                int x = map(p);
68                if (x >= 0)
69                        invmap.set(x, p);
[729]70        }
71}
72
73///////////////////////////
74
75ParamTransaction::ParamTransaction(MutableParamInterface &mpi)
76        :par(mpi)
77{
[731]78        panode = par.onadd.add(STATRICKCALLBACK(this, &ParamTransaction::onPropAdd, 0));
79        pdnode = par.ondelete.add(STATRICKCALLBACK(this, &ParamTransaction::onPropDelete, 0));
80        pcnode = par.onchange.add(STATRICKCALLBACK(this, &ParamTransaction::onPropChange, 0));
81        ganode = par.ongroupadd.add(STATRICKCALLBACK(this, &ParamTransaction::onGroupAdd, 0));
82        gdnode = par.ongroupdelete.add(STATRICKCALLBACK(this, &ParamTransaction::onGroupDelete, 0));
83        gcnode = par.ongroupchange.add(STATRICKCALLBACK(this, &ParamTransaction::onGroupChange, 0));
84        reset();
[729]85}
86
87ParamTransaction::~ParamTransaction()
88{
[731]89        par.onadd.removeNode(panode);
90        par.ondelete.removeNode(pdnode);
91        par.onchange.removeNode(pcnode);
92        par.ongroupadd.removeNode(ganode);
93        par.ongroupdelete.removeNode(gdnode);
94        par.ongroupchange.removeNode(gcnode);
[729]95}
96
97void ParamTransaction::reset()
98{
[731]99        resetMaps();
100        changed = false;
101        grchanged = false;
[729]102}
103
[731]104void ParamTransaction::onPropAdd(void* data, intptr_t i)
[729]105{
[731]106        propmap.insert((int)i);
107        changed = true;
[729]108}
109
[731]110void ParamTransaction::onPropDelete(void* data, intptr_t i)
[729]111{
[731]112        propmap.remove((int)i);
113        changed = true;
[729]114}
115
[731]116void ParamTransaction::onGroupAdd(void* data, intptr_t i)
[729]117{
[731]118        groupmap.insert((int)i);
119        grchanged = true;
[729]120}
121
[731]122void ParamTransaction::onGroupDelete(void* data, intptr_t i)
[729]123{
[731]124        groupmap.remove((int)i);
125        grchanged = true;
[729]126}
127
[731]128void ParamTransaction::onPropChange(void* data, intptr_t i)
[729]129{
[731]130        changed = true;
[729]131}
132
[731]133void ParamTransaction::onGroupChange(void* data, intptr_t i)
[729]134{
[731]135        grchanged = true;
[729]136}
137
138void ParamTransaction::resetMaps()
139{
[731]140        propmap.reset(par.getPropCount());
141        groupmap.reset(par.getGroupCount());
[729]142}
143
144int ParamTransaction::propertyPosition(int prop)
[731]145{
146        return propmap.invget(prop);
147}
[729]148
149int ParamTransaction::groupPosition(int group)
[731]150{
151        return groupmap.invget(group);
152}
[729]153
154const char * ParamTransaction::id(int i)
155{
[731]156        i = propertyPosition(i);
157        if (i == -2) return 0;
158        if (i >= 0) return par.id(i); else return "?";
[729]159}
160
161const char * ParamTransaction::name(int i)
162{
[731]163        i = propertyPosition(i);
164        if (i == -2) return 0;
165        if (i >= 0) return par.name(i); else return "?";
[729]166}
167
168const char * ParamTransaction::type(int i)
169{
[731]170        i = propertyPosition(i);
171        if (i == -2) return 0;
172        if (i >= 0) return par.type(i); else return "?";
[729]173}
174
175const char * ParamTransaction::help(int i)
176{
[731]177        i = propertyPosition(i);
178        return (i >= 0) ? par.help(i) : 0;
[729]179}
180
181int ParamTransaction::flags(int i)
182{
[731]183        i = propertyPosition(i);
184        return (i >= 0) ? par.flags(i) : 0;
[729]185}
186
187int ParamTransaction::group(int i)
188{
[731]189        i = propertyPosition(i);
190        return (i >= 0) ? par.group(i) : 0;
[729]191}
192
193const char * ParamTransaction::grname(int i)
194{
[731]195        i = groupPosition(i);
196        if (i == -2) return 0;
197        return (i >= 0) ? par.grname(i) : "?";
[729]198}
199
200int ParamTransaction::grmember(int g, int i)
201{
[731]202        g = groupPosition(g);
203        if (g < 0) return -9999;
204        for (int p = 0; p < getPropCount(); p++)
205                if (group(p) == g)
206                        if (!i--)
207                                return p;
208        return -9999;
[729]209}
210
211void ParamTransaction::call(int i, ExtValue *a, ExtValue *b)
212{
[731]213        i = propertyPosition(i);
214        if (i >= 0) par.call(i, a, b);
[729]215}
216
217SString ParamTransaction::getString(int i)
218{
[731]219        i = propertyPosition(i);
220        return (i >= 0) ? par.getString(i) : SString();
[729]221}
222
223paInt ParamTransaction::getInt(int i)
224{
[731]225        i = propertyPosition(i);
226        return (i >= 0) ? par.getInt(i) : 0;
[729]227}
228
229double ParamTransaction::getDouble(int i)
230{
[731]231        i = propertyPosition(i);
232        return (i >= 0) ? par.getDouble(i) : 0;
[729]233}
234
235ExtObject ParamTransaction::getObject(int i)
236{
[731]237        i = propertyPosition(i);
238        return (i >= 0) ? par.getObject(i) : ExtObject();
[729]239}
240
241ExtValue ParamTransaction::getExtValue(int i)
242{
[731]243        i = propertyPosition(i);
244        return (i >= 0) ? par.getExtValue(i) : ExtValue();
[729]245}
246
247int ParamTransaction::setInt(int i, paInt v)
248{
[731]249        i = propertyPosition(i);
250        return (i >= 0) ? par.setInt(i, v) : PSET_NOPROPERTY;
[729]251}
252
253int ParamTransaction::setDouble(int i, double v)
254{
[731]255        i = propertyPosition(i);
256        return (i >= 0) ? par.setDouble(i, v) : PSET_NOPROPERTY;
[729]257}
258
259int ParamTransaction::setString(int i, const SString &v)
260{
[731]261        i = propertyPosition(i);
262        return (i >= 0) ? par.setString(i, v) : PSET_NOPROPERTY;
[729]263}
264
265int ParamTransaction::setObject(int i, const ExtObject &v)
266{
[731]267        i = propertyPosition(i);
268        return (i >= 0) ? par.setObject(i, v) : PSET_NOPROPERTY;
[729]269}
270
271int ParamTransaction::setExtValue(int i, const ExtValue &v)
272{
[731]273        i = propertyPosition(i);
274        return (i >= 0) ? par.setExtValue(i, v) : PSET_NOPROPERTY;
[729]275}
Note: See TracBrowser for help on using the repository browser.