Changeset 104 for cpp/gdk/extvalue.cpp

Timestamp:

07/23/13 18:15:30 (11 years ago)

Author:

sz

Message:

introducing object de/serialization - see serialtest.cpp
the core GDK classes can be now used in multiple threads (ifdef MULTITHREADED)

File:

• cpp/gdk/extvalue.cpp (modified) (4 diffs)

cpp/gdk/extvalue.cpp

@@ -5 +5 @@
 #include "extvalue.h"
 #include "param.h"
+#include "sstringutils.h"
 #include <math.h>
+#include <ctype.h>
+#include "collectionobj.h"
+#include "3dobject.h"
 
 SString ExtObject::toString() const
 {
 if (isEmpty()) return SString("<empty object>");
-ParamInterface *p=getParamInterface();
+Param tmp_param;
+ParamInterface *p=getParamInterface(tmp_param);
 int tostr=p->findId("toString");
 if (tostr>=0)
@@ -25 +30 @@
         return tmp;
         }
+}
+
+ThreadSingleton<ExtObject::Serialization> ExtObject::serialization;
+
+void ExtObject::Serialization::begin()
+{
+if (level==0)
+        refs.clear();
+level++;
+}
+
+int ExtObject::Serialization::add(const ExtObject &o)
+{
+if (o.isEmpty()) return -1;
+for(int i=0;i<refs.size();i++)
+        {
+        ExtObject& r=refs[i];
+        if (r==o) return i;
+        }
+refs.push_back(o);
+return -1;
+}
+
+void ExtObject::Serialization::replace(const ExtObject& o,const ExtObject& other)
+{
+if (o.isEmpty()) return;
+for(int i=0;i<refs.size();i++)
+        {
+        ExtObject& r=refs[i];
+        if (r==o)
+                {
+                r=other;
+                return;
+                }
+        }
+}
+
+void ExtObject::Serialization::remove(const ExtObject& o)
+{
+if (o.isEmpty()) return;
+for(int i=0;i<refs.size();i++)
+        {
+        ExtObject& r=refs[i];
+        if (o==r) refs.erase(refs.begin()+i);
+        }
+}
+
+const ExtObject* ExtObject::Serialization::get(int ref)
+{
+if (ref<0) return NULL;
+if (ref>=refs.size()) return NULL;
+return &refs[ref];
+}
+
+void ExtObject::Serialization::end()
+{
+level--;
+if (level==0)
+        refs.clear();
+}
+
+SString ExtObject::serialize_inner() const
+{
+int ref=serialization.getref().add(*this);
+if (ref>=0)
+        {
+        SString ret;
+        sprintf(ret.directAppend(20),"^%d",ref);ret.endAppend();
+        return ret;
+        }
+
+if (isEmpty()) return SString();
+VectorObject *vec=VectorObject::fromObject(*this);
+if (vec)
+        return vec->serialize();
+DictionaryObject *dic=DictionaryObject::fromObject(*this);
+if (dic)
+        return dic->serialize();
+Param tmp_param;
+ParamInterface *p=getParamInterface(tmp_param);
+int m=p->findId("toVector");
+if (m<0) 
+        m=p->findId("toDictionary");
+if (m>=0)
+        {
+        ExtObject o(p->getObject(m));
+        SString ret=SString(interfaceName())+o.serialize();
+        return ret;
+        }
+m=p->findId("toString");
+if (m>=0)
+        {
+        SString str=p->getString(m);
+        sstringQuote(str);
+        SString ret=SString(interfaceName())+"\""+str+"\"";
+        return ret;
+        }
+
+SString ret=interfaceName();
+sprintf(ret.directAppend(30),"<%p>",object?object:paraminterface);ret.endAppend();
+return ret;
+}
+
+SString ExtObject::serialize() const
+{
+serialization.getref().begin();
+SString ret=serialize_inner();
+serialization.getref().end();
+return ret;
 }
 
@@ -297 +411 @@
 }
 
+SString ExtValue::serialize() const
+{
+switch(type)
+        {
+        case TString:
+                {
+                SString q=sdata();
+                sstringQuote(q);
+                return SString("\"")+q+SString("\"");
+                }
+        case TInt:
+                {
+                SString tmp;
+                sprintf(tmp.directAppend(20),"%d",idata());
+                tmp.endAppend();
+                return tmp;
+                }
+        case TDouble:
+                {
+                SString tmp;
+                sprintf(tmp.directAppend(20),"%.15g",ddata());
+                tmp.endAppend();
+                if ((!strchr(tmp,'.'))&&(!strchr(tmp,'e'))) tmp+=".0";
+                return tmp;
+                }
+        case TObj:
+                return odata().serialize();
+        case TInvalid:
+                return SString("undefined");
+        default:
+                return SString("null");
+        }
+}
+
+//returns the first character after the parsed number or NULL if not a number
+const char* ExtValue::parseNumber(const char* in)
+{
+if (isdigit(*in)||((*in=='-')&&(isdigit(in[1]))))
+        {
+        const char* p=in;
+        if (*p=='-') p++;
+        while(isdigit(*p)) p++;
+        bool fp=false;
+        if ((*p=='.') && isdigit(p[1]))
+                {
+                p++;
+                while(isdigit(*p)) p++;
+                fp=true;
+                }
+        if (((*p=='e')||(*p=='E')) && (isdigit(p[1]) || (((p[1]=='-') || (p[1]=='+')) && isdigit(p[2]))))
+                {
+                p++;
+                if ((*p=='-')||(*p=='+')) p++;
+                while(isdigit(*p)) p++;
+                fp=true;
+                }
+
+        if (fp)
+                {
+                setDouble(atof(in));
+                return p;
+                }
+        else
+                {
+                setInt(atol(in));
+                return p;
+                }
+        }
+return NULL;
+}
+
+PtrListTempl<ParamInterface*> ExtValue::deserializable_classes;
+
+void ExtValue::initDeserializableClasses()
+{
+deserializable_classes+=&Pt3D_Ext::getStaticParam();
+deserializable_classes+=&Orient_Ext::getStaticParam();
+}
+
+ParamInterface *ExtValue::findDeserializableClass(const char* name)
+{
+FOREACH(ParamInterface*,cls,deserializable_classes)
+        if (!strcmp(cls->getName(),name))
+                return cls;
+return NULL;
+}
+
+static const char* skipWord(const char* in)
+{
+while(isalpha(*in))
+        in++;
+return in;
+}
+
+//returns the first character after the parsed portion or NULL if invalid format
+const char* ExtValue::deserialize_inner(const char* in)
+{
+const char* ret=parseNumber(in);
+if (ret)
+        return ret;
+else if (*in=='\"')
+        {
+        ret=skipQuoteString(in+1,NULL);
+        SString s(in+1,ret-(in+1));
+        sstringUnquote(s);
+        setString(s);
+        if (*ret=='\"')
+                return ret+1;
+        else
+                return NULL;
+        }
+else if (*in=='[')
+        {
+        VectorObject *vec=new VectorObject;
+        ExtObject o(&VectorObject::par,vec);
+        ExtObject::serialization.getref().add(o);
+        const char* p=in+1;
+        ExtValue tmp;
+        while(*p)
+                {
+                if (*p==']') {p++;break;}
+                ret=tmp.deserialize(p);
+                if (ret)
+                        {
+                        vec->data+=new ExtValue(tmp);
+                        p=ret;
+                        if (*p==',') p++;
+                        }
+                else
+                        {
+                        p=NULL;
+                        break;
+                        }
+                }
+        setObject(o);
+        return p;
+        }
+else if (*in=='{')
+        {
+        DictionaryObject *dic=new DictionaryObject;
+        ExtObject o(&DictionaryObject::par,dic);
+        ExtObject::serialization.getref().add(o);
+        const char* p=in+1;
+        ExtValue args[2]/*={value,key}*/, dummy_ret;
+        while(*p)
+                {
+                if (*p=='}') {p++;break;}
+                ret=args[1].deserialize(p);
+                if ((!ret)||(args[1].getType()!=TString)) {p=NULL;break;}
+                p=ret;
+                if (*p!=':') {p=NULL;break;}
+                p++;
+                ret=args[0].deserialize(p);
+                if (!ret) {p=NULL;break;}
+                p=ret;
+                dic->p_set(args,&dummy_ret);
+                if (*p==',') p++;
+                }
+        setObject(o);
+        return p;
+        }
+else if (!strncmp(in,"null",4))
+        {
+        setEmpty();
+        return in+4;
+        }
+else if (!strncmp(in,"undefined",9))
+        {
+        setInvalid();
+        return in+9;
+        }
+else if (*in=='<')
+        { //unserializable object
+        setInvalid();
+        while(*in)
+                if (*in=='>')
+                        return in+1;
+                else in++;
+        return in;
+        }
+else if (*in=='^')
+        {
+        in++;
+        ExtValue ref;
+        ret=ref.parseNumber(in);
+        if (ret && (ref.getType()==TInt))
+                {
+                const ExtObject* o=ExtObject::serialization.getref().get(ref.getInt());
+                if (o)
+                        {
+                        setObject(*o);
+                        return ret;
+                        }
+                }
+        return NULL;
+        }
+else if ((ret=skipWord(in))&&(ret!=in))
+        {
+        SString clsname(in,ret-in);
+        ExtValue tmp;
+        ret=tmp.deserialize(ret);
+        ParamInterface *cls=findDeserializableClass(clsname);
+        if (cls && (tmp.getType()!=TUnknown) && (tmp.getType()!=TInvalid))
+                {
+                VectorObject *vec=VectorObject::fromObject(tmp.getObject());
+                if (vec)
+                        {
+                        int m=cls->findId("newFromVector");
+                        if (m>=0)
+                                {
+                                cls->call(m,&tmp,this);
+                                ExtObject::serialization.getref().replace(tmp.getObject(),getObject());
+                                return ret;
+                                }
+                        }
+                DictionaryObject *dic=DictionaryObject::fromObject(tmp.getObject());
+                if (dic)
+                        {
+                        int m=cls->findId("newFromDictionary");
+                        if (m>=0)
+                                {
+                                cls->call(m,&tmp,this);
+                                ExtObject::serialization.getref().replace(tmp.getObject(),getObject());
+                                return ret;
+                                }
+                        }
+                if (tmp.getType()==TString)
+                        {
+                        int m=cls->findId("newFromString");
+                        if (m>=0)
+                                {
+                                cls->call(m,&tmp,this);
+                                ExtObject::serialization.getref().replace(tmp.getObject(),getObject());
+                                return ret;
+                                }
+                        }
+                ExtObject::serialization.getref().remove(tmp.getObject());
+                setEmpty();
+                }
+        FMprintf("ExtValue","deserialize",FMLV_WARN,"object of class \"%s\" could not be deserialized",(const char*)clsname);
+        return ret;
+        }
+return NULL;
+}
+
+const char* ExtValue::deserialize(const char* in)
+{
+ExtObject::serialization.getref().begin();
+const char* ret=deserialize_inner(in);
+ExtObject::serialization.getref().end();
+return ret;
+}
+
 ExtObject ExtValue::getObject() const
 {
@@ -307 +674 @@
 if (getType()!=TObj) return ExtValue((long)getType());
 ExtObject& o=odata();
-return ExtValue(SString(o.isEmpty()?"":o.getParamInterface()->getName()));
-}
+return ExtValue(SString(o.isEmpty()?"":o.interfaceName()));
+}