# source:cpp/frams/vm/classes/collectionobj.cpp@648

Last change on this file since 648 was 648, checked in by Maciej Komosinski, 7 years ago

Warn when trying to remove non-existing indexed object

• Property svn:eol-style set to `native`
File size: 15.3 KB
Line
1// This file is a part of Framsticks SDK.  http://www.framsticks.com/
2// Copyright (C) 1999-2015  Maciej Komosinski and Szymon Ulatowski.
4
5#include "collectionobj.h"
6#include <common/nonstd_math.h> //sqrt in borland
7#include <frams/util/validitychecks.h>
8#include <common/nonstd_stl.h>
9#include <frams/util/sstringutils.h>
10#ifndef NO_VMACHINE
11#include <frams/vm/vmachine.h>
12#endif
13
14#define FIELDSTRUCT VectorObject
15ParamEntry vector_paramtab[]=
16{
17{"Vector",1,15,"Vector","Vector is a 1-dimensional array indexed by an integer value (starting from 0). "
18 "Multidimensional arrays can be simulated by putting other Vector objects into a Vector.\n"
19"Examples:\n"
20"\tvar v1=Vector.new();\n"
23"A short way of doing the same (square brackets create a vector):\n"
24"\tvar v2=[123,\"string\"];\n"
25"Simulate a 2D array:\n"
26"\tvar v3=[[1,2,3],[4,5],[6]];\n"
27"You can iterate directly over values of a Vector using for(...in...) loops:\n"
28"\tfor(var element in v3) Simulator.print(element);"
29},
30{"clear",0,PARAM_NOSTATIC,"Clear data","p()",PROCEDURE(p_clear),},
32{"remove",0,PARAM_NOSTATIC,"Remove at position","p(d position)",PROCEDURE(p_remove),},
33{"get",0,PARAM_NOSTATIC,"Get value at position","p x(d position)",PROCEDURE(p_get),"object[position] can be always used instead of object.get(position)"},
34{"set",0,PARAM_NOSTATIC,"Set value at position","p(d position,x value)",PROCEDURE(p_set),"object[position]=value can be always used instead of object.set(position,value)"},
35{"insert",0,PARAM_NOSTATIC,"Insert value at position","p(d position,x value)",PROCEDURE(p_insert),},
39{"stdev",0,PARAM_READONLY | PARAM_NOSTATIC,"Standard deviation","f",GETONLY(stdev),"=sqrt(sum((element[i]-avg)^2)/(size-1)) which is estimated population std.dev. from sample std.dev."},
41{"new",0,0,"Create new Vector","p oVector()",STATICPROCEDURE(p_new),},
42{"sort",0,PARAM_NOSTATIC,"Sort elements (in place)","p(oFunctionReference comparator)",PROCEDURE(p_sort),"comparator can be null, giving the \"natural\" sorting order (depending on element type), otherwise it must be a function reference obtained from the 'function' operator.\n\nExample:\nfunction compareLastDigit(a,b) {return (a%10)<(b%10);}\nvar v=[16,23,35,42,54,61];\nv.sort(function compareLastDigit);"},
44{"clone",0,PARAM_NOSTATIC,"Create a clone","p oVector()",PROCEDURE(p_clone),"The resulting clone is a shallow copy (contains the same object references as the original). A deep copy can be obtained through serialization: String.deserialize(String.serialize(object));"},
45{0,0,0,},
46};
47#undef FIELDSTRUCT
48
49#define FIELDSTRUCT DictionaryObject
50ParamEntry dictionary_paramtab[]=
51{
52{"Dictionary",1,11,"Dictionary","Dictionary associates stored values with string keys "
53 "(\"key\" is the first argument in get/set/remove functions). Integer key can be "
54 "used to enumerate all elements (note that while iterating, the elements are returned in no particular order).\n"
55 "Examples:\n"
56 "\tvar d;\n"
57 "\td=Dictionary.new();\n"
58 "\td.set(\"name\",\"John\");\n"
59 "\td.set(\"age\",44);\n"
60 "Another way of doing the same:\n"
61 "\td={};\n"
62 "\td[\"name\"]=\"John\";\n"
63 "\td[\"age\"]=44;\n"
64 "And the most concise way:\n"
65 "\td={ \"name\":\"John\", \"age\":44 };\n"
66 "Iterating:\n"
67 "\tfor(var i=0;i<d.size;i++) Simulator.print(d.getKey(i)+\" is \"+d.get(i));",
68},
69{"clear",0,PARAM_NOSTATIC,"Clear data","p()",PROCEDURE(p_clear),},
71{"remove",0,PARAM_NOSTATIC,"Remove","p(x key)",PROCEDURE(p_remove),"Removes the named or indexed element (depending on the argument type: string or int)."},
72{"get",0,PARAM_NOSTATIC,"Get element","p x(x key)",PROCEDURE(p_get),"Retrieves the named or indexed element (depending on the argument type: string or int). null is returned for nonexistent keys.\nobject.get(key) can be shortened to 'object[key]'"},
73{"getKey",0,PARAM_NOSTATIC,"Get a key","p s(d index)",PROCEDURE(p_getKey),"Returns the key of the indexed element (0 <= index < size)"},
74{"set",0,PARAM_NOSTATIC,"Set element","p x(x key,x value)",PROCEDURE(p_set),"Set element value for the specified key or index (depending on the argument type: string or int).\n"
75"Returns the value previously associated with the given key (or index).\n"
76"object.set(key,value) can be shortened to object[key]=value. Literal string keys can use even shorter notation: object->key=value instead of object.set(\"key\",value)\n"
77"Note the difference in the returned value:\n"
78"  var old_value=object.set(\"key\",new_value); //'old_value' gets the value previously associated with \"key\"\n"
79"  var x=object[\"key\"]=new_value; //'x' becomes 'new_value', consistently with the semantics of the assignment operator. The value previously associated with \"key\" is lost."},
81{"new",0,0,"Create a Dictionary","p oDictionary()",STATICPROCEDURE(p_new),"Empty directory can be also created using the {} expression."},
83{"clone",0,PARAM_NOSTATIC,"Create a clone","p oDictionary()",PROCEDURE(p_clone),"The resulting clone is a shallow copy (contains the same object references as the original). A deep copy can be obtained through serialization: String.deserialize(String.serialize(object));"},
84{"assign",0,PARAM_NOSTATIC,"Assign from another object","p(x)",PROCEDURE(p_assign),"Replaces current dictionary with dictionary contents from another object."},
85
86{0,0,0,},
87};
88#undef FIELDSTRUCT
89
90Param VectorObject::par(vector_paramtab);
91Param DictionaryObject::par(dictionary_paramtab);
92
93/////////////////////////////////////////
94
95VectorObject::VectorObject(Pt3D &pt)
97{
98set_or_insert(0,ExtValue(pt.x),false);
99set_or_insert(1,ExtValue(pt.y),false);
100set_or_insert(2,ExtValue(pt.z),false);
101}
102
103void VectorObject::clear()
104{
105if (owndata)
106for(int i=data.size()-1;i>=0;i--)
107        {
108        ExtValue *v=(ExtValue*)data.get(i);
109        if (v) delete v;
110        }
111data.clear();
112}
113
114void VectorObject::p_remove(PARAMPROCARGS)
115{
117int i=args->getInt();
118if (!listIndexCheck(&data,i,"VectorObject","remove")) return;
119ExtValue *v=(ExtValue*)data.get(i);
120if (v) delete v;
121data-=i;
122}
123
124void VectorObject::set_or_insert(int i,const ExtValue& val,bool insert)
125{
126if (i<0) return;
127int oldsize=data.size();
128if (i>oldsize)
129        {
130        data.setSize(i);
131        while(i>oldsize)
132                data.set(oldsize++,0);
133        }
134if (insert)
135        data.insert(i,new ExtValue(val));
136else
137        {
138        ExtValue *v=(ExtValue*)data.get(i);
139        if (v) delete v;
140        data.set(i,new ExtValue(val));
141        }
142}
143
144void VectorObject::p_get(PARAMPROCARGS)
145{
146int i=args->getInt();
147if (listIndexCheck(&data,i,"VectorObject","get"))
148        {
149        ExtValue *v=get(i);
150        if (v)
151                {
152                *ret=*v;
153                return;
154                }
155        }
156*ret=ExtValue();
157}
158
159void VectorObject::get_avg(ExtValue* ret)
160{
161if (!data.size()) {ret->setEmpty(); return;}
162double s=0.0;
163for(int i=data.size()-1;i>=0;i--)
164        s+=((ExtValue*)data.get(i))->getDouble();
165s/=data.size();
166ret->setDouble(s);
167}
168
169SString VectorObject::serialize(SerializationFormat format) const
170{
171SString out="[";
172        {
173        for(int i=0;i<data.size();i++)
174                {
175                ExtValue* v=(ExtValue*)data.get(i);
176                if (i) out+=",";
177                if (v)
178                        out+=v->serialize(format);
179                else
180                        out+="null";
181                }
182        }
183out+="]";
184//sprintf(out.directAppend(20),"<Vector@%p>",this);out.endAppend();
185return out;
186}
187
189
190void VectorObject::get_toString(ExtValue* ret)
191{
192SString out="[";
193//static SListTempl<VectorObject*> trace;
194if (tlsGetRef(VectorObject_tostring_trace).find(this)>=0)
195        out+="...";
196else
197        {
198        tlsGetRef(VectorObject_tostring_trace)+=this;
199        for(int i=0;i<data.size();i++)
200                {
201                ExtValue* v=(ExtValue*)data.get(i);
202                if (i) out+=",";
203                if (v)
204                        out+=v->getString();
205                else
206                        out+="null";
207                }
208        tlsGetRef(VectorObject_tostring_trace)-=this;
209        }
210out+="]";
211ret->setString(out);
212}
213
214void VectorObject::get_stdev(ExtValue* ret)
215{
216if (!data.size()) {ret->setEmpty(); return;}
217get_avg(ret);
218double a=ret->getDouble();
219double s=0.0;
220for(int i=data.size()-1;i>=0;i--)
221        {
222        double d=a-((ExtValue*)data.get(i))->getDouble();
223        s+=d*d;
224        }
225ret->setDouble(sqrt(s/max(1,data.size()-1)));
226}
227
228void VectorObject::p_find(PARAMPROCARGS)
229{
230short i;
231for(i=0;i<data.size();i++)
232        {
233        if ((*args)==(*get(i)))
234                {ret->setInt(i);return;}
235        }
236ret->setInt(-1);
237}
238
239void VectorObject::p_clone(PARAMPROCARGS)
240{
241VectorObject *c=new VectorObject;
242c->data.setSize(data.size());
243for(int i=0;i<data.size();i++)
244        {
245        ExtValue *v=(ExtValue*)get(i);
246        if (v)
247                c->data.set(i,new ExtValue(*v));
248        }
249ret->setObject(ExtObject(&par,c));
250}
251
252class VEComparator
253{
254public:
255bool operator()(const ExtValue *a,const ExtValue *b) {return a->compare(*b)==ExtValue::ResultLower;}
256};
257
258#ifndef NO_VMACHINE
259class VMVEComparator
260{
261public:
262VMachine::JumpTargetObject *jto;
263VMachine *vm;
264VMVEComparator(VMachine::JumpTargetObject *_jto):jto(_jto),vm(jto->vm) {}
265bool operator()(const ExtValue *a,const ExtValue *b);
266};
267
268bool VMVEComparator::operator()(const ExtValue *a,const ExtValue *b)
269{
270if (!VMCode::prepareDynamicJumpTarget(jto->pc,jto->code))
271        return false;
272
273vm->push(*a);
274vm->push(*b);
275vm->pushNewCallState();
276vm->jumpDynamicJumpTarget(jto->pc);
277vm->run();
278vm->popCallState();
279bool ret;
280ExtValue& retval=vm->getValue();
281if (retval.type==TInvalid)
282        {
283        ret=false;
284        logPrintf("VectorElementComparator","",LOG_ERROR,"Comparison function returned no value");
285        }
286else
287        ret=(retval.getInt()!=0);
288vm->drop(2);
289return ret;
290}
291#endif
292
293void VectorObject::p_sort(PARAMPROCARGS)
294{
295#ifndef NO_VMACHINE
296VMachine::JumpTargetObject *jto=VMachine::JumpTargetObject::fromObject(args->getObject(),false);
297if (jto)
298        {
299        VMVEComparator cmp(jto);
300        ExtValue **first=(ExtValue**)&data.getref(0);
301        std::sort(first,first+data.size(),cmp);
302        }
303else
304#endif
305        {
306        VEComparator cmp;
307        ExtValue **first=(ExtValue**)&data.getref(0);
308        std::sort(first,first+data.size(),cmp);
309        }
310ret->setEmpty();
311}
312
313void VectorObject::get_iterator(ExtValue* ret)
314{
315ret->setObject(VectorIterator::makeFrom(this));
316}
317
318VectorObject* VectorObject::fromObject(const ExtObject& o, bool warn)
319{
320return (VectorObject*)o.getTarget(par.getName(),true,warn);
321}
322
323/////////////////////////////
324
325void DictionaryObject::clear()
326{
327for(HashEntryIterator it(hash);it.isValid();)
328        {
329        ExtValue *v=(ExtValue*)hash.remove(it);
330        if (v) delete v;
331        }
332hash.clear();
333hash.init();
334}
335
336void DictionaryObject::p_find(PARAMPROCARGS)
337{
338for(HashEntryIterator it(hash);it.isValid();it++)
339        {
340        if ((*args)==(*((ExtValue*)it->value)))
341                {
342                ret->setString(it->key);
343                return;
344                }
345        }
346ret->setEmpty();
347}
348
349HashEntryIterator* DictionaryObject::getIndexIterator(int i)
350{
351if (i<0) return 0;
352if (i>=hash.getSize()) return 0;
353
354if ((!it.isValid())||(it_index>i))
355        {
356        it=HashEntryIterator(hash);
357        it_index=0;
358        }
359while(it.isValid())
360        {
361        if (it_index==i)
362                return &it;
363        it_index++;
364        it++;
365        }
366return 0;
367}
368
369void DictionaryObject::p_remove(PARAMPROCARGS)
370{
371if ((args->type==TInt)||(args->type==TDouble))
372        {
373        HashEntryIterator* iter=getIndexIterator(args->getInt());
374        if (iter)
375                {
376                ExtValue *oldval=(ExtValue*)hash.remove(*iter);
377                if (oldval) {*ret=*oldval; delete oldval;} else *ret=ExtValue();
378                }
379        }
380else
381        {
382        ExtValue *oldval=(ExtValue*)hash.remove(args[0].getString());
383        if (oldval) {*ret=*oldval; delete oldval;} else *ret=ExtValue();
384        }
385}
386
387ExtValue DictionaryObject::get(SString key)
388{
389ExtValue *val=(ExtValue*)hash.get(key);
390if (val)
391        return *val;
392return ExtValue::empty();
393}
394
395ExtValue DictionaryObject::get(int index)
396{
397HashEntryIterator* iter=getIndexIterator(index);
398if (iter && (*iter)->value)
399        return *((ExtValue*)(*iter)->value);
400return ExtValue::empty();
401}
402
403void DictionaryObject::p_get(PARAMPROCARGS)
404{
405if ((args->type==TInt)||(args->type==TDouble))
406        *ret=get(args->getInt());
407else
408        *ret=get(args[0].getString());
409}
410
411void DictionaryObject::p_getKey(PARAMPROCARGS)
412{
413HashEntryIterator* iter=getIndexIterator(args->getInt());
414if (iter)
415        {
416        *ret=(*iter)->key;
417        return;
418        }
419*ret=ExtValue();
420}
421
422ExtValue DictionaryObject::set(SString key,ExtValue new_value)
423{
424ExtValue ret;
425ExtValue *new_ext=(new_value.getType()==TUnknown) ? NULL : new ExtValue(new_value);
426ExtValue *old_ext=(ExtValue*)hash.put(key,new_ext);
427if (old_ext) { ret=*old_ext; delete old_ext;}
428return ret;
429}
430
431void DictionaryObject::p_set(PARAMPROCARGS)
432{
433*ret=set(args[1].getString(),args[0]);
434}
435
436SString DictionaryObject::serialize(SerializationFormat format) const
437{
438SString out="{";
439        {
440        for(HashEntryIterator it(hash);it.isValid();)
441                {
442                out+="\"";
443                SString q=it->key; sstringQuote(q);
444                out+=q;
445                out+="\":";
446                if (it->value!=NULL)
447                        out+=((ExtValue*)it->value)->serialize(format);
448                else
449                        out+="null";
450                it++;
451                if (it.isValid()) out+=",";
452                }
453        }
454out+="}";
455return out;
456}
457
458void DictionaryObject::get_toString(ExtValue* ret)
459{
460SString out="{";
461//static SListTempl<DictionaryObject*> trace;
462if (tlsGetRef(VectorObject_tostring_trace).find(this)>=0)
463        out+="...";
464else
465        {
466        tlsGetRef(VectorObject_tostring_trace)+=this;
467        for(HashEntryIterator it(hash);it.isValid();)
468                {
469                out+=it->key;
470                out+=":";
471                if (it->value!=NULL)
472                        out+=((ExtValue*)it->value)->getString();
473                else
474                        out+="null";
475                it++;
476                if (it.isValid()) out+=",";
477                }
478        tlsGetRef(VectorObject_tostring_trace)-=this;
479        }
480out+="}";
481ret->setString(out);
482}
483
484void DictionaryObject::copyFrom(DictionaryObject *other)
485{
486for(HashEntryIterator it(other->hash);it.isValid();it++)
487        {
488        ExtValue *v=(ExtValue*)it->value;
489        hash.put(it->key,v?new ExtValue(*v):NULL);
490        }
491}
492
493void DictionaryObject::p_clone(PARAMPROCARGS)
494{
495DictionaryObject *c=new DictionaryObject;
496c->copyFrom(this);
497ret->setObject(ExtObject(&par,c));
498}
499
500void DictionaryObject::p_assign(PARAMPROCARGS)
501{
502clear();
503DictionaryObject *other=DictionaryObject::fromObject(args[0].getObject(),false);
504if (other)
505                copyFrom(other);
506ret->setEmpty();
507}
508
509DictionaryObject* DictionaryObject::fromObject(const ExtObject& o, bool warn)
510{
511return (DictionaryObject*)o.getTarget(par.getName(), true, warn);
512}
513
514////////////////
515
516VectorIterator::VectorIterator(VectorObject* v)
517{
518vec=v;
519vec->incref();
520pos=-1;
521}
522
523#define FIELDSTRUCT VectorIterator
524ParamEntry vectoriterator_paramtab[]=
525{
526 {"VectorIterator",1,2,"VectorIterator","VectorIterator"},
529{0,0,0,},
530};
531#undef FIELDSTRUCT
532
533ExtObject VectorIterator::makeFrom(VectorObject *v)
534{
535static Param par(vectoriterator_paramtab);
536return ExtObject(&par,new VectorIterator(v));
537}
538
539VectorIterator::~VectorIterator()
540{
541vec->decref();
542}
543
544void VectorIterator::get_next(ExtValue* ret)
545{
546pos++;
547ret->setInt((pos < vec->data.size()) ? 1 : 0);
548}
549
550void VectorIterator::get_value(ExtValue* ret)
551{
552ExtValue *v=(ExtValue*) (((pos>=0)&&(pos<vec->data.size())) ? vec->data(pos) : NULL );
553if (v)
554        *ret=*v;
555else
556        ret->setEmpty();
557}
558
559// not actually needed for deserialization (vector and dict are special cases) but findDeserializableClass can be also used in other contexts
560REGISTER_DESERIALIZABLE(VectorObject)
561REGISTER_DESERIALIZABLE(DictionaryObject)
Note: See TracBrowser for help on using the repository browser.