Changeset 899 for cpp/frams/model


Ignore:
Timestamp:
11/30/19 02:13:25 (5 years ago)
Author:
Maciej Komosinski
Message:

Code formatting

Location:
cpp/frams/model
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • cpp/frams/model/modelparts.cpp

    r844 r899  
    11// This file is a part of Framsticks SDK.  http://www.framsticks.com/
    2 // Copyright (C) 1999-2017  Maciej Komosinski and Szymon Ulatowski.
     2// Copyright (C) 1999-2019  Maciej Komosinski and Szymon Ulatowski.
    33// See LICENSE.txt for details.
    44
    … …  
    7474}
    7575
    76 void PartBase::setInfo(const SString& name, const SString& value)
     76void PartBase::setInfo(const SString &name, const SString &value)
    7777{
    7878        strSetField(info, name, value);
    7979}
    8080
    81 void PartBase::setInfo(const SString& name, int value)
     81void PartBase::setInfo(const SString &name, int value)
    8282{
    8383        setInfo(name, SString::valueOf(value));
    8484}
    8585
    86 void PartBase::setInfo(const SString& name, double value)
     86void PartBase::setInfo(const SString &name, double value)
    8787{
    8888        setInfo(name, SString::valueOf(value));
    8989}
    9090
    91 SString PartBase::getInfo(const SString& name)
     91SString PartBase::getInfo(const SString &name)
    9292{
    9393        return strGetField(info, name);
    … …  
    134134}
    135135
    136 void NeuroClass::setGenActive(const char* genactive_classes[])
    137 {
    138         for (const char** n = genactive_classes; *n; n++)
    139         {
    140                 NeuroClass* cls = Neuro::getClass(*n);
     136void NeuroClass::setGenActive(const char *genactive_classes[])
     137{
     138        for (const char **n = genactive_classes; *n; n++)
     139        {
     140                NeuroClass *cls = Neuro::getClass(*n);
    141141                if (cls) cls->genactive = 1;
    142142        }
    … …  
    223223}
    224224
    225 SString** Neuro::inputInfo(int i)
     225SString **Neuro::inputInfo(int i)
    226226{
    227227        if (i >= getInputCount()) return 0;
    … …  
    229229}
    230230
    231 void Neuro::setInputInfo(int i, const SString& name, const SString &value)
     231void Neuro::setInputInfo(int i, const SString &name, const SString &value)
    232232{
    233233        SString **s = inputInfo(i);
    … …  
    237237}
    238238
    239 void Neuro::setInputInfo(int i, const SString& name, int value)
     239void Neuro::setInputInfo(int i, const SString &name, int value)
    240240{
    241241        setInputInfo(i, name, SString::valueOf(value));
    242242}
    243243
    244 void Neuro::setInputInfo(int i, const SString& name, double value)
     244void Neuro::setInputInfo(int i, const SString &name, double value)
    245245{
    246246        setInputInfo(i, name, SString::valueOf(value));
    … …  
    255255}
    256256
    257 SString Neuro::getInputInfo(int i, const SString& name)
     257SString Neuro::getInputInfo(int i, const SString &name)
    258258{
    259259        SString **s = inputInfo(i);
    … …  
    263263}
    264264
    265 void Neuro::operator=(const Neuro& src)
     265void Neuro::operator=(const Neuro &src)
    266266{
    267267        refno = src.refno;
    … …  
    294294}
    295295
    296 NeuroClass* Neuro::getClass(int classindex)
     296NeuroClass *Neuro::getClass(int classindex)
    297297{
    298298        return NeuroLibrary::staticlibrary.getClass(classindex);
    299299}
    300300
    301 NeuroClass* Neuro::getClass(const SString& classname)
     301NeuroClass *Neuro::getClass(const SString &classname)
    302302{
    303303        return NeuroLibrary::staticlibrary.findClass(classname);
    304304}
    305305
    306 int Neuro::getClassIndex(const NeuroClass*nc)
    307 {
    308         return NeuroLibrary::staticlibrary.classes.find((void*)nc);
    309 }
    310 
    311 NeuroClass* Neuro::getClass()
     306int Neuro::getClassIndex(const NeuroClass *nc)
     307{
     308        return NeuroLibrary::staticlibrary.classes.find((void *)nc);
     309}
     310
     311NeuroClass *Neuro::getClass()
    312312{
    313313        checkClass();
    … …  
    315315}
    316316
    317 void Neuro::setClass(NeuroClass* cl)
     317void Neuro::setClass(NeuroClass *cl)
    318318{
    319319        myclass = cl;
    … …  
    328328}
    329329
    330 void Neuro::setDetails(const SString& details)
     330void Neuro::setDetails(const SString &details)
    331331{
    332332        int colon = details.indexOf(':');
    … …  
    362362}
    363363
    364 void Neuro::setClassName(const SString& clazz)
     364void Neuro::setClassName(const SString &clazz)
    365365{
    366366        myclassname = clazz;
    … …  
    368368}
    369369
    370 int Neuro::addInput(Neuro* child, double weight, const SString *info)
     370int Neuro::addInput(Neuro *child, double weight, const SString *info)
    371371{
    372372        inputs += NInput(child, weight, (info && (info->len())) ? new SString(*info) : 0);
    … …  
    376376}
    377377
    378 int Neuro::findInput(Neuro* child) const
     378int Neuro::findInput(Neuro *child) const
    379379{
    380380        for (int i = 0; i < inputs.size(); i++)
    … …  
    383383}
    384384
    385 Neuro* Neuro::getInput(int i, double &weight) const
     385Neuro *Neuro::getInput(int i, double &weight) const
    386386{
    387387        if (i >= getInputCount()) return 0;
    … …  
    401401}
    402402
    403 void Neuro::setInput(int i, Neuro* n)
     403void Neuro::setInput(int i, Neuro *n)
    404404{
    405405        NInput &inp = inputs(i);
    … …  
    407407}
    408408
    409 void Neuro::setInput(int i, Neuro* n, double w)
     409void Neuro::setInput(int i, Neuro *n, double w)
    410410{
    411411        NInput &inp = inputs(i);
    … …  
    424424}
    425425
    426 int Neuro::removeInput(Neuro* child)
     426int Neuro::removeInput(Neuro *child)
    427427{
    428428        int i = findInput(child);
    … …  
    463463}
    464464
    465 int Neuro::findInputs(SList& result, const char* classname, const Part* part, const Joint* joint) const
     465int Neuro::findInputs(SList &result, const char *classname, const Part *part, const Joint *joint) const
    466466{
    467467        Neuro *nu;
    … …  
    476476                if (classname)
    477477                        if (nu->getClassName() != cn) continue;
    478                 result += (void*)nu;
     478                result += (void *)nu;
    479479        }
    480480        return result.size() - n0;
    481481}
    482482
    483 int Neuro::findOutputs(SList& result, const char* classname, const Part* part, const Joint* joint) const
     483int Neuro::findOutputs(SList &result, const char *classname, const Part *part, const Joint *joint) const
    484484{ // not very efficient...
    485485        Neuro *nu, *inp;
    … …  
    498498                        if (inp == this)
    499499                        {
    500                         result += (void*)nu;
    501                         break;
     500                                result += (void *)nu;
     501                                break;
    502502                        }
    503503        }
    … …  
    576576}
    577577
    578 void Part::operator=(const Part& src)
     578void Part::operator=(const Part &src)
    579579{
    580580        p = src.p; o = src.o;
    … …  
    612612        Pt3D x = p2 - p1;
    613613        Pt3D dir(x.y, x.z, x.x);
    614         p = p1 + x*0.5;
     614        p = p1 + x * 0.5;
    615615        rot.getAngles(x, dir);
    616616}
    617617
    618 Param& Part::getStaticParam()
     618Param &Part::getStaticParam()
    619619{
    620620        static Param p(f0_part_paramtab, 0, "Part");
    … …  
    637637}
    638638
    639 void Joint::operator=(const Joint& src)
     639void Joint::operator=(const Joint &src)
    640640{
    641641        rot = src.rot;
    … …  
    652652}
    653653
    654 void Joint::attachToParts(Part* p1, Part* p2)
     654void Joint::attachToParts(Part *p1, Part *p2)
    655655{
    656656        part1 = p1;
    … …  
    695695}
    696696
    697 Param& Joint::getStaticParam()
     697Param &Joint::getStaticParam()
    698698{
    699699        static Param p(f0_joint_paramtab, 0, "Joint");
    … …  
    760760};
    761761
    762 Param& Neuro::getStaticParam()
     762Param &Neuro::getStaticParam()
    763763{
    764764        static Param p(f0_neuro_paramtab, 0, "NeuroDef");

  • cpp/frams/model/modelparts.h

    r844 r899  
    2424class MultiRange;
    2525
    26 typedef UserTags<Model, void*, 5> ModelUserTags;
     26typedef UserTags<Model, void *, 5> ModelUserTags;
    2727
    2828/** Common base for model elements. */
    … …  
    3131public:
    3232        SString vis_style;
    33         PartBase(const SString& s) :vis_style(s), mapped(0) {}
     33        PartBase(const SString &s) :vis_style(s), mapped(0) {}
    3434        ~PartBase();
    35         static SString getDefaultStyle(){ return SString("none"); }
     35        static SString getDefaultStyle() { return SString("none"); }
    3636        MultiRange *mapped;
    3737        enum PartBaseFlags { Selected = 1 };
    … …  
    4848
    4949        void clearMapping();
    50         MultiRange* getMapping() { return mapped; }
     50        MultiRange *getMapping() { return mapped; }
    5151        void setMapping(const IRange &mr);
    5252        void addMapping(const IRange &mr);
    … …  
    5454        void addMapping(const MultiRange &mr);
    5555
    56         void setInfo(const SString& name, const SString& value);
    57         void setInfo(const SString& name, int value);
    58         void setInfo(const SString& name, double value);
    59         SString getInfo(const SString& name);
     56        void setInfo(const SString &name, const SString &value);
     57        void setInfo(const SString &name, int value);
     58        void setInfo(const SString &name, double value);
     59        SString getInfo(const SString &name);
    6060};
    6161
    … …  
    9494
    9595        Part(enum Shape s = SHAPE_BALL_AND_STICK);
    96         Part(const Part& src) :PartBase(getDefaultStyle()) { operator=(src); }
    97         void operator=(const Part& src);
     96        Part(const Part &src) :PartBase(getDefaultStyle()) { operator=(src); }
     97        void operator=(const Part &src);
    9898
    9999        void setPositionAndRotationFromAxis(const Pt3D &p1, const Pt3D &p2);
    … …  
    101101        void setRot(const Pt3D &r);///< set part.rot (rotation angles) and calculate part.o
    102102
    103         static Param& getStaticParam();
     103        static Param &getStaticParam();
    104104};
    105105
    … …  
    128128
    129129        Joint();
    130         Joint(const Joint& src) :PartBase(getDefaultStyle()) { operator=(src); }
    131         void operator=(const Joint& src);
     130        Joint(const Joint &src) :PartBase(getDefaultStyle()) { operator=(src); }
     131        void operator=(const Joint &src);
    132132
    133133        /** connect two parts with this joint.
    … …  
    135135                @see isDelta()
    136136                */
    137         void attachToParts(Part* p1, Part* p2);
     137        void attachToParts(Part *p1, Part *p2);
    138138        /// @see attachToParts(Part*,Part*)
    139139        void attachToParts(int p1, int p2);
    … …  
    168168        Pt3D vcolor;
    169169
    170         static Param& getStaticParam();
     170        static Param &getStaticParam();
    171171};
    172172
    173173#define JOINT_DELTA_MARKER 99999.0
    174174
    175 ////////////////// NN /////////////////
     175
     176
     177////////////////// Neural Network /////////////////
    176178
    177179class NeuroClass;
    178180
    179 typedef UserTags<NeuroClass, void*, 5> NeuroClassUserTags;
     181typedef UserTags<NeuroClass, void *, 5> NeuroClassUserTags;
    180182
    181183/** Information about neuron class.
    … …  
    184186{
    185187        bool ownedvectordata;
    186         void operator=(const NeuroClass& nosuchthich){}
     188        void operator=(const NeuroClass &nosuchthich) {}
    187189public:
    188190        SString name, longname, description;
    … …  
    207209        /** class name for use in Neuro::setClassName(), Neuro::setDetails() (former 'moredata' field),
    208210                eg. "N","-",G" */
    209         const SString& getName() { return name; }
     211        const SString &getName() { return name; }
    210212        /** human friendly name, eg. "Neuron","Link","Gyroscope"  */
    211         const SString& getLongName() { return longname; }
     213        const SString &getLongName() { return longname; }
    212214        /** long description */
    213         const SString& getDescription() { return description; }
    214         ParamEntry* getParamTab() { return props; }
     215        const SString &getDescription() { return description; }
     216        ParamEntry *getParamTab() { return props; }
    215217
    216218        /** NeuroClass specific properties, recognized by all neurons of this class */
    … …  
    240242                }
    241243                */
    242         int* getSymbolGlyph()
     244        int *getSymbolGlyph()
    243245        {
    244246                return vectordata;
    … …  
    246248        void setSymbolGlyph(int *data, bool owned = 1)
    247249        {
    248                 if (vectordata&&ownedvectordata) delete[]vectordata;
     250                if (vectordata && ownedvectordata) delete[]vectordata;
    249251                vectordata = data; ownedvectordata = owned;
    250252        }
    … …  
    282284
    283285        static void resetActive(); ///< set default values of active and genactive for all classes
    284         static void setGenActive(const char* classes[]); ///< set genactive for specified classes
    285 };
    286 
    287 class Neuro;
    288 
    289 /** Single processing unit in Framsticks NN.  */
     286        static void setGenActive(const char *classes[]); ///< set genactive for specified classes
     287};
     288
     289
     290
     291
     292
     293
     294/** Single processing unit in Framsticks neural network.  */
    290295class Neuro : public PartBase
    291296{
    … …  
    305310        /** set myclass and make knownclass=true */
    306311        void checkClass();
    307         SString** inputInfo(int i);
     312        SString **inputInfo(int i);
    308313        void defassign();
    309314
    … …  
    313318        Param extraProperties();
    314319
    315         void setInputInfo(int i, const SString& name, const SString &value);
    316         void setInputInfo(int i, const SString& name, int value);
    317         void setInputInfo(int i, const SString& name, double value);
     320        void setInputInfo(int i, const SString &name, const SString &value);
     321        void setInputInfo(int i, const SString &name, int value);
     322        void setInputInfo(int i, const SString &name, double value);
    318323        SString getInputInfo(int i);
    319         SString getInputInfo(int i, const SString& name);
    320 
    321         NeuroClass* getClass();
    322         void setClass(NeuroClass*);
     324        SString getInputInfo(int i, const SString &name);
     325
     326        NeuroClass *getClass();
     327        void setClass(NeuroClass *);
    323328
    324329        SString getClassParams() { return myclassparams; }
    325         void setClassParams(const SString& cp) { myclassparams = cp; }
     330        void setClassParams(const SString &cp) { myclassparams = cp; }
    326331
    327332        SString getClassName();
    328         void setClassName(const SString& clazz);
     333        void setClassName(const SString &clazz);
    329334
    330335        /** return neuro unit details encoded as <CLASS> ":" <PROPERTIES>
    … …  
    351356                @see getDetails()
    352357                */
    353         void setDetails(const SString&);
     358        void setDetails(const SString &);
    354359
    355360#define STATRICKCLASS Neuro
    … …  
    377382        Neuro();
    378383        Neuro(double _state, double _inertia, double _force, double _sigmo);
    379         Neuro(const Neuro& src) :PartBase(getDefaultStyle()) { operator=(src); }
     384        Neuro(const Neuro &src) :PartBase(getDefaultStyle()) { operator=(src); }
    380385
    381386        ~Neuro();
    382387
    383         void operator=(const Neuro& src);
     388        void operator=(const Neuro &src);
    384389
    385390        /** Attach this Neuro to the specified Part or detach it from the body if p==NULL.
    … …  
    387392                @see getPart()
    388393                */
    389         void attachToPart(Part* p) { part = p; joint = 0; }
     394        void attachToPart(Part *p) { part = p; joint = 0; }
    390395
    391396        /** Attach this Neuro to the specified Joint or detach it from the body if p==NULL.
    … …  
    393398                @see getJoint()
    394399                */
    395         void attachToJoint(Joint* j) { joint = j; part = 0; }
     400        void attachToJoint(Joint *j) { joint = j; part = 0; }
    396401
    397402        void attachToPart(int i);
    … …  
    422427
    423428        /** @return the Neuro connected as i-th input */
    424         Neuro* getInput(int i) const { return (i >= inputs.size()) ? 0 : inputs(i).n; }
     429        Neuro *getInput(int i) const { return (i >= inputs.size()) ? 0 : inputs(i).n; }
    425430        /** @return the Neuro connected as i-th input.
    426431                @param weight
    427432                */
    428         Neuro* getInput(int i, double &weight) const;
     433        Neuro *getInput(int i, double &weight) const;
    429434        /** @return connectin weight for i-th input */
    430435        double getInputWeight(int i) const;
    … …  
    432437        void setInputWeight(int i, double weight);
    433438        /** connect i-th input with another neuron */
    434         void setInput(int i, Neuro*n);
     439        void setInput(int i, Neuro *n);
    435440        /** connect i-th input with another neuron */
    436         void setInput(int i, Neuro*n, double weight);
     441        void setInput(int i, Neuro *n, double weight);
    437442        /** add new input. @return its reference number */
    438         int addInput(Neuro* child, double weight = 1.0, const SString* info = 0);
     443        int addInput(Neuro *child, double weight = 1.0, const SString *info = 0);
    439444        /** @return reference number [0..InputCount-1] of the input
    440445           or -1 if 'child' is not connected with this Neuro.*/
    441         int findInput(Neuro* child) const;
     446        int findInput(Neuro *child) const;
    442447        void removeInput(paInt refno);
    443448        /**    @return reference number of the child connection, like findInput() */
    444         int removeInput(Neuro* child);
    445 
    446         int findInputs(SList& result, const char* classname = 0, const Part* part = 0, const Joint* joint = 0) const;
    447         int findOutputs(SList& result, const char* classname = 0, const Part* part = 0, const Joint* joint = 0) const;
     449        int removeInput(Neuro *child);
     450
     451        int findInputs(SList &result, const char *classname = 0, const Part *part = 0, const Joint *joint = 0) const;
     452        int findOutputs(SList &result, const char *classname = 0, const Part *part = 0, const Joint *joint = 0) const;
    448453
    449454        /* class database retrieval */
    … …  
    453458                */
    454459        static SString getClassName(int classindex);
    455         static NeuroClass* getClass(int classindex);
    456         static NeuroClass* getClass(const SString& classname);
    457         static int getClassIndex(const NeuroClass*nc);
     460        static NeuroClass *getClass(int classindex);
     461        static NeuroClass *getClass(const SString &classname);
     462        static int getClassIndex(const NeuroClass *nc);
    458463
    459464        // not really private, but you should not access those directly
    … …  
    468473        Orient o;       ///< rotation matrix calculated from "rot"
    469474        static ParamEntry emptyParamTab[];
    470         static Param& getStaticParam();
     475        static Param &getStaticParam();
    471476};
    472477
Note: See TracChangeset for help on using the changeset viewer.