reformatting code according to guidelines defined at

http://wololo.net/forum/viewtopic.php?f=35&t=2235&start=10

projects/mtg/src/ThisDescriptor.cpp

@@ -5,330 +5,394 @@
 #include "MTGCardInstance.h"
 #include "CardDescriptor.h"
 
-
-ThisDescriptor::~ThisDescriptor(){
-  //nothing to do for now
+ThisDescriptor::~ThisDescriptor()
+{
+    //nothing to do for now
 }
 
 //Returns the amount by which a value passes the comparison.
-int ThisDescriptor::matchValue(int value){
-  switch (comparisonMode){
+int ThisDescriptor::matchValue(int value)
+{
+    switch (comparisonMode)
+    {
     case COMPARISON_AT_MOST:
-      return (comparisonCriterion - value + 1);
+        return (comparisonCriterion - value + 1);
     case COMPARISON_AT_LEAST:
-      return (value - comparisonCriterion + 1);
+        return (value - comparisonCriterion + 1);
     case COMPARISON_EQUAL:
-      return (comparisonCriterion == value);
+        return (comparisonCriterion == value);
     case COMPARISON_GREATER:
-      return (value - comparisonCriterion);
+        return (value - comparisonCriterion);
     case COMPARISON_LESS:
-      return (comparisonCriterion - value);
+        return (comparisonCriterion - value);
     case COMPARISON_UNEQUAL:
-      return (comparisonCriterion != value);       
-  }
-  return 0;
+        return (comparisonCriterion != value);
+    }
+    return 0;
 }
 
-ThisDescriptor * ThisDescriptorFactory::createThisDescriptor(string s){
-  size_t found;
- 
-  string whitespaces (" \t\f\v\n\r");
+ThisDescriptor * ThisDescriptorFactory::createThisDescriptor(string s)
+{
+    size_t found;
 
-  found=s.find_last_not_of(whitespaces);
-  if (found!=string::npos)
-    s.erase(found+1);
-  else return NULL;
+    string whitespaces(" \t\f\v\n\r");
 
-  found=s.find_first_not_of(whitespaces);
-  if (found!=string::npos)
-    s.erase(0,found);
-  else return NULL;
+    found = s.find_last_not_of(whitespaces);
+    if (found != string::npos)
+        s.erase(found + 1);
+    else
+        return NULL;
 
-  //set comparison mode
-  //equal, greater, and less must remain above the others, otherwise the others may never be used.
-  int mode = 0;
-  size_t found2 = string::npos;
-  int opLength = 0;
+    found = s.find_first_not_of(whitespaces);
+    if (found != string::npos)
+        s.erase(0, found);
+    else
+        return NULL;
 
-  found = s.find("=");
-  if (found != string::npos){
-    mode = COMPARISON_EQUAL;
-    found2 = found + 1;
-    opLength = 1;
-  }
-  found = s.find(">");
-  if (found != string::npos){
-    mode = COMPARISON_GREATER;
-    found2 = found + 1;
-    opLength = 1;
-  }
-  found = s.find("<");
-  if (found != string::npos){
-    mode = COMPARISON_LESS;
-    found2 = found + 1; 
-    opLength = 1;
-  }
-  found = s.find("<=");
-  if (found != string::npos){
-    mode = COMPARISON_AT_MOST; 
-    found2 = found + 2; 
-    opLength = 2;
-  }
-  found = s.find(">=");
-  if (found != string::npos){
-    mode = COMPARISON_AT_LEAST;
-    found2 = found + 2;
-    opLength = 2;
-  }
-  found = s.find("!=");
-  if (found != string::npos){
-    mode  = COMPARISON_UNEQUAL; 
-    found2 = found + 2; 
-    opLength = 2;
-  }
-  if (!mode) mode = COMPARISON_AT_LEAST;
+    //set comparison mode
+    //equal, greater, and less must remain above the others, otherwise the others may never be used.
+    int mode = 0;
+    size_t found2 = string::npos;
+    int opLength = 0;
 
-  //get comparison criterion
-  int criterionFound = 0;
-  int criterion = 1;
-  if ((found2 != string::npos) && (found2 < s.length())){
-    criterion = atoi(s.substr(found2).c_str());
-    criterionFound = 1;
-  }
-  if (found2 != string::npos) s.erase(found2 - opLength);
-
-  //counters
-  found = s.find("counter{");
-  if (found != string::npos) {
-    size_t start = s.find("{");
-    size_t end = s.find("}");
-    string counterString = s.substr(start+1,end-start-1);
-    AbilityFactory abf;
-    Counter * counter = abf.parseCounter(counterString,NULL);
-    if (counter) {
-      if (criterionFound) counter->nb = criterion;
-      ThisCounter * td = NEW ThisCounter(counter);
-      if (td) {
-        td->comparisonMode = mode;
-        return td;
-      }
+    found = s.find("=");
+    if (found != string::npos)
+    {
+        mode = COMPARISON_EQUAL;
+        found2 = found + 1;
+        opLength = 1;
     }
-    return NULL;
-  }
-
-  //any counter
-  found = s.find("counters");
-  if (found != string::npos) {
-    ThisCounterAny * td = NEW ThisCounterAny(criterion);
-    if (td) {
-      td->comparisonMode = mode;
-      return td;
+    found = s.find(">");
+    if (found != string::npos)
+    {
+        mode = COMPARISON_GREATER;
+        found2 = found + 1;
+        opLength = 1;
     }
-    return NULL;
-  }
-
-  //equips
-  found = s.find("gear");//still same meaning, better wording to word conflict with MTGAbility equip.
-  if (found != string::npos) {
-    ThisEquip * td = NEW ThisEquip(criterion);
-    if (td) {
-      td->comparisonMode = mode;
-      return td;
+    found = s.find("<");
+    if (found != string::npos)
+    {
+        mode = COMPARISON_LESS;
+        found2 = found + 1;
+        opLength = 1;
     }
-    return NULL;
-  }
-
-	  //whenever this creature attacks do effect
-  found = s.find("attacking");
-  if (found != string::npos) {
-    ThisAttacked * td = NEW ThisAttacked(criterion);
-    if (td) {
-      td->comparisonMode = mode;
-      return td;
+    found = s.find("<=");
+    if (found != string::npos)
+    {
+        mode = COMPARISON_AT_MOST;
+        found2 = found + 2;
+        opLength = 2;
     }
-    return NULL;
-  }
-
-		  //whenever this creature attacks do effect
-  found = s.find("notblocked");
-  if (found != string::npos) {
-    ThisNotBlocked * td = NEW ThisNotBlocked(criterion);
-    if (td) {
-      td->comparisonMode = mode;
-      return td;
+    found = s.find(">=");
+    if (found != string::npos)
+    {
+        mode = COMPARISON_AT_LEAST;
+        found2 = found + 2;
+        opLength = 2;
     }
-    return NULL;
-  }
-
-     //controller life
-  found = s.find("opponentlife");
-  if (found != string::npos) {
-    ThisOpponentlife * td = NEW ThisOpponentlife(criterion);
-    if (td) {
-      td->comparisonMode = mode;
-      return td;
+    found = s.find("!=");
+    if (found != string::npos)
+    {
+        mode = COMPARISON_UNEQUAL;
+        found2 = found + 2;
+        opLength = 2;
     }
-    return NULL;
-  }
+    if (!mode) mode = COMPARISON_AT_LEAST;
 
-   //controller life
-  found = s.find("controllerlife");
-  if (found != string::npos) {
-    ThisControllerlife * td = NEW ThisControllerlife(criterion);
-    if (td) {
-      td->comparisonMode = mode;
-      return td;
+    //get comparison criterion
+    int criterionFound = 0;
+    int criterion = 1;
+    if ((found2 != string::npos) && (found2 < s.length()))
+    {
+        criterion = atoi(s.substr(found2).c_str());
+        criterionFound = 1;
     }
-    return NULL;
-  }
+    if (found2 != string::npos) s.erase(found2 - opLength);
 
-     //power
-  found = s.find("power");
-  if (found != string::npos) {
-    ThisPower * td = NEW ThisPower(criterion);
-    if (td) {
-      td->comparisonMode = mode;
-      return td;
+    //counters
+    found = s.find("counter{");
+    if (found != string::npos)
+    {
+        size_t start = s.find("{");
+        size_t end = s.find("}");
+        string counterString = s.substr(start + 1, end - start - 1);
+        AbilityFactory abf;
+        Counter * counter = abf.parseCounter(counterString, NULL);
+        if (counter)
+        {
+            if (criterionFound) counter->nb = criterion;
+            ThisCounter * td = NEW ThisCounter(counter);
+            if (td)
+            {
+                td->comparisonMode = mode;
+                return td;
+            }
+        }
+        return NULL;
     }
-    return NULL;
-  }
 
-  //toughness
-  found = s.find("toughness");
-  if (found != string::npos) {
-    ThisToughness * td = NEW ThisToughness(criterion);
-    if (td) {
-      td->comparisonMode = mode;
-      return td;
+    //any counter
+    found = s.find("counters");
+    if (found != string::npos)
+    {
+        ThisCounterAny * td = NEW ThisCounterAny(criterion);
+        if (td)
+        {
+            td->comparisonMode = mode;
+            return td;
+        }
+        return NULL;
     }
-    return NULL;
-  }
 
-  // X
-  found = s.find("x");
-  if (found != string::npos) {
-    ThisX * td = NEW ThisX(criterion);
-    if (td){
-      td->comparisonMode = mode;
-      return td;
+    //equips
+    found = s.find("gear");//still same meaning, better wording to word conflict with MTGAbility equip.
+    if (found != string::npos)
+    {
+        ThisEquip * td = NEW ThisEquip(criterion);
+        if (td)
+        {
+            td->comparisonMode = mode;
+            return td;
+        }
+        return NULL;
     }
-    return NULL;
-  }
 
-  return NULL;
+    //whenever this creature attacks do effect
+    found = s.find("attacking");
+    if (found != string::npos)
+    {
+        ThisAttacked * td = NEW ThisAttacked(criterion);
+        if (td)
+        {
+            td->comparisonMode = mode;
+            return td;
+        }
+        return NULL;
+    }
+
+    //whenever this creature attacks do effect
+    found = s.find("notblocked");
+    if (found != string::npos)
+    {
+        ThisNotBlocked * td = NEW ThisNotBlocked(criterion);
+        if (td)
+        {
+            td->comparisonMode = mode;
+            return td;
+        }
+        return NULL;
+    }
+
+    //controller life
+    found = s.find("opponentlife");
+    if (found != string::npos)
+    {
+        ThisOpponentlife * td = NEW ThisOpponentlife(criterion);
+        if (td)
+        {
+            td->comparisonMode = mode;
+            return td;
+        }
+        return NULL;
+    }
+
+    //controller life
+    found = s.find("controllerlife");
+    if (found != string::npos)
+    {
+        ThisControllerlife * td = NEW ThisControllerlife(criterion);
+        if (td)
+        {
+            td->comparisonMode = mode;
+            return td;
+        }
+        return NULL;
+    }
+
+    //power
+    found = s.find("power");
+    if (found != string::npos)
+    {
+        ThisPower * td = NEW ThisPower(criterion);
+        if (td)
+        {
+            td->comparisonMode = mode;
+            return td;
+        }
+        return NULL;
+    }
+
+    //toughness
+    found = s.find("toughness");
+    if (found != string::npos)
+    {
+        ThisToughness * td = NEW ThisToughness(criterion);
+        if (td)
+        {
+            td->comparisonMode = mode;
+            return td;
+        }
+        return NULL;
+    }
+
+    // X
+    found = s.find("x");
+    if (found != string::npos)
+    {
+        ThisX * td = NEW ThisX(criterion);
+        if (td)
+        {
+            td->comparisonMode = mode;
+            return td;
+        }
+        return NULL;
+    }
+
+    return NULL;
 }
 
-ThisCounter::ThisCounter(Counter * _counter){
-  counter = _counter;
-  comparisonCriterion = counter->nb;
+ThisCounter::ThisCounter(Counter * _counter)
+{
+    counter = _counter;
+    comparisonCriterion = counter->nb;
 }
 
-ThisCounter::ThisCounter(int power, int toughness, int nb, const char * name){
-  counter = NEW Counter(NULL,name,power,toughness);
-  comparisonCriterion = nb;
+ThisCounter::ThisCounter(int power, int toughness, int nb, const char * name)
+{
+    counter = NEW Counter(NULL, name, power, toughness);
+    comparisonCriterion = nb;
 }
 
-int ThisCounter::match(MTGCardInstance * card){
-  Counter * targetCounter = card->counters->hasCounter(counter->name.c_str(),counter->power,counter->toughness);
-    if (targetCounter){
-      return matchValue(targetCounter->nb);
-    }else{
-      switch (comparisonMode) {
+int ThisCounter::match(MTGCardInstance * card)
+{
+    Counter * targetCounter = card->counters->hasCounter(counter->name.c_str(), counter->power, counter->toughness);
+    if (targetCounter)
+    {
+        return matchValue(targetCounter->nb);
+    }
+    else
+    {
+        switch (comparisonMode)
+        {
         case COMPARISON_LESS:
-          return comparisonCriterion;
+            return comparisonCriterion;
         case COMPARISON_AT_MOST:
-          return comparisonCriterion + 1;
+            return comparisonCriterion + 1;
         case COMPARISON_UNEQUAL:
-          if (comparisonCriterion) return 1;
-          else return 0;
+            if (comparisonCriterion)
+                return 1;
+            else
+                return 0;
         case COMPARISON_EQUAL:
-          if (comparisonCriterion) return 0;
-          else return 1;
-        default :
-          return 0;
-      }
+            if (comparisonCriterion)
+                return 0;
+            else
+                return 1;
+        default:
+            return 0;
+        }
     }
 }
 
-ThisCounter::~ThisCounter() {
-  SAFE_DELETE(counter);
+ThisCounter::~ThisCounter()
+{
+    SAFE_DELETE(counter);
 }
 
-ThisOpponentlife::ThisOpponentlife(int olife){
-  comparisonCriterion = olife;
+ThisOpponentlife::ThisOpponentlife(int olife)
+{
+    comparisonCriterion = olife;
 }
 
-int ThisOpponentlife::match(MTGCardInstance * card){
-	return matchValue(card->controller()->opponent()->life);
+int ThisOpponentlife::match(MTGCardInstance * card)
+{
+    return matchValue(card->controller()->opponent()->life);
 }
 
-ThisControllerlife::ThisControllerlife(int life){
-  comparisonCriterion = life;
+ThisControllerlife::ThisControllerlife(int life)
+{
+    comparisonCriterion = life;
 }
 
-int ThisControllerlife::match(MTGCardInstance * card){
-	return matchValue(card->controller()->life);
+int ThisControllerlife::match(MTGCardInstance * card)
+{
+    return matchValue(card->controller()->life);
 }
 
-ThisPower::ThisPower(int power){
-  comparisonCriterion = power;
+ThisPower::ThisPower(int power)
+{
+    comparisonCriterion = power;
 }
 
-int ThisPower::match(MTGCardInstance * card){
-  return matchValue(card->power);
+int ThisPower::match(MTGCardInstance * card)
+{
+    return matchValue(card->power);
 }
 
-ThisEquip::ThisEquip(int equipment){
-  comparisonCriterion = equipment;
+ThisEquip::ThisEquip(int equipment)
+{
+    comparisonCriterion = equipment;
 }
-int ThisEquip::match(MTGCardInstance * card){
-  return matchValue(card->equipment);
+int ThisEquip::match(MTGCardInstance * card)
+{
+    return matchValue(card->equipment);
 }
 
-ThisAttacked::ThisAttacked(int attack){
+ThisAttacked::ThisAttacked(int attack)
+{
 
-	comparisonCriterion = attack;
+    comparisonCriterion = attack;
 }
 
-int ThisAttacked::match(MTGCardInstance * card){
+int ThisAttacked::match(MTGCardInstance * card)
+{
 
-	return matchValue(card->didattacked);
+    return matchValue(card->didattacked);
 }
 
-ThisNotBlocked::ThisNotBlocked(int unblocked){
+ThisNotBlocked::ThisNotBlocked(int unblocked)
+{
 
-	comparisonCriterion = unblocked;
+    comparisonCriterion = unblocked;
 }
 
-int ThisNotBlocked::match(MTGCardInstance * card){
+int ThisNotBlocked::match(MTGCardInstance * card)
+{
 
-	return matchValue(card->notblocked);
+    return matchValue(card->notblocked);
 }
 
-ThisToughness::ThisToughness(int toughness){
-  comparisonCriterion = toughness;
+ThisToughness::ThisToughness(int toughness)
+{
+    comparisonCriterion = toughness;
 }
 
-int ThisToughness::match(MTGCardInstance * card){
-  return matchValue(card->toughness);
+int ThisToughness::match(MTGCardInstance * card)
+{
+    return matchValue(card->toughness);
 }
 
-ThisCounterAny::ThisCounterAny(int nb){
-  comparisonCriterion = nb;
+ThisCounterAny::ThisCounterAny(int nb)
+{
+    comparisonCriterion = nb;
 }
 
-int ThisCounterAny::match(MTGCardInstance * card){
-  int result = 0;
-  for (int i = 0; i < card->counters->mCount; i++) {
-    result += card->counters->counters[i]->nb;
-  }
-  return matchValue(result);
+int ThisCounterAny::match(MTGCardInstance * card)
+{
+    int result = 0;
+    for (int i = 0; i < card->counters->mCount; i++)
+    {
+        result += card->counters->counters[i]->nb;
+    }
+    return matchValue(result);
 }
 
-ThisX::ThisX(int x){
-  comparisonCriterion = x;
+ThisX::ThisX(int x)
+{
+    comparisonCriterion = x;
 }
 
-int ThisX::match(MTGCardInstance * card){
-  return matchValue(card->X);
-}
+int ThisX::match(MTGCardInstance * card)
+{
+    return matchValue(card->X);
+}