coding style: use agent rather than slave

kdudka · kdudka · commit 56e824f27e1e · 2020-11-05T13:53:09.000+01:00
The former is known to be politically safer. Closes: https://github.com/kdudka/csdiff/pull/15
diff --git a/src/abstract-filter.cc b/src/abstract-filter.cc
@@ -42,8 +42,8 @@ struct PredicateFilter::Private {
     }
 };
 
-PredicateFilter::PredicateFilter(AbstractWriter *slave):
-    AbstractFilter(slave),
+PredicateFilter::PredicateFilter(AbstractWriter *agent):
+    AbstractFilter(agent),
     d(new Private)
 {
 }
@@ -97,7 +97,7 @@ void EventPrunner::handleDef(const Defect &defOrig)
             def.keyEventIdx--;
     }
 
-    slave_->handleDef(def);
+    agent_->handleDef(def);
 }
 
 
@@ -170,14 +170,14 @@ void CtxEmbedder::handleDef(const Defect &defOrig)
     const DefEvent &evt = defOrig.events[defOrig.keyEventIdx];
     if (!evt.line) {
         // no line number for the key event
-        slave_->handleDef(defOrig);
+        agent_->handleDef(defOrig);
         return;
     }
 
     std::fstream fstr(evt.fileName.c_str(), std::ios::in);
     if (!fstr) {
         // failed to open input file
-        slave_->handleDef(defOrig);
+        agent_->handleDef(defOrig);
         return;
     }
 
@@ -188,5 +188,5 @@ void CtxEmbedder::handleDef(const Defect &defOrig)
 
     // close the file stream and forward the result
     fstr.close();
-    slave_->handleDef(def);
+    agent_->handleDef(def);
 }
diff --git a/src/abstract-filter.hh b/src/abstract-filter.hh
@@ -25,33 +25,33 @@
 /// decorator
 class GenericAbstractFilter: public AbstractWriter {
     protected:
-        AbstractWriter *slave_;
+        AbstractWriter *agent_;
         virtual void handleDef(const Defect &def) = 0;
 
     public:
         virtual void notifyFile(const std::string &fileName) {
-            slave_->notifyFile(fileName);
+            agent_->notifyFile(fileName);
         }
 
-        GenericAbstractFilter(AbstractWriter *slave):
-            slave_(slave)
+        GenericAbstractFilter(AbstractWriter *agent):
+            agent_(agent)
         {
         }
 
         ~GenericAbstractFilter() {
-            delete slave_;
+            delete agent_;
         }
 
         virtual void flush() {
-            slave_->flush();
+            agent_->flush();
         }
 
         virtual const TScanProps& getScanProps() const {
-            return slave_->getScanProps();
+            return agent_->getScanProps();
         }
 
         virtual void setScanProps(const TScanProps &scanProps) {
-            slave_->setScanProps(scanProps);
+            agent_->setScanProps(scanProps);
         }
 };
 
@@ -61,8 +61,8 @@ class EventPrunner: public GenericAbstractFilter {
         int thr_;
 
     public:
-        EventPrunner(AbstractWriter *slave, unsigned thr):
-            GenericAbstractFilter(slave),
+        EventPrunner(AbstractWriter *agent, unsigned thr):
+            GenericAbstractFilter(agent),
             thr_(thr)
         {
         }
@@ -76,8 +76,8 @@ class CtxEmbedder: public GenericAbstractFilter {
         int ctxLines_;
 
     public:
-        CtxEmbedder(AbstractWriter *slave, const int ctxLines):
-            GenericAbstractFilter(slave),
+        CtxEmbedder(AbstractWriter *agent, const int ctxLines):
+            GenericAbstractFilter(agent),
             ctxLines_(ctxLines)
         {
         }
@@ -94,8 +94,8 @@ class AbstractFilter: public GenericAbstractFilter {
         virtual bool matchDef(const Defect &def) = 0;
 
     public:
-        AbstractFilter(AbstractWriter *slave):
-            GenericAbstractFilter(slave),
+        AbstractFilter(AbstractWriter *agent):
+            GenericAbstractFilter(agent),
             neg_(false)
         {
         }
@@ -108,7 +108,7 @@ class AbstractFilter: public GenericAbstractFilter {
             if (neg_ == matchDef(def))
                 return;
 
-            slave_->handleDef(def);
+            agent_->handleDef(def);
         }
 };
 
@@ -120,7 +120,7 @@ class IPredicate {
 
 class PredicateFilter: public AbstractFilter {
     public:
-        PredicateFilter(AbstractWriter *slave);
+        PredicateFilter(AbstractWriter *agent);
         virtual ~PredicateFilter();
 
         /// takes ownership of pred and will call delete on it on destruction
diff --git a/src/csgrep.cc b/src/csgrep.cc
@@ -311,8 +311,8 @@ class SrcAnnotPredicate: public IPredicate {
 
 class PathStripper: public GenericAbstractFilter {
     public:
-        PathStripper(AbstractWriter *slave, const std::string &prefix):
-            GenericAbstractFilter(slave),
+        PathStripper(AbstractWriter *agent, const std::string &prefix):
+            GenericAbstractFilter(agent),
             prefStr_(prefix),
             prefSize_(prefix.size())
         {
@@ -335,7 +335,7 @@ class PathStripper: public GenericAbstractFilter {
                 path.erase(/* pos */ 0U, prefSize_);
             }
 
-            slave_->handleDef(def);
+            agent_->handleDef(def);
         }
 
     private:
@@ -345,8 +345,8 @@ class PathStripper: public GenericAbstractFilter {
 
 class DuplicateFilter: public AbstractFilter {
     public:
-        DuplicateFilter(AbstractWriter *slave):
-            AbstractFilter(slave)
+        DuplicateFilter(AbstractWriter *agent):
+            AbstractFilter(agent)
         {
         }
 
diff --git a/src/cslinker.cc b/src/cslinker.cc
@@ -114,10 +114,10 @@ void ImpFlagDecorator::handleDef(const Defect &defOrig)
         // found -> set "imp" flag to 1
         Defect def = defOrig;
         def.imp = 1;
-        slave_->handleDef(def);
+        agent_->handleDef(def);
     }
     else {
-        slave_->handleDef(defOrig);
+        agent_->handleDef(defOrig);
     }
 }
 
@@ -138,7 +138,7 @@ void ParsingRulesDecorator::handleDef(const Defect &defOrig)
 {
     Defect def = defOrig;
     gccPostProc_.apply(&def);
-    slave_->handleDef(def);
+    agent_->handleDef(def);
 }
 
 class OrphanWriter {
diff --git a/src/cwe-mapper.cc b/src/cwe-mapper.cc
@@ -201,13 +201,13 @@ void CweMapDecorator::handleDef(const Defect &orig)
 {
     if (d->cweMap.empty()) {
         // CweMap not populated
-        slave_->handleDef(orig);
+        agent_->handleDef(orig);
         return;
     }
 
     Defect def(orig);
     d->cweMap.assignCwe(def);
-    slave_->handleDef(def);
+    agent_->handleDef(def);
 }
 
 CweMap& CweMapDecorator::cweMap()
diff --git a/src/gcc-parser.cc b/src/gcc-parser.cc
@@ -45,17 +45,17 @@ class ITokenizer {
 class AbstractTokenFilter: public ITokenizer {
     public:
         virtual int lineNo() const {
-            return slave_->lineNo();
+            return agent_->lineNo();
         }
 
     protected:
-        /// @param slave the object will NOT be deleted on destruction
-        AbstractTokenFilter(ITokenizer *slave):
-            slave_(slave)
+        /// @param agent the object will NOT be deleted on destruction
+        AbstractTokenFilter(ITokenizer *agent):
+            agent_(agent)
         {
         }
 
-        ITokenizer *slave_;
+        ITokenizer *agent_;
 };
 
 #define RE_LOCATION "([^ #:\"][^:\"]+)(?::([0-9]+))?(?::([0-9]+))?"
@@ -174,8 +174,8 @@ EToken Tokenizer::readNext(DefEvent *pEvt)
 
 class NoiseFilter: public AbstractTokenFilter {
     public:
-        NoiseFilter(ITokenizer *slave):
-            AbstractTokenFilter(slave)
+        NoiseFilter(ITokenizer *agent):
+            AbstractTokenFilter(agent)
         {
         }
 
@@ -189,7 +189,7 @@ class NoiseFilter: public AbstractTokenFilter {
 EToken NoiseFilter::readNext(DefEvent *pEvt)
 {
     for (;;) {
-        const EToken tok = slave_->readNext(pEvt);
+        const EToken tok = agent_->readNext(pEvt);
         if (T_UNKNOWN != tok)
             return tok;
 
@@ -200,8 +200,8 @@ EToken NoiseFilter::readNext(DefEvent *pEvt)
 
 class MarkerConverter: public AbstractTokenFilter {
     public:
-        MarkerConverter(ITokenizer *slave):
-            AbstractTokenFilter(slave),
+        MarkerConverter(ITokenizer *agent):
+            AbstractTokenFilter(agent),
             lastTok_(T_NULL),
             lineNo_(0)
         {
@@ -224,13 +224,13 @@ EToken MarkerConverter::readNext(DefEvent *pEvt)
     EToken tok = lastTok_;
     if (T_NULL != tok) {
         *pEvt = lastEvt_;
-        lineNo_ = slave_->lineNo();
+        lineNo_ = agent_->lineNo();
         lastTok_ = T_NULL;
         return tok;
     }
 
-    tok = slave_->readNext(pEvt);
-    lineNo_ = slave_->lineNo();
+    tok = agent_->readNext(pEvt);
+    lineNo_ = agent_->lineNo();
     switch (tok) {
         case T_SIDEBAR:
             pEvt->event = "#";
@@ -244,7 +244,7 @@ EToken MarkerConverter::readNext(DefEvent *pEvt)
             return tok;
     }
 
-    lastTok_ = slave_->readNext(&lastEvt_);
+    lastTok_ = agent_->readNext(&lastEvt_);
     switch (lastTok_) {
         case T_SIDEBAR:
         case T_MARKER:
@@ -264,8 +264,8 @@ EToken MarkerConverter::readNext(DefEvent *pEvt)
 
 class MultilineConcatenator: public AbstractTokenFilter {
     public:
-        MultilineConcatenator(ITokenizer *slave):
-            AbstractTokenFilter(slave),
+        MultilineConcatenator(ITokenizer *agent):
+            AbstractTokenFilter(agent),
             lastTok_(T_NULL)
         {
         }
@@ -336,7 +336,7 @@ EToken MultilineConcatenator::readNext(DefEvent *pEvt)
     switch (lastTok_) {
         case T_NULL:
             // no last token --> we have to read a new one
-            tok = slave_->readNext(pEvt);
+            tok = agent_->readNext(pEvt);
             break;
 
         case T_MSG:
@@ -356,7 +356,7 @@ EToken MultilineConcatenator::readNext(DefEvent *pEvt)
     if (T_MSG == tok) {
         do
             // read one token ahead
-            lastTok_ = slave_->readNext(&lastEvt_);
+            lastTok_ = agent_->readNext(&lastEvt_);
 
         while
             // try to merge it with the previous one

Original file line number	Diff line number	Diff line change
`@@ -42,8 +42,8 @@ struct PredicateFilter::Private {`
`42`	`42`	`}`
`43`	`43`	`};`
`44`	`44`
`45`		`-PredicateFilter::PredicateFilter(AbstractWriter *slave):`
`46`		`- AbstractFilter(slave),`
	`45`	`+PredicateFilter::PredicateFilter(AbstractWriter *agent):`
	`46`	`+ AbstractFilter(agent),`
`47`	`47`	`d(new Private)`
`48`	`48`	`{`
`49`	`49`	`}`
`@@ -97,7 +97,7 @@ void EventPrunner::handleDef(const Defect &defOrig)`
`97`	`97`	`def.keyEventIdx--;`
`98`	`98`	`}`
`99`	`99`
`100`		`- slave_->handleDef(def);`
	`100`	`+ agent_->handleDef(def);`
`101`	`101`	`}`
`102`	`102`
`103`	`103`
`@@ -170,14 +170,14 @@ void CtxEmbedder::handleDef(const Defect &defOrig)`
`170`	`170`	`const DefEvent &evt = defOrig.events[defOrig.keyEventIdx];`
`171`	`171`	`if (!evt.line) {`
`172`	`172`	`// no line number for the key event`
`173`		`- slave_->handleDef(defOrig);`
	`173`	`+ agent_->handleDef(defOrig);`
`174`	`174`	`return;`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	`std::fstream fstr(evt.fileName.c_str(), std::ios::in);`
`178`	`178`	`if (!fstr) {`
`179`	`179`	`// failed to open input file`
`180`		`- slave_->handleDef(defOrig);`
	`180`	`+ agent_->handleDef(defOrig);`
`181`	`181`	`return;`
`182`	`182`	`}`
`183`	`183`
`@@ -188,5 +188,5 @@ void CtxEmbedder::handleDef(const Defect &defOrig)`
`188`	`188`
`189`	`189`	`// close the file stream and forward the result`
`190`	`190`	`fstr.close();`
`191`		`- slave_->handleDef(def);`
	`191`	`+ agent_->handleDef(def);`
`192`	`192`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,33 +25,33 @@`
`25`	`25`	`/// decorator`
`26`	`26`	`class GenericAbstractFilter: public AbstractWriter {`
`27`	`27`	`protected:`
`28`		`- AbstractWriter *slave_;`
	`28`	`+ AbstractWriter *agent_;`
`29`	`29`	`virtual void handleDef(const Defect &def) = 0;`
`30`	`30`
`31`	`31`	`public:`
`32`	`32`	`virtual void notifyFile(const std::string &fileName) {`
`33`		`- slave_->notifyFile(fileName);`
	`33`	`+ agent_->notifyFile(fileName);`
`34`	`34`	`}`
`35`	`35`
`36`		`- GenericAbstractFilter(AbstractWriter *slave):`
`37`		`- slave_(slave)`
	`36`	`+ GenericAbstractFilter(AbstractWriter *agent):`
	`37`	`+ agent_(agent)`
`38`	`38`	`{`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`~GenericAbstractFilter() {`
`42`		`- delete slave_;`
	`42`	`+ delete agent_;`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`virtual void flush() {`
`46`		`- slave_->flush();`
	`46`	`+ agent_->flush();`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`virtual const TScanProps& getScanProps() const {`
`50`		`- return slave_->getScanProps();`
	`50`	`+ return agent_->getScanProps();`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`virtual void setScanProps(const TScanProps &scanProps) {`
`54`		`- slave_->setScanProps(scanProps);`
	`54`	`+ agent_->setScanProps(scanProps);`
`55`	`55`	`}`
`56`	`56`	`};`
`57`	`57`
`@@ -61,8 +61,8 @@ class EventPrunner: public GenericAbstractFilter {`
`61`	`61`	`int thr_;`
`62`	`62`
`63`	`63`	`public:`
`64`		`- EventPrunner(AbstractWriter *slave, unsigned thr):`
`65`		`- GenericAbstractFilter(slave),`
	`64`	`+ EventPrunner(AbstractWriter *agent, unsigned thr):`
	`65`	`+ GenericAbstractFilter(agent),`
`66`	`66`	`thr_(thr)`
`67`	`67`	`{`
`68`	`68`	`}`
`@@ -76,8 +76,8 @@ class CtxEmbedder: public GenericAbstractFilter {`
`76`	`76`	`int ctxLines_;`
`77`	`77`
`78`	`78`	`public:`
`79`		`- CtxEmbedder(AbstractWriter *slave, const int ctxLines):`
`80`		`- GenericAbstractFilter(slave),`
	`79`	`+ CtxEmbedder(AbstractWriter *agent, const int ctxLines):`
	`80`	`+ GenericAbstractFilter(agent),`
`81`	`81`	`ctxLines_(ctxLines)`
`82`	`82`	`{`
`83`	`83`	`}`
`@@ -94,8 +94,8 @@ class AbstractFilter: public GenericAbstractFilter {`
`94`	`94`	`virtual bool matchDef(const Defect &def) = 0;`
`95`	`95`
`96`	`96`	`public:`
`97`		`- AbstractFilter(AbstractWriter *slave):`
`98`		`- GenericAbstractFilter(slave),`
	`97`	`+ AbstractFilter(AbstractWriter *agent):`
	`98`	`+ GenericAbstractFilter(agent),`
`99`	`99`	`neg_(false)`
`100`	`100`	`{`
`101`	`101`	`}`
`@@ -108,7 +108,7 @@ class AbstractFilter: public GenericAbstractFilter {`
`108`	`108`	`if (neg_ == matchDef(def))`
`109`	`109`	`return;`
`110`	`110`
`111`		`- slave_->handleDef(def);`
	`111`	`+ agent_->handleDef(def);`
`112`	`112`	`}`
`113`	`113`	`};`
`114`	`114`
`@@ -120,7 +120,7 @@ class IPredicate {`
`120`	`120`
`121`	`121`	`class PredicateFilter: public AbstractFilter {`
`122`	`122`	`public:`
`123`		`- PredicateFilter(AbstractWriter *slave);`
	`123`	`+ PredicateFilter(AbstractWriter *agent);`
`124`	`124`	`virtual ~PredicateFilter();`
`125`	`125`
`126`	`126`	`/// takes ownership of pred and will call delete on it on destruction`
Original file line number	Diff line number	Diff line change
`@@ -311,8 +311,8 @@ class SrcAnnotPredicate: public IPredicate {`
`311`	`311`
`312`	`312`	`class PathStripper: public GenericAbstractFilter {`
`313`	`313`	`public:`
`314`		`- PathStripper(AbstractWriter *slave, const std::string &prefix):`
`315`		`- GenericAbstractFilter(slave),`
	`314`	`+ PathStripper(AbstractWriter *agent, const std::string &prefix):`
	`315`	`+ GenericAbstractFilter(agent),`
`316`	`316`	`prefStr_(prefix),`
`317`	`317`	`prefSize_(prefix.size())`
`318`	`318`	`{`
`@@ -335,7 +335,7 @@ class PathStripper: public GenericAbstractFilter {`
`335`	`335`	`path.erase(/* pos */ 0U, prefSize_);`
`336`	`336`	`}`
`337`	`337`
`338`		`- slave_->handleDef(def);`
	`338`	`+ agent_->handleDef(def);`
`339`	`339`	`}`
`340`	`340`
`341`	`341`	`private:`
`@@ -345,8 +345,8 @@ class PathStripper: public GenericAbstractFilter {`
`345`	`345`
`346`	`346`	`class DuplicateFilter: public AbstractFilter {`
`347`	`347`	`public:`
`348`		`- DuplicateFilter(AbstractWriter *slave):`
`349`		`- AbstractFilter(slave)`
	`348`	`+ DuplicateFilter(AbstractWriter *agent):`
	`349`	`+ AbstractFilter(agent)`
`350`	`350`	`{`
`351`	`351`	`}`
`352`	`352`
Original file line number	Diff line number	Diff line change
`@@ -114,10 +114,10 @@ void ImpFlagDecorator::handleDef(const Defect &defOrig)`
`114`	`114`	`// found -> set "imp" flag to 1`
`115`	`115`	`Defect def = defOrig;`
`116`	`116`	`def.imp = 1;`
`117`		`- slave_->handleDef(def);`
	`117`	`+ agent_->handleDef(def);`
`118`	`118`	`}`
`119`	`119`	`else {`
`120`		`- slave_->handleDef(defOrig);`
	`120`	`+ agent_->handleDef(defOrig);`
`121`	`121`	`}`
`122`	`122`	`}`
`123`	`123`
`@@ -138,7 +138,7 @@ void ParsingRulesDecorator::handleDef(const Defect &defOrig)`
`138`	`138`	`{`
`139`	`139`	`Defect def = defOrig;`
`140`	`140`	`gccPostProc_.apply(&def);`
`141`		`- slave_->handleDef(def);`
	`141`	`+ agent_->handleDef(def);`
`142`	`142`	`}`
`143`	`143`
`144`	`144`	`class OrphanWriter {`
Original file line number	Diff line number	Diff line change
`@@ -201,13 +201,13 @@ void CweMapDecorator::handleDef(const Defect &orig)`
`201`	`201`	`{`
`202`	`202`	`if (d->cweMap.empty()) {`
`203`	`203`	`// CweMap not populated`
`204`		`- slave_->handleDef(orig);`
	`204`	`+ agent_->handleDef(orig);`
`205`	`205`	`return;`
`206`	`206`	`}`
`207`	`207`
`208`	`208`	`Defect def(orig);`
`209`	`209`	`d->cweMap.assignCwe(def);`
`210`		`- slave_->handleDef(def);`
	`210`	`+ agent_->handleDef(def);`
`211`	`211`	`}`
`212`	`212`
`213`	`213`	`CweMap& CweMapDecorator::cweMap()`