Changeset 790 for cpp

Timestamp:

05/29/18 15:46:35 (7 years ago)

Author:

Maciej Komosinski

Message:

Code formatting

Location:

cpp/frams/neuro

Files:

• neurofactory.cpp (modified) (2 diffs)
• neurofactory.h (modified) (1 diff)
• neuroimplfiles-SDK.h (modified) (1 diff)
• neurolibparam.cpp (modified) (1 diff)
• neurolibparam.h (modified) (1 diff)
• neurolibrary.cpp (modified) (2 diffs)
• neurolibrary.h (modified) (1 diff)

cpp/frams/neuro/neurofactory.cpp

@@ -13 +13 @@
 NeuroImpl* NeuroFactory::getImplementation(NeuroClass *nc)
 {
-if (nc!=NULL)
+        if (nc != NULL)
         {
-        std::map<NeuroClass*,NeuroImpl*>::iterator it=impl.find(nc);
-        if (it!=impl.end())
-                return it->second;
+                std::map<NeuroClass*, NeuroImpl*>::iterator it = impl.find(nc);
+                if (it != impl.end())
+                        return it->second;
         }
-return NULL;
+        return NULL;
 }
 
 NeuroImpl* NeuroFactory::createNeuroImpl(NeuroClass *nc)
 {
-if (!nc) return 0;
-if (!nc->active) return 0;
-NeuroImpl* ni=getImplementation(nc);
-if (!ni) return 0;
-ni=ni->makeNew();
-if (ni) ni->neuroclass=nc;
-return ni;
+        if (!nc) return 0;
+        if (!nc->active) return 0;
+        NeuroImpl* ni = getImplementation(nc);
+        if (!ni) return 0;
+        ni = ni->makeNew();
+        if (ni) ni->neuroclass = nc;
+        return ni;
 }
 
-NeuroImpl* NeuroFactory::setImplementation(const SString& classname,NeuroImpl *ni,bool deleteold)
+NeuroImpl* NeuroFactory::setImplementation(const SString& classname, NeuroImpl *ni, bool deleteold)
 {
-NeuroClass *nc=Neuro::getClass(classname);
-if (!nc) return ni;
-return setImplementation(nc,ni,deleteold);
+        NeuroClass *nc = Neuro::getClass(classname);
+        if (!nc) return ni;
+        return setImplementation(nc, ni, deleteold);
 }
 
-NeuroImpl* NeuroFactory::setImplementation(NeuroClass *nc,NeuroImpl *ni,bool deleteold)
+NeuroImpl* NeuroFactory::setImplementation(NeuroClass *nc, NeuroImpl *ni, bool deleteold)
 {
-if (nc==NULL) return NULL;
-std::map<NeuroClass*,NeuroImpl*>::iterator it=impl.find(nc);
-NeuroImpl* old_ni=NULL;
-if (it==impl.end())
+        if (nc == NULL) return NULL;
+        std::map<NeuroClass*, NeuroImpl*>::iterator it = impl.find(nc);
+        NeuroImpl* old_ni = NULL;
+        if (it == impl.end())
         {
-        if (ni!=NULL)
+                if (ni != NULL)
                 {
-                impl[nc]=ni;
-                nc->impl_count++;
+                        impl[nc] = ni;
+                        nc->impl_count++;
                 }
-        return NULL;
+                return NULL;
         }
-else
+        else
         {
-        old_ni=it->second;
-        if (ni)
-                it->second=ni;
-        else
+                old_ni = it->second;
+                if (ni)
+                        it->second = ni;
+                else
                 {
-                impl.erase(it);
-                nc->impl_count--;
+                        impl.erase(it);
+                        nc->impl_count--;
                 }
         }
-if (deleteold && old_ni) delete old_ni;
-return old_ni;
+        if (deleteold && old_ni) delete old_ni;
+        return old_ni;
 }
 
@@ -73 +73 @@
 void NeuroFactory::setStandardImplementation()
 {
-SETIMPLEMENTATION
+        SETIMPLEMENTATION
 }
 
 void NeuroFactory::freeImplementation()
 {
-for(int i=0;i<Neuro::getClassCount();i++)
-        setImplementation(Neuro::getClass(i),0);
+        for (int i = 0; i < Neuro::getClassCount(); i++)
+                setImplementation(Neuro::getClass(i), 0);
 }
 
 void NeuroFactory::removeUnimplemented()
 {
-SString removed;
-for(int i=0;i<Neuro::getClassCount();i++)
+        SString removed;
+        for (int i = 0; i < Neuro::getClassCount(); i++)
         {
-        NeuroClass *nc=Neuro::getClass(i);
-        if (nc->impl_count==0)
+                NeuroClass *nc = Neuro::getClass(i);
+                if (nc->impl_count == 0)
                 {
-                removed+=nc->getName();
-                removed+=" ";
-                NeuroLibrary::staticlibrary.classes-=i; 
-                i--;
-                delete nc;
+                        removed += nc->getName();
+                        removed += " ";
+                        NeuroLibrary::staticlibrary.classes -= i;
+                        i--;
+                        delete nc;
                 }
         }
-if (removed.len())
-        logPrintf("NeuroFactory","removeUninmplemented",LOG_INFO,
-         "Removed Neuro classes: %s",removed.c_str());
+        if (removed.len())
+                logPrintf("NeuroFactory", "removeUninmplemented", LOG_INFO,
+                "Removed Neuro classes: %s", removed.c_str());
 }
-

cpp/frams/neuro/neurofactory.h

@@ -13 +13 @@
 class NeuroFactory
 {
-std::map<NeuroClass*,NeuroImpl*> impl;
+        std::map<NeuroClass*, NeuroImpl*> impl;
 public:
-NeuroImpl* setImplementation(NeuroClass *nc,NeuroImpl *ni,bool deleteold=1);
-NeuroImpl* setImplementation(const SString& classname,NeuroImpl *ni,bool deleteold=1);
-NeuroImpl* getImplementation(NeuroClass *nc);
-class NeuroImpl* createNeuroImpl(Neuro *n)
-        {NeuroClass *nc=n->getClass(); if (!nc) return 0; return createNeuroImpl(nc);}
-class NeuroImpl* createNeuroImpl(NeuroClass *nc);
+        NeuroImpl* setImplementation(NeuroClass *nc, NeuroImpl *ni, bool deleteold = 1);
+        NeuroImpl* setImplementation(const SString& classname, NeuroImpl *ni, bool deleteold = 1);
+        NeuroImpl* getImplementation(NeuroClass *nc);
+        class NeuroImpl* createNeuroImpl(Neuro *n)
+        {
+                NeuroClass *nc = n->getClass(); if (!nc) return 0; return createNeuroImpl(nc);
+        }
+        class NeuroImpl* createNeuroImpl(NeuroClass *nc);
 
-void setStandardImplementation();
-void freeImplementation();
-void removeUnimplemented();
+        void setStandardImplementation();
+        void freeImplementation();
+        void removeUnimplemented();
 };
 

cpp/frams/neuro/neuroimplfiles-SDK.h

@@ -14 +14 @@
 #include "impl/neuroimpl-vmot.hpp"
 #endif
-

cpp/frams/neuro/neurolibparam.cpp

@@ -8 +8 @@
 
 NeuroLibParam::NeuroLibParam(const char* gr, const char* name, const char* pref)
-        :mygroup(gr),myname(name),myprefix(pref)
+        :mygroup(gr), myname(name), myprefix(pref)
 {
-anode=NeuroLibrary::staticlibrary.classes.l_add.add(
-        STATRICKCALLBACK(this,&NeuroLibParam::neuroclassAdded,0));
-dnode=NeuroLibrary::staticlibrary.classes.l_postdel.add(
-        STATRICKCALLBACK(this,&NeuroLibParam::neuroclassRemoved,0));
+        anode = NeuroLibrary::staticlibrary.classes.l_add.add(
+                STATRICKCALLBACK(this, &NeuroLibParam::neuroclassAdded, 0));
+        dnode = NeuroLibrary::staticlibrary.classes.l_postdel.add(
+                STATRICKCALLBACK(this, &NeuroLibParam::neuroclassRemoved, 0));
 }
 
 NeuroLibParam::~NeuroLibParam()
 {
-NeuroLibrary::staticlibrary.classes.l_add.removeNode(anode);// remove(anode) tez powinno byc ok - do sprawdzenia
-NeuroLibrary::staticlibrary.classes.l_postdel.removeNode(dnode);
+        NeuroLibrary::staticlibrary.classes.l_add.removeNode(anode);// remove(anode) tez powinno byc ok - do sprawdzenia
+        NeuroLibrary::staticlibrary.classes.l_postdel.removeNode(dnode);
 }
 
-void NeuroLibParam::neuroclassAdded(void* data,intptr_t i)
-{onadd.action(i);}
-void NeuroLibParam::neuroclassRemoved(void* data,intptr_t i)
-{ondelete.action(i);}
+void NeuroLibParam::neuroclassAdded(void* data, intptr_t i)
+{
+        onadd.action(i);
+}
+void NeuroLibParam::neuroclassRemoved(void* data, intptr_t i)
+{
+        ondelete.action(i);
+}
 
 static bool isGoodName(const SString& name)
 {
-for(int i=0;i<name.len();i++)
-        if (!isalnum(name[i])) return false;
-return true;
+        for (int i = 0; i < name.len(); i++)
+                if (!isalnum(name[i])) return false;
+        return true;
 }
 
 const char *NeuroLibParam::id(int i)
 {
-static SString t;
-if (i>=Neuro::getClassCount()) return 0;
-t=myprefix;
-SString n=Neuro::getClass(i)->getName();
-if (isGoodName(n))
-        t+=n;
-else
+        static SString t;
+        if (i >= Neuro::getClassCount()) return 0;
+        t = myprefix;
+        SString n = Neuro::getClass(i)->getName();
+        if (isGoodName(n))
+                t += n;
+        else
         {//jezeli w nazwie klasy neuronu sa "dziwne" znaki to zamiast tego uzywamy long name
-        // * -> Constant, | -> Bend_muscle, @ -> Rotation_muscle
-        n=Neuro::getClass(i)->getLongName();
-        for(char* p=n.directWrite();*p;p++)
-                if (*p==' ') *p='_';
-        n.endWrite();
-        t+=n;
+                // * -> Constant, | -> Bend_muscle, @ -> Rotation_muscle
+                n = Neuro::getClass(i)->getLongName();
+                for (char* p = n.directWrite(); *p; p++)
+                        if (*p == ' ') *p = '_';
+                n.endWrite();
+                t += n;
         }
-return t.c_str();
+        return t.c_str();
 }
 
 const char *NeuroLibParam::name(int i)
 {
-static SString t;
-t=Neuro::getClass(i)->getLongName();
-t+=" ("; t+=Neuro::getClassName(i); t+=")";
-return t.c_str();
+        static SString t;
+        t = Neuro::getClass(i)->getLongName();
+        t += " ("; t += Neuro::getClassName(i); t += ")";
+        return t.c_str();
 }
 
 const char *NeuroLibParam::help(int i)
 {
-static SString t;
-t=Neuro::getClass(i)->getSummary();
-return t.c_str();
+        static SString t;
+        t = Neuro::getClass(i)->getSummary();
+        return t.c_str();
 }
 
-int NeuroLibParam::grmember(int gi,int n)
+int NeuroLibParam::grmember(int gi, int n)
 {
-return (gi==0)?
-        ((n>=getPropCount())?-9999:n)
-        :
-        -9999;
+        return (gi == 0) ?
+                ((n >= getPropCount()) ? -9999 : n)
+                :
+                -9999;
 }
-

cpp/frams/neuro/neurolibparam.h

@@ -9 +9 @@
 #include <frams/model/modelparts.h>
 
-class NeuroLibParam: public MutableParamInterface
+class NeuroLibParam : public MutableParamInterface
 {
-const char* mygroup;
-const char* myname;
-const char* myprefix;
-CallbackNode *anode,*dnode;
+        const char* mygroup;
+        const char* myname;
+        const char* myprefix;
+        CallbackNode *anode, *dnode;
 
-  public:
-NeuroLibParam(const char* gr=0, const char* name=0, const char* pref=0);
-~NeuroLibParam();
+public:
+        NeuroLibParam(const char* gr = 0, const char* name = 0, const char* pref = 0);
+        ~NeuroLibParam();
 
 #define STATRICKCLASS NeuroLibParam
-VIRTCALLBACKDEF(neuroclassAdded);
-VIRTCALLBACKDEF(neuroclassRemoved);
+        VIRTCALLBACKDEF(neuroclassAdded);
+        VIRTCALLBACKDEF(neuroclassRemoved);
 #undef STATRICKCLASS
 
-int getGroupCount() {return 1;}
-int getPropCount()  {return Neuro::getClassCount();}
+        int getGroupCount() { return 1; }
+        int getPropCount()  { return Neuro::getClassCount(); }
 
-const char* getName() {return myname;}
-const char *grname(int gi) {return (gi==0)?mygroup:0;}
+        const char* getName() { return myname; }
+        const char *grname(int gi) { return (gi == 0) ? mygroup : 0; }
 
-const char *id(int i);
-const char *name(int i);
-const char *help(int i);
-const char *type(int i) {return "d 0 1";}
-int flags(int i)        {return 0;}
-int group(int i)        {return 0;}
-int grmember(int gi,int n);
-void call(int i,ExtValue* args,ExtValue *ret) {}
+        const char *id(int i);
+        const char *name(int i);
+        const char *help(int i);
+        const char *type(int i) { return "d 0 1"; }
+        int flags(int i)        { return 0; }
+        int group(int i)        { return 0; }
+        int grmember(int gi, int n);
+        void call(int i, ExtValue* args, ExtValue *ret) {}
 
-SString getString(int i) {return SString();}
-double getDouble(int) {return 0;}
-ExtObject getObject(int i) {return ExtObject();}
-ExtValue getExtValue(int i) {return ExtValue();}
-int setDouble(int i, double) {return 0;}
-int setString(int i, const SString &v) {return 0;}
-int setObject(int i, const ExtObject &v) {return 0;}
-int setExtValue(int i, const ExtValue &v) {return 0;}
+        SString getString(int i) { return SString(); }
+        double getDouble(int) { return 0; }
+        ExtObject getObject(int i) { return ExtObject(); }
+        ExtValue getExtValue(int i) { return ExtValue(); }
+        int setDouble(int i, double) { return 0; }
+        int setString(int i, const SString &v) { return 0; }
+        int setObject(int i, const ExtObject &v) { return 0; }
+        int setExtValue(int i, const ExtValue &v) { return 0; }
 };
 

cpp/frams/neuro/neurolibrary.cpp

@@ -11 +11 @@
 int NeuroLibrary::findClassIndex(const SString & classname, bool activeonly)
 {
-NeuroClass* cl;
-for(int i=0;cl=(NeuroClass*)classes(i);i++)
+        NeuroClass* cl;
+        for (int i = 0; cl = (NeuroClass*)classes(i); i++)
         {
-        if (activeonly && !cl->active) continue;
-        if (classname == cl->getName()) return i;
+                if (activeonly && !cl->active) continue;
+                if (classname == cl->getName()) return i;
         }
-return -1;
+        return -1;
 }
 
 NeuroClass* NeuroLibrary::findClass(const SString & classname, bool activeonly)
 {
-int i=findClassIndex(classname,activeonly);
-if (i<0) return 0;
-return getClass(i);
+        int i = findClassIndex(classname, activeonly);
+        if (i < 0) return 0;
+        return getClass(i);
 }
 
 SString NeuroLibrary::getClassName(int classindex)
 {
-NeuroClass *cl=getClass(classindex);
-return cl? cl->getName() : SString();
+        NeuroClass *cl = getClass(classindex);
+        return cl ? cl->getName() : SString();
 }
 
-NeuroClass *NeuroLibrary::addClass(NeuroClass *cls,bool replace)
+NeuroClass *NeuroLibrary::addClass(NeuroClass *cls, bool replace)
 {
-NeuroClass *old=findClass(cls->getName());
-if (old)
+        NeuroClass *old = findClass(cls->getName());
+        if (old)
         {
-        if (replace)
+                if (replace)
                 {
-                classes-=old;
-                classes+=cls;
+                        classes -= old;
+                        classes += cls;
                 }
         }
-else
-        classes+=cls;
-return old;
+        else
+                classes += cls;
+        return old;
 }
 
@@ -56 +56 @@
 NeuroLibrary::NeuroLibrary()
 {
-addStandardClasses();
+        addStandardClasses();
 }
 
 NeuroLibrary::~NeuroLibrary()
 {
-FOREACH(NeuroClass*,cl,classes)
-        delete cl;
+        FOREACH(NeuroClass*, cl, classes)
+                delete cl;
 }
 
 void NeuroLibrary::removeClass(int i)
 {
-classes-=i;
+        classes -= i;
 }
 
 void NeuroLibrary::clear()
 {
-while(getClassCount()>0)
-        removeClass(getClassCount()-1);
+        while (getClassCount() > 0)
+                removeClass(getClassCount() - 1);
 }
-

cpp/frams/neuro/neurolibrary.h

@@ -13 +13 @@
 class NeuroLibrary
 {
-  public:
-static NeuroLibrary staticlibrary;
-NeuroLibrary();
-~NeuroLibrary();
-AdvList classes;
-NeuroClass* findClass(const SString& classname, bool activeonly=1);
-void addStandardClasses();
-int findClassIndex(const SString& classname, bool activeonly=1);
-NeuroClass* getClass(int classindex) {return (NeuroClass*)classes(classindex);}
-SString getClassName(int classindex);
-int getClassCount() {return classes.size();}
-void removeClass(int i);
-void clear();
-NeuroClass *addClass(NeuroClass *cls,bool replace=1);
+public:
+        static NeuroLibrary staticlibrary;
+        NeuroLibrary();
+        ~NeuroLibrary();
+        AdvList classes;
+        NeuroClass* findClass(const SString& classname, bool activeonly = 1);
+        void addStandardClasses();
+        int findClassIndex(const SString& classname, bool activeonly = 1);
+        NeuroClass* getClass(int classindex) { return (NeuroClass*)classes(classindex); }
+        SString getClassName(int classindex);
+        int getClassCount() { return classes.size(); }
+        void removeClass(int i);
+        void clear();
+        NeuroClass *addClass(NeuroClass *cls, bool replace = 1);
 };