source: cpp/frams/util/extvalue.h @ 522

Last change on this file since 522 was 522, checked in by Maciej Komosinski, 8 years ago

Code formatting

  • Property svn:eol-style set to native
File size: 10.0 KB
RevLine 
[286]1// This file is a part of Framsticks SDK.  http://www.framsticks.com/
2// Copyright (C) 1999-2015  Maciej Komosinski and Szymon Ulatowski.
3// See LICENSE.txt for details.
[109]4
5#ifndef _EXTVALUE_H_
6#define _EXTVALUE_H_
7
8#include "sstring.h"
9#include <frams/param/param.h>
10#include <common/nonstd_stl.h>
11#include <common/threads.h>
12
13#define EXTVALUEUNION
[325]14template <int A, int B> struct CompileTimeMax { enum { val = A > B ? A : B }; };
[109]15#define EXTVALUEUNIONSIZE CompileTimeMax<sizeof(ExtObject),sizeof(SString)>::val
16
[482]17//#define DEBUG_EXTOBJECT(txt) printf("%p ExtObj::" txt "\n",this)
18#define DEBUG_EXTOBJECT(txt)
19
[109]20enum ExtPType
[325]21{
22        TUnknown = 0, TInt, TDouble, TString, TObj, TInvalid
23};
[109]24
25/**
26   destructable object
[325]27   */
[109]28class DestrBase
29{
30public:
[325]31        int refcount;
32        DestrBase() :refcount(0) {}
33        void incref() { refcount++; }
34        void decref() { refcount--; if (refcount == 0) delete this; }
35        virtual ~DestrBase() {}
[109]36};
37
[464]38enum SerializationFormat { NativeSerialization, JSONSerialization };
39
[109]40/**
41   object reference.
[325]42   */
[109]43class ExtObject
44{
[325]45        int subtype;                    //< 0/1=Generic/DPC Object,  0/2=Standalone/Shared Param
46        void incref() const;
47        void decref() const;
48public:
49        union {
50                void* object;           //< generic object, will use param
51                DestrBase *dbobject;    //< object with refcounting, will be deleted if refcount goes to 0
52        };
53        union {
54                Param* param;           //< if object!=0
55                ParamInterface *paraminterface; //< if object==0
56        };
[109]57
[325]58        void copyFrom(const ExtObject& src)  { subtype = src.subtype; object = src.object; param = src.param; }
[109]59
[325]60        void* operator new(size_t s, void* mem){ return mem; }
[109]61#ifdef _MSC_VER
[325]62                void operator delete(void* mem, void* t) {}
[109]63#endif
[325]64        void* operator new(size_t s){ return malloc(sizeof(ExtObject)); }
65        void operator delete(void* mem) { free(mem); }
66        ///@param tmp_param can be used for temporary storage, the result ParamInterface* is only valid for as long as tmp_param is valid
67        ParamInterface *getParamInterface(Param &tmp_param) const  { if (subtype & 2){ tmp_param.setParamTab(param->getParamTab()); tmp_param.select(object); return &tmp_param; } return paraminterface; }
68        const char* interfaceName() const { if (isEmpty()) return "Empty"; return (subtype & 2) ? param->getName() : paraminterface->getName(); }
69        bool matchesInterfaceName(ParamInterface* pi) const { return !strcmp(interfaceName(), pi->getName()); }
70        void* getTarget() const { return (subtype & 1) ? dbobject : object; }
71        void* getTarget(const char* classname, bool through_barrier = true, bool warn = true) const;
[522]72        bool callDelegate(const char* delegate, ExtValue *args, ExtValue *ret);
[325]73        void setEmpty() { decref(); subtype = 0; param = NULL; object = NULL; }
74        int isEmpty() const { return !param; }
[482]75        static const ExtObject& empty() { static const ExtObject e((ParamInterface*)NULL); return e; }
76        ExtObject(const ExtObject& src)      { DEBUG_EXTOBJECT("(const&)"); src.incref(); copyFrom(src); }
[325]77        void operator=(const ExtObject& src) { src.incref(); decref(); copyFrom(src); }
78        bool makeUnique();//< @return false if nothing has changed
[109]79
[325]80        bool operator==(const ExtObject& src) const;
[109]81
[325]82        SString toString() const;
[464]83        SString serialize_inner(SerializationFormat format) const;
84        SString serialize(SerializationFormat format) const;
[109]85
[522]86        ExtObject(Param *p, void *o) :subtype(2), object(o), param(p) { DEBUG_EXTOBJECT("(Param,void)"); }
[482]87        ExtObject(ParamInterface *p = 0) :subtype(0), object(0), paraminterface(p) { DEBUG_EXTOBJECT("(ParamInterface)"); }
88        ExtObject(Param *p, DestrBase *o) :subtype(1 + 2), dbobject(o), param(p){ DEBUG_EXTOBJECT("(Param,DestrBase)"); incref(); }
89        ExtObject(ParamInterface *p, DestrBase *o) :subtype(1), dbobject(o), paraminterface(p){ DEBUG_EXTOBJECT("(ParamInterface,DestrBase)"); incref(); }
[109]90
[482]91        ~ExtObject(){ DEBUG_EXTOBJECT("~"); decref(); }
[109]92
[325]93        class Serialization
94        {
95                std::vector<ExtObject> refs;
96                int level;
97        public:
98                Serialization() :level(0) {}
99                void begin();
100                void end();
101                int add(const ExtObject& o);
102                void replace(const ExtObject& o, const ExtObject& other);
103                void remove(const ExtObject& o);
104                const ExtObject* get(int ref);
105        };
[109]106
107};
108
[371]109extern THREAD_LOCAL_DECL(ExtObject::Serialization, ExtObject_serialization);
110
[109]111class ExtValue
112{
113public:
[325]114        ExtPType type;
[109]115#ifdef EXTVALUEUNION
[384]116        intptr_t data[(EXTVALUEUNIONSIZE + sizeof(intptr_t) - 1) / sizeof(intptr_t)];
[325]117        paInt& idata() const { return (paInt&)data[0]; };
118        double& ddata() const { return *(double*)data; };
119        ExtObject& odata() const { return *(ExtObject*)data; };
120        SString& sdata() const { return *(SString*)data; };
[109]121#else
[325]122        union {
123                paInt i;
124                double d;
125                SString *s;
126                ExtObject *o;
127        };
128        paInt& idata() const {return (paInt&)i;};
129        double& ddata() const {return (double&)d;};
130        ExtObject& odata() const {return *o;};
131        SString& sdata() const {return *s;};
[109]132#endif
133
[325]134        void* operator new(size_t s, void* mem){ return mem; }
135        void* operator new(size_t s){ return ::operator new(s); }
[109]136
[325]137                ExtValue() :type(TUnknown){}
138        ~ExtValue() { setEmpty(); }
139        ExtValue(paInt v) { seti(v); }
140        ExtValue(double v) { setd(v); }
141        ExtValue(const SString &v) { sets(v); }
142        ExtValue(const ExtObject &srco) { seto(srco); }
143        static ExtValue invalid() { ExtValue v; v.setInvalid(); return v; }
144        static const ExtValue& empty() { static const ExtValue v; return v; }
[333]145        static const ExtValue& zero() { static const ExtValue v(0); return v; }
146
147        enum CompareResult
148        {
[337]149                ResultLower = -1, ResultEqual = 0, ResultHigher = 1,
150                ResultEqualUnordered,
151                ResultUnequal_RelaxedEqual,
152                ResultUnequal_RelaxedUnequal,
153                ResultMismatch_RelaxedUnequal,
154                ResultMismatch
[333]155        };
156        // performs all script value comparisons.
157        // relaxed comparison (internal use only, not available in scripts) works like regular == with additional null~=0, notnull!~0
158        // and is used for pseudo-boolean conversion allowing for expressions like "if (null) ..."
159        CompareResult compare(const ExtValue& src) const;
160
[337]161        enum CmpOperator { CmpFIRST, CmpEQ = CmpFIRST, CmpNE, CmpGE, CmpLE, CmpGT, CmpLT,/*relaxed (not)equal*/CmpREQ, CmpRNE };
[333]162        static const char* cmp_op_names[];
[337]163        struct CmpContext { const ExtValue *v1, *v2; };
[333]164        // interpret compare() result, optional context controls error messages
165        // @return 0=false, 1=true, -1=undefined (null in script)
[337]166        static int interpretCompare(CmpOperator op, CompareResult result, CmpContext *context = NULL);
[333]167
[337]168        void divInt(paInt a);
169        void divDouble(double a);
170
[325]171        int operator==(const ExtValue& src) const;
172        void operator+=(const ExtValue& src);
173        void operator-=(const ExtValue& src);
174        void operator*=(const ExtValue& src);
175        void operator/=(const ExtValue& src);
176        void operator%=(const ExtValue& src);
177        void operator=(const ExtValue& src)
178        {
179                setr(src);
180        }
181        ExtValue(const ExtValue& src)
182                :type(TUnknown) {
183                set(src);
184        }
185        void setEmpty();
186        void setInvalid() { setEmpty(); type = TInvalid; }
[490]187        void setError(const SString& msg);
[325]188        bool makeUnique() { return (type == TObj) && odata().makeUnique(); } //< @return false if nothing has changed
[333]189        ExtPType getType() const { return type; }
[325]190        void *getObjectTarget(const char* classname, bool warn = true) const;
191        void setInt(paInt v) { if (type != TInt) setri(v); else idata() = v; }
192        void setDouble(double v) { if (type != TDouble) setrd(v); else ddata() = v; }
193        void setString(const SString &v) { if (type != TString) setrs(v); else sdata() = v; }
194        void setObject(const ExtObject &src) { if (type != TObj) setro(src); else odata() = src; }
[326]195        static bool parseInt(const char* s, paInt &result, bool strict, bool error);
196        static bool parseDouble(const char* s, double &result, bool error);
[325]197        static paInt getInt(const char* s, bool strict = false);//< @param strict=true will fail on floating point
198        static double getDouble(const char* s);
199        paInt getInt() const;
200        double getDouble() const;
201        SString getString() const;
202        const SString* getStringPtr() const;//< @return pointer to the internal sstring object or NULL if the current type is not string
[464]203        SString serialize(SerializationFormat format) const;
[325]204        ExtObject getObject() const;
205        bool isNull() const { return (type == TUnknown) || ((type == TObj) && odata().isEmpty()); }
206        SString typeDescription() const;//< @return human readable type name (used in error messages)
[337]207        SString typeAndValue() const;//< @return type and value (used in error messages)
[325]208        const char* parseNumber(const char* in, ExtPType strict_type = TUnknown);
209        const char* deserialize(const char* in);//< @return first character after the succesfully parsed string or NULL if failed
210        const char* deserialize_inner(const char* in);
211        static ParamInterface *findDeserializableClass(const char* name);
212        static PtrListTempl<ParamInterface*> &getDeserializableClasses();
213        template<typename T> class AddDeserializable
214        {
215        public:
216                AddDeserializable() { ExtValue::getDeserializableClasses() += &T::getStaticParam(); }
217        };
[222]218
[325]219        static SString format(SString& fmt, const ExtValue **values, int count);
[109]220
[325]221        ExtValue getExtType();
[109]222
[325]223private: // setrx - release and set, setx - assume released
224        void setr(const ExtValue& src){ setEmpty(); set(src); }
225        void set(const ExtValue& src);
226        void setri(paInt v) { setEmpty(); seti(v); }
227        void setrd(double v) { setEmpty(); setd(v); }
228        void seti(paInt v) { type = TInt; idata() = v; }
229        void setd(double v) { type = TDouble; ddata() = v; }
[109]230#ifdef EXTVALUEUNION
[325]231        void setrs(const SString &v) { setEmpty(); sets(v); }
232        void setro(const ExtObject &src) { setEmpty(); seto(src); }
233        void sets(const SString &v) { type = TString; new(data)SString(v); }
234        void seto(const ExtObject &src) { type = TObj; new(data)ExtObject(src); }
[109]235#else
[325]236        void setrs(const SString &v) {setEmpty();sets(v);}
237        void setro(const ExtObject &src) {setEmpty();seto(src);}
238        void sets(const SString &v) {type=TString;s=new SString(v);}
239        void seto(const ExtObject &src) {type=TObj;o=new ExtObject(src);}
[109]240#endif
241
242};
243
[222]244#define REGISTER_DESERIALIZABLE(name) ExtValue::AddDeserializable<name> deserializable_autoinit_ ## name;
[109]245
[522]246class ErrorObject : public DestrBase
[490]247{
[522]248public:
249        SString message;
250        static Param& getParam();
251        static Param& getStaticParam() { return getParam(); }
252        static ExtObject makeDynamicObject(ErrorObject* e);
253        static const SString TO_STRING_PREFIX;
[490]254#define STATRICKCLASS ErrorObject
[522]255        PARAMGETDEF(toString);
256        PARAMPROCDEF(p_newfromstring);
[490]257#undef STATRICKCLASS
258};
259
[109]260#endif
Note: See TracBrowser for help on using the repository browser.