Cosmetic changes to pass compilation

Signed-off-by: Kenji Hosokawa <khosokawa@jp.adit-jv.com>

4 files changed, 26 insertions, 26 deletions

diff --git a/src/core/logic/RBAAffectInfo.cpp b/src/core/logic/RBAAffectInfo.cpp
index 6cf4e98..2186ad2 100644
--- a/src/core/logic/RBAAffectInfo.cpp
+++ b/src/core/logic/RBAAffectInfo.cpp
@@ -55,8 +55,8 @@ RBAAffectInfo::addInfoThatFormerAffectedToLatter(const RBAAllocatable* const all
 
 /**
  * @brief Deletes the Affect information of "allocatable" registered by 
- * 　　　　　　　other allocatables registered by arbitration of the specified 
- * 　　　　　　　recursion hierarchy of the specified "allocatable".
+ *               other allocatables registered by arbitration of the specified 
+ *               recursion hierarchy of the specified "allocatable".
  * @param affectAllocatable
  */
 void RBAAffectInfo::removeAffectInfo(const RBAAllocatable* const affectAllocatable)
diff --git a/src/core/logic/RBAArbitrator.cpp b/src/core/logic/RBAArbitrator.cpp
index 9fdd7d3..74db3aa 100644
--- a/src/core/logic/RBAArbitrator.cpp
+++ b/src/core/logic/RBAArbitrator.cpp
@@ -510,7 +510,7 @@ RBAArbitrator::arbitrateMain()
   result_ = std::make_unique<RBAResultImpl>(retResult.get());
 
   // A compile error occurs if std::move() is missing because 
-  // std::unique_ptr<RBAResultImpl>　is cast to std::unique_ptr<RBAResult>
+  // std::unique_ptr<RBAResultImpl>  is cast to std::unique_ptr<RBAResult>
   return std::move(retResult);
 }
 
@@ -659,7 +659,7 @@ arbitrate(std::list<RBAAllocatable*>& allocatables)
     revisited = revisitedInitSet;
     // -------------------------------------------------------------------------
     // To prevent an infinite loop, generate information to limit registration 
-  　　// of other "allocable" that affected the target "allocatable" 
+      // of other "allocable" that affected the target "allocatable" 
     // during arbitration
     // -------------------------------------------------------------------------
     RBAAffectInfo affectInfo;
@@ -825,7 +825,7 @@ void RBAArbitrator::arbitrateAllocatable(
     }
   }
   // ---------------------------------------------------------------------
-  // Re-arbitration of the Allocatable　that influenced
+  // Re-arbitration of the Allocatable  that influenced
   // ---------------------------------------------------------------------
   if ((beforeState != allocatable->getState())
           || allocatable->isHidden()
@@ -876,7 +876,7 @@ void RBAArbitrator::arbitrateAllocatable(
       //  This is a 'const_cast' expression that strips away a 'const' or 
       //  'volatile' qualifier.
       // [Why there is no problem if it deviate from the rules]
-    　　//  Confirmed that there is no problem from the design point of view.
+        //  Confirmed that there is no problem from the design point of view.
       //  We won't fix it now because we need to redesign the class, but
       //  no much effort as of now.
       RBAAllocatable* allo {const_cast<RBAAllocatable*>(affectAllocatable)};
@@ -970,7 +970,7 @@ collectRevisitAllocatable(std::list<const RBAAllocatable*>* const totalRevisitAl
 {
   std::set<const RBAAllocatable*> revisitAllocatablesSet;
 
-　　// Determine if re-arbitration should be done based on the constraint 
+    // Determine if re-arbitration should be done based on the constraint 
   // that the determination was NG
   for(RBAConstraintImpl*& constraint : falseConstraints) {
     // Get Contraint information
@@ -982,7 +982,7 @@ collectRevisitAllocatable(std::list<const RBAAllocatable*>* const totalRevisitAl
       info->collectRearbitrationTargetFor(allocatable, rightFalseAllocatables, false);
     }
     if (rightFalseAllocatables.empty()) {
-      // Non-implication constraint　expression
+      // Non-implication constraint  expression
       // To ensure that "currently arbitrated allocable" does not lose to lower 
       // priority allocable, arbitration of low priority Allocable is performed 
       // if low priority Allocable is included in 
@@ -1211,7 +1211,7 @@ updateResult()
   // Deactivate canceled Content
   result_->updateActiveContentStates();
 
-  // Update coordinates　of Area 
+  // Update coordinates  of Area 
   for(auto& area : result_->getVisibleAreas()) {
     const RBAAreaImpl* const areaImpl {dynamic_cast<const RBAAreaImpl*>(area)};
     const auto posCont = model_->findPositionContainerImpl(area->getName());
diff --git a/src/core/logic/RBAConstraintInfo.cpp b/src/core/logic/RBAConstraintInfo.cpp
index b208c5f..8614394 100644
--- a/src/core/logic/RBAConstraintInfo.cpp
+++ b/src/core/logic/RBAConstraintInfo.cpp
@@ -135,7 +135,7 @@ void RBAConstraintInfo::clear()
     // @Deviation (MEM05-CPP,Rule-7_5_4,A7-5-2)
     //  [Contents that deviate from the rules]
     //   recursively calling clear()
-    // 　[Reason that there is no problem if the rule is deviated]
+    //   [Reason that there is no problem if the rule is deviated]
     //   ConstraintInfo is created for each node in the Constraint expression 
     //   tree. The Constraint expression tree is determined by the constraint 
     //   expressions written in the model file, and its depth is finite.
@@ -177,7 +177,7 @@ bool RBAConstraintInfo::needsReRearbitrationFor(
           //  [Contents that deviate from the rules]
           //   Function '::rba::RBAConstraintInfo::needsReRearbitrationFor=(_,
           //                          p={c::rba::RBAAllocatable})' is recursive.
-          // 　[Reason that there is no problem if the rule is deviated]
+          //   [Reason that there is no problem if the rule is deviated]
           //   Recursive call is required as a feature
           result = children_.back()->needsReRearbitrationFor(allocatable);
         }
@@ -198,7 +198,7 @@ bool RBAConstraintInfo::needsReRearbitrationFor(
 bool RBAConstraintInfo::needsRearbitrationFor(const RBAAllocatable* const allocatable,
                                               bool isImplies) const
 {
-  bool result {false};  // 再調停要否
+  bool result {false};  // Necessity of re-arbitration
   if (children_.empty() == false) {
     // When the syntax of the constraint expression is 
     //  - ImpliesOperator
@@ -248,13 +248,13 @@ bool RBAConstraintInfo::needsRearbitrationFor(const RBAAllocatable* const alloca
           //  [Contents that deviate from the rules]
           //   Function '::rba::RBAConstraintInfo::needsRearbitrationFor=(_,
           //                       p={c::rba::RBAAllocatable},_o)' is recursive. 
-          // 　[Reason that there is no problem if the rule is deviated]
+          //   [Reason that there is no problem if the rule is deviated]
           //   Recursive call is required as a feature
           result = (result || child->needsRearbitrationFor(allocatable, isImplies));
         }
         // The Constraint expression does not include IF or implication,
         //  or
-        // the Allocatable state reference expression is not included　in the 
+        // the Allocatable state reference expression is not included  in the 
         // left side of the IF condition of the parent syntax or 
         // the implication of the parent syntax,
         //  or
@@ -333,7 +333,7 @@ void RBAConstraintInfo::collectRearbitrationTargetFor(
         //   Function '::rba::RBAConstraintInfo::collectRearbitrationTargetFor=(_,p={c::rba::RBAAllocatable},
         //     &{c::std::set<p={c::rba::RBAAllocatable},{c::std::less<p={c::rba::RBAAllocatable}>},
         //     {c::std::allocator<p={c::rba::RBAAllocatable}>}>},_o)' is recursive. 
-        // 　[Reason that there is no problem if the rule is deviated]
+        //   [Reason that there is no problem if the rule is deviated]
         //   Recursive call is required as a feature
         children_.front()->collectRearbitrationTargetFor(allocatable, targets,
                                                          !isNot);
@@ -374,7 +374,7 @@ void RBAConstraintInfo::collectTrueAllocatables(
       //     &{c::std::set<p={c::rba::RBAAllocatable},
       //     {c::std::less<p={c::rba::RBAAllocatable}>},
       //     {c::std::allocator<p={c::rba::RBAAllocatable}>}>})' is recursive. 
-      // 　[Reason that there is no problem if the rule is deviated]
+      //   [Reason that there is no problem if the rule is deviated]
       //   Recursive call is required as a feature
       child->collectTrueAllocatables(allocatables);
     }
@@ -411,7 +411,7 @@ void RBAConstraintInfo::collectFalseAllocatables(
       //           {c::std::less<p={c::rba::RBAAllocatable}>},
       //           {c::std::allocator<p={c::rba::RBAAllocatable}>}>})' 
       //   is recursive. 
-      // 　[Reason that there is no problem if the rule is deviated]
+      //   [Reason that there is no problem if the rule is deviated]
       //   Recursive call is required as a feature
       child->collectFalseAllocatables(allocatables);
     }
@@ -440,7 +440,7 @@ bool RBAConstraintInfo::contains(const RBAAllocatable* const allocatable) const
     //   Function '::rba::RBAConstraintInfo::contains=(_,
     //                                p={c::rba::RBAAllocatable})' 
     //   is recursive. 
-    // 　[Reason that there is no problem if the rule is deviated]
+    //   [Reason that there is no problem if the rule is deviated]
     //   Recursive call is required as a feature
     if (child->contains(allocatable)) {
       return true;
@@ -489,7 +489,7 @@ void RBAConstraintInfo::collectAffectedAllocatables(
       // the same processing is performed, because "Exists {A,B}{x|x.isXXX}" 
       // is equivalent to "A.isXXX OR B.isXXX"
       if (!isRevert) {
-        // Processing when "Info" of "OR"　in which evaluation result that is not 
+        // Processing when "Info" of "OR"  in which evaluation result that is not 
         // qualified by an odd number of negative is "Skip" or evaluation reslt 
         // that is not qualified by an odd number of negative is "False".
         if (!isTrue()) {
@@ -507,7 +507,7 @@ void RBAConstraintInfo::collectAffectedAllocatables(
           }
         }
       } else {
-        // Processing when "Info" of "OR"　in which evaluation result that is not 
+        // Processing when "Info" of "OR"  in which evaluation result that is not 
         // qualified by an odd number of negative is "Skip" or evaluation reslt 
         // that is not qualified by an odd number of negative is "False".
         // "!(A.isXXX OR B.isXXX)" can be decomposed into 
@@ -526,7 +526,7 @@ void RBAConstraintInfo::collectAffectedAllocatables(
       //"For-All {A,B}{x|x.isXXX}" is equivalent to "A.isXXX AND B.isXXX", 
       // so the same processing is performed
       if (isRevert) {
-        // Processing when "Info" of "AND"　in which evaluation result that 
+        // Processing when "Info" of "AND"  in which evaluation result that 
         // is not qualified by an odd number of "negative" is "Skip" or 
         // evaluation reslt that is not qualified by an odd number of negative 
         // is "True".
@@ -540,21 +540,21 @@ void RBAConstraintInfo::collectAffectedAllocatables(
             //  [Contents that deviate from the rules]
             //   Function '::rba::RBAConstraintInfo::collectAffectedAllocatables(_,_o,&{c::std::set<p={c::rba::RBAAllocatable},
             //   {c::std::less<p={c::rba::RBAAllocatable}>},{c::std::allocator<p={c::rba::RBAAllocatable}>}>},_o)' is recursive.
-            // 　[Reason that there is no problem if the rule is deviated]
+            //   [Reason that there is no problem if the rule is deviated]
             //   Recursive call is required as a feature
             i->collectAffectedAllocatables(isRevert, affectAllocatables, true,
                                            forObject);
           }
         }
       } else {
-        // Processing when "Info" of "AND"　in which evaluation result that 
+        // Processing when "Info" of "AND"  in which evaluation result that 
         // is not qualified by an odd number of "negative" is "Skip" or 
         // evaluation reslt that is not qualified by an odd number of negative 
         // is "True".
         //
         // When "A.isXXX AND B.isXXX", the evaluation result of "AND" does not 
         // become True unless the evaluation result of B becomes True, 
-        // regardless of the evaluation result of A.　Therefore, A does not 
+        // regardless of the evaluation result of A.  Therefore, A does not 
         // affect B, and B does not affect A.
         // Therefore, "collecting" is as it is, and the "child Info" is 
         // searched for an allocable influence.
diff --git a/src/core/logic/RBAResultSet.cpp b/src/core/logic/RBAResultSet.cpp
index bcc9892..d516406 100644
--- a/src/core/logic/RBAResultSet.cpp
+++ b/src/core/logic/RBAResultSet.cpp
@@ -267,7 +267,7 @@ RBAResultSet::getArea(const RBAViewContentState* const state,
           // @Deviation (MEM05-CPP,Rule-7_5_4,A7-5-2)
           //  [Contents that deviate from the rules]
           //   calling getArea() recursively
-          // 　[Reason that there is no problem if the rule is deviated]
+          //   [Reason that there is no problem if the rule is deviated]
           //   When getArea() is performed on CyclicContent, at that time, 
           //   respond Area where ViewContent assigned to CyclicContent 
           //   is assigned. When CyclicContent is assigned to CyclicContent, 
@@ -301,7 +301,7 @@ RBAResultSet::getZone(const RBASoundContentState* const state,
           //                  &{c::std::__cxx11::list<p={c::rba::RBAZone},
           //                  {c::std::allocator<p={c::rba::RBAZone}>}>})' 
           //   is recursive. 
-          // 　[Reason that there is no problem if the rule is deviated]
+          //   [Reason that there is no problem if the rule is deviated]
           //   Recursive call is required as a feature
           getZone(ownerState, zoneList);
         } else {