Apply clang-format

1 files changed, 217 insertions, 200 deletions

diff --git a/utils/synutils/argument_reorder_model.h b/utils/synutils/argument_reorder_model.h
index b553b34b..062b8841 100644
--- a/utils/synutils/argument_reorder_model.h
+++ b/utils/synutils/argument_reorder_model.h
@@ -12,211 +12,228 @@
 #include "tree.h"
 #include "srl_sentence.h"
 
-
-//an argument item or a predicate item (the verb itself)
-struct SSRLItem{
-        SSRLItem(const STreeItem *tree_item, string role):
-        tree_item_(tree_item),
-        role_(role) {
-
-        }
-        ~SSRLItem() {
-
-        }
-        const STreeItem *tree_item_;
-        const string role_;
+// an argument item or a predicate item (the verb itself)
+struct SSRLItem {
+  SSRLItem(const STreeItem *tree_item, string role)
+      : tree_item_(tree_item), role_(role) {}
+  ~SSRLItem() {}
+  const STreeItem *tree_item_;
+  const string role_;
 };
 
-struct SPredicateItem{
-	SPredicateItem(const SParsedTree *tree, const SPredicate *pred):
-                pred_(pred) {
-                vec_items_.reserve(pred->m_vecArgt.size() + 1);
-                for (int i = 0; i < pred->m_vecArgt.size(); i++) {
-                        vec_items_.push_back(new SSRLItem(pred->m_vecArgt[i]->m_pTreeItem, string(pred->m_vecArgt[i]->m_pszRole)));
-                }
-                vec_items_.push_back(new SSRLItem(tree->m_vecTerminals[pred->m_iPosition]->m_ptParent, string("Pred")));
-                sort(vec_items_.begin(), vec_items_.end(), SortFunction);
-
-                begin_ = vec_items_[0]->tree_item_->m_iBegin;
-                end_ = vec_items_[vec_items_.size() - 1]->tree_item_->m_iEnd;
-        }
-
-        ~SPredicateItem() {
-                vec_items_.clear();
-        }
-
-        static bool SortFunction (SSRLItem *i, SSRLItem* j) { return (i->tree_item_->m_iBegin < j->tree_item_->m_iBegin); }
-
-        vector<SSRLItem*> vec_items_;
-        int begin_;
-        int end_;
-        const SPredicate *pred_;
+struct SPredicateItem {
+  SPredicateItem(const SParsedTree *tree, const SPredicate *pred)
+      : pred_(pred) {
+    vec_items_.reserve(pred->m_vecArgt.size() + 1);
+    for (int i = 0; i < pred->m_vecArgt.size(); i++) {
+      vec_items_.push_back(new SSRLItem(pred->m_vecArgt[i]->m_pTreeItem,
+                                        string(pred->m_vecArgt[i]->m_pszRole)));
+    }
+    vec_items_.push_back(new SSRLItem(
+        tree->m_vecTerminals[pred->m_iPosition]->m_ptParent, string("Pred")));
+    sort(vec_items_.begin(), vec_items_.end(), SortFunction);
+
+    begin_ = vec_items_[0]->tree_item_->m_iBegin;
+    end_ = vec_items_[vec_items_.size() - 1]->tree_item_->m_iEnd;
+  }
+
+  ~SPredicateItem() { vec_items_.clear(); }
+
+  static bool SortFunction(SSRLItem *i, SSRLItem *j) {
+    return (i->tree_item_->m_iBegin < j->tree_item_->m_iBegin);
+  }
+
+  vector<SSRLItem *> vec_items_;
+  int begin_;
+  int end_;
+  const SPredicate *pred_;
 };
 
 struct SArgumentReorderModel {
-public:
-	static string fnGetBlockOutcome(int iBegin, int iEnd, SAlignment *pAlign) {
-		return pAlign->fnIsContinuous(iBegin, iEnd);
-	}
-	static void fnGetReorderType(SPredicateItem *pPredItem, SAlignment *pAlign, vector<string>& vecStrLeftReorder, vector<string>& vecStrRightReorder) {
-    	vector<int> vecLeft, vecRight;
-    	for (int i = 0; i < pPredItem->vec_items_.size(); i++) {
-            const STreeItem *pCon1 = pPredItem->vec_items_[i]->tree_item_;
-    		int iLeft1, iRight1;
-            pAlign->fnGetLeftRightMost(pCon1->m_iBegin, pCon1->m_iEnd, true, iLeft1, iRight1);
-            vecLeft.push_back(iLeft1);
-            vecRight.push_back(iRight1);
-    	}
-    	vector<int> vecLeftPosition;
-    	fnGetRelativePosition(vecLeft, vecLeftPosition);
-    	vector<int> vecRightPosition;
-    	fnGetRelativePosition(vecRight, vecRightPosition);
-
-    	vecStrLeftReorder.clear();
-    	vecStrRightReorder.clear();
-    	for (int i = 1; i < vecLeftPosition.size(); i++) {
-    		string strOutcome;
-    		fnGetOutcome(vecLeftPosition[i - 1], vecLeftPosition[i], strOutcome);
-    		vecStrLeftReorder.push_back(strOutcome);
-    		fnGetOutcome(vecRightPosition[i - 1], vecRightPosition[i], strOutcome);
-    		vecStrRightReorder.push_back(strOutcome);
-    	}
-	}
-
-	/*
-	 * features:
-	 * f1: (left_label, right_label, parent_label)
-	 * f2: (left_label, right_label, parent_label, other_right_sibling_label)
-	 * f3: (left_label, right_label, parent_label, other_left_sibling_label)
-	 * f4: (left_label, right_label, left_head_pos)
-	 * f5: (left_label, right_label, left_head_word)
-	 * f6: (left_label, right_label, right_head_pos)
-	 * f7: (left_label, right_label, right_head_word)
-	 * f8: (left_label, right_label, left_chunk_status)
-	 * f9: (left_label, right_label, right_chunk_status)
-	 * f10: (left_label, parent_label)
-	 * f11: (right_label, parent_label)
-	 *
-	 * f1: (left_role, right_role, predicate_term)
-	 * f2: (left_role, right_role, predicate_term, other_right_role)
-	 * f3: (left_role, right_role, predicate_term, other_left_role)
-	 * f4: (left_role, right_role, left_head_pos)
-	 * f5: (left_role, right_role, left_head_word)
-	 * f6: (left_role, right_role, left_syntactic_label)
-	 * f7: (left_role, right_role, right_head_pos)
-	 * f8: (left_role, right_role, right_head_word)
-	 * f8: (left_role, right_role, right_syntactic_label)
-	 * f8: (left_role, right_role, left_chunk_status)
-	 * f9: (left_role, right_role, right_chunk_status)
-	 * f10: (left_role, right_role, left_chunk_status)
-	 * f11: (left_role, right_role, right_chunk_status)
-	 * f12: (left_label, parent_label)
-	 * f13: (right_label, parent_label)
-	 */
-	static void fnGenerateFeature(const SParsedTree *pTree, const SPredicate *pPred, const SPredicateItem *pPredItem, int iPos, const string& strBlock1, const string& strBlock2, ostringstream& ostr) {
-		SSRLItem *pSRLItem1 = pPredItem->vec_items_[iPos - 1];
-		SSRLItem *pSRLItem2 = pPredItem->vec_items_[iPos];
-		const STreeItem *pCon1 = pSRLItem1->tree_item_;
-		const STreeItem *pCon2 = pSRLItem2->tree_item_;
-
-		string left_role = pSRLItem1->role_;
-		string right_role = pSRLItem2->role_;
-
-		string predicate_term = pTree->m_vecTerminals[pPred->m_iPosition]->m_pszTerm;
-
-		vector<string> vec_other_right_sibling;
-		for (int i = iPos + 1; i < pPredItem->vec_items_.size(); i++)
-			vec_other_right_sibling.push_back(string(pPredItem->vec_items_[i]->role_));
-		if (vec_other_right_sibling.size() == 0)
-			vec_other_right_sibling.push_back(string("NULL"));
-
-		vector<string> vec_other_left_sibling;
-		for (int i = 0; i < iPos - 1; i++)
-			vec_other_right_sibling.push_back(string(pPredItem->vec_items_[i]->role_));
-		if (vec_other_left_sibling.size() == 0)
-			vec_other_left_sibling.push_back(string("NULL"));
-
-
-		//generate features
-		//f1
-		ostr << "f1=" << left_role << "_" << right_role << "_" << predicate_term;
-		ostr << "f1=" << left_role << "_" << right_role;
-
-		//f2
-		for (int i = 0; i < vec_other_right_sibling.size(); i++) {
-			ostr << " f2=" << left_role << "_" << right_role << "_" << predicate_term << "_" << vec_other_right_sibling[i];
-			ostr << " f2=" << left_role << "_" << right_role << "_" << vec_other_right_sibling[i];
-		}
-		//f3
-		for (int i = 0; i < vec_other_left_sibling.size(); i++) {
-			ostr << " f3=" << left_role << "_" << right_role << "_" << predicate_term << "_" << vec_other_left_sibling[i];
-			ostr << " f3=" << left_role << "_" << right_role << "_" << vec_other_left_sibling[i];
-		}
-		//f4
-		ostr << " f4=" << left_role << "_" << right_role << "_" << pTree->m_vecTerminals[pCon1->m_iHeadWord]->m_ptParent->m_pszTerm;
-		//f5
-		ostr << " f5=" << left_role << "_" << right_role << "_" << pTree->m_vecTerminals[pCon1->m_iHeadWord]->m_pszTerm;
-		//f6
-		ostr << " f6=" << left_role << "_" << right_role << "_" << pCon2->m_pszTerm;
-		//f7
-		ostr << " f7=" << left_role << "_" << right_role << "_" << pTree->m_vecTerminals[pCon2->m_iHeadWord]->m_ptParent->m_pszTerm;
-		//f8
-		ostr << " f8=" << left_role << "_" << right_role << "_" << pTree->m_vecTerminals[pCon2->m_iHeadWord]->m_pszTerm;
-		//f9
-		ostr << " f9=" << left_role << "_" << right_role << "_" << pCon2->m_pszTerm;
-		//f10
-		ostr << " f10=" << left_role << "_" << right_role << "_" << strBlock1;
-		//f11
-		ostr << " f11=" << left_role << "_" << right_role << "_" << strBlock2;
-		//f12
-		ostr << " f12=" << left_role << "_" << predicate_term;
-		ostr << " f12=" << left_role;
-		//f13
-		ostr << " f13=" << right_role << "_" << predicate_term;
-		ostr << " f13=" << right_role;
-	}
-
-private:
-	static void fnGetOutcome(int i1, int i2, string& strOutcome) {
-		assert(i1 != i2);
-		if (i1 < i2) {
-			if (i2 > i1 + 1) strOutcome = string("DM");
-			else strOutcome = string("M");
-		} else {
-			if (i1 > i2 + 1) strOutcome = string("DS");
-			else strOutcome = string("S");
-		}
-	}
-
-	static void fnGetRelativePosition(const vector<int>& vecLeft, vector<int>& vecPosition) {
-		vecPosition.clear();
-
-		vector<float> vec;
-		for (int i = 0; i < vecLeft.size(); i++) {
-			if (vecLeft[i] == -1) {
-				if (i == 0)
-					vec.push_back(-1);
-				else
-					vec.push_back(vecLeft[i-1] + 0.1);
-			} else
-				vec.push_back(vecLeft[i]);
-		}
-
-		for (int i = 0; i < vecLeft.size(); i++) {
-			int count = 0;
-
-			for (int j = 0; j < vecLeft.size(); j++) {
-				if ( j == i) continue;
-				if (vec[j] < vec[i]) {
-					count++;
-				} else if (vec[j] == vec[i] && j < i) {
-					count++;
-				}
-			}
-			vecPosition.push_back(count);
-		}
-	}
+ public:
+  static string fnGetBlockOutcome(int iBegin, int iEnd, SAlignment *pAlign) {
+    return pAlign->fnIsContinuous(iBegin, iEnd);
+  }
+  static void fnGetReorderType(SPredicateItem *pPredItem, SAlignment *pAlign,
+                               vector<string> &vecStrLeftReorder,
+                               vector<string> &vecStrRightReorder) {
+    vector<int> vecLeft, vecRight;
+    for (int i = 0; i < pPredItem->vec_items_.size(); i++) {
+      const STreeItem *pCon1 = pPredItem->vec_items_[i]->tree_item_;
+      int iLeft1, iRight1;
+      pAlign->fnGetLeftRightMost(pCon1->m_iBegin, pCon1->m_iEnd, true, iLeft1,
+                                 iRight1);
+      vecLeft.push_back(iLeft1);
+      vecRight.push_back(iRight1);
+    }
+    vector<int> vecLeftPosition;
+    fnGetRelativePosition(vecLeft, vecLeftPosition);
+    vector<int> vecRightPosition;
+    fnGetRelativePosition(vecRight, vecRightPosition);
+
+    vecStrLeftReorder.clear();
+    vecStrRightReorder.clear();
+    for (int i = 1; i < vecLeftPosition.size(); i++) {
+      string strOutcome;
+      fnGetOutcome(vecLeftPosition[i - 1], vecLeftPosition[i], strOutcome);
+      vecStrLeftReorder.push_back(strOutcome);
+      fnGetOutcome(vecRightPosition[i - 1], vecRightPosition[i], strOutcome);
+      vecStrRightReorder.push_back(strOutcome);
+    }
+  }
+
+  /*
+   * features:
+   * f1: (left_label, right_label, parent_label)
+   * f2: (left_label, right_label, parent_label, other_right_sibling_label)
+   * f3: (left_label, right_label, parent_label, other_left_sibling_label)
+   * f4: (left_label, right_label, left_head_pos)
+   * f5: (left_label, right_label, left_head_word)
+   * f6: (left_label, right_label, right_head_pos)
+   * f7: (left_label, right_label, right_head_word)
+   * f8: (left_label, right_label, left_chunk_status)
+   * f9: (left_label, right_label, right_chunk_status)
+   * f10: (left_label, parent_label)
+   * f11: (right_label, parent_label)
+   *
+   * f1: (left_role, right_role, predicate_term)
+   * f2: (left_role, right_role, predicate_term, other_right_role)
+   * f3: (left_role, right_role, predicate_term, other_left_role)
+   * f4: (left_role, right_role, left_head_pos)
+   * f5: (left_role, right_role, left_head_word)
+   * f6: (left_role, right_role, left_syntactic_label)
+   * f7: (left_role, right_role, right_head_pos)
+   * f8: (left_role, right_role, right_head_word)
+   * f8: (left_role, right_role, right_syntactic_label)
+   * f8: (left_role, right_role, left_chunk_status)
+   * f9: (left_role, right_role, right_chunk_status)
+   * f10: (left_role, right_role, left_chunk_status)
+   * f11: (left_role, right_role, right_chunk_status)
+   * f12: (left_label, parent_label)
+   * f13: (right_label, parent_label)
+   */
+  static void fnGenerateFeature(const SParsedTree *pTree,
+                                const SPredicate *pPred,
+                                const SPredicateItem *pPredItem, int iPos,
+                                const string &strBlock1,
+                                const string &strBlock2, ostringstream &ostr) {
+    SSRLItem *pSRLItem1 = pPredItem->vec_items_[iPos - 1];
+    SSRLItem *pSRLItem2 = pPredItem->vec_items_[iPos];
+    const STreeItem *pCon1 = pSRLItem1->tree_item_;
+    const STreeItem *pCon2 = pSRLItem2->tree_item_;
+
+    string left_role = pSRLItem1->role_;
+    string right_role = pSRLItem2->role_;
+
+    string predicate_term =
+        pTree->m_vecTerminals[pPred->m_iPosition]->m_pszTerm;
+
+    vector<string> vec_other_right_sibling;
+    for (int i = iPos + 1; i < pPredItem->vec_items_.size(); i++)
+      vec_other_right_sibling.push_back(
+          string(pPredItem->vec_items_[i]->role_));
+    if (vec_other_right_sibling.size() == 0)
+      vec_other_right_sibling.push_back(string("NULL"));
+
+    vector<string> vec_other_left_sibling;
+    for (int i = 0; i < iPos - 1; i++)
+      vec_other_right_sibling.push_back(
+          string(pPredItem->vec_items_[i]->role_));
+    if (vec_other_left_sibling.size() == 0)
+      vec_other_left_sibling.push_back(string("NULL"));
+
+    // generate features
+    // f1
+    ostr << "f1=" << left_role << "_" << right_role << "_" << predicate_term;
+    ostr << "f1=" << left_role << "_" << right_role;
+
+    // f2
+    for (int i = 0; i < vec_other_right_sibling.size(); i++) {
+      ostr << " f2=" << left_role << "_" << right_role << "_" << predicate_term
+           << "_" << vec_other_right_sibling[i];
+      ostr << " f2=" << left_role << "_" << right_role << "_"
+           << vec_other_right_sibling[i];
+    }
+    // f3
+    for (int i = 0; i < vec_other_left_sibling.size(); i++) {
+      ostr << " f3=" << left_role << "_" << right_role << "_" << predicate_term
+           << "_" << vec_other_left_sibling[i];
+      ostr << " f3=" << left_role << "_" << right_role << "_"
+           << vec_other_left_sibling[i];
+    }
+    // f4
+    ostr << " f4=" << left_role << "_" << right_role << "_"
+         << pTree->m_vecTerminals[pCon1->m_iHeadWord]->m_ptParent->m_pszTerm;
+    // f5
+    ostr << " f5=" << left_role << "_" << right_role << "_"
+         << pTree->m_vecTerminals[pCon1->m_iHeadWord]->m_pszTerm;
+    // f6
+    ostr << " f6=" << left_role << "_" << right_role << "_" << pCon2->m_pszTerm;
+    // f7
+    ostr << " f7=" << left_role << "_" << right_role << "_"
+         << pTree->m_vecTerminals[pCon2->m_iHeadWord]->m_ptParent->m_pszTerm;
+    // f8
+    ostr << " f8=" << left_role << "_" << right_role << "_"
+         << pTree->m_vecTerminals[pCon2->m_iHeadWord]->m_pszTerm;
+    // f9
+    ostr << " f9=" << left_role << "_" << right_role << "_" << pCon2->m_pszTerm;
+    // f10
+    ostr << " f10=" << left_role << "_" << right_role << "_" << strBlock1;
+    // f11
+    ostr << " f11=" << left_role << "_" << right_role << "_" << strBlock2;
+    // f12
+    ostr << " f12=" << left_role << "_" << predicate_term;
+    ostr << " f12=" << left_role;
+    // f13
+    ostr << " f13=" << right_role << "_" << predicate_term;
+    ostr << " f13=" << right_role;
+  }
+
+ private:
+  static void fnGetOutcome(int i1, int i2, string &strOutcome) {
+    assert(i1 != i2);
+    if (i1 < i2) {
+      if (i2 > i1 + 1)
+        strOutcome = string("DM");
+      else
+        strOutcome = string("M");
+    } else {
+      if (i1 > i2 + 1)
+        strOutcome = string("DS");
+      else
+        strOutcome = string("S");
+    }
+  }
+
+  static void fnGetRelativePosition(const vector<int> &vecLeft,
+                                    vector<int> &vecPosition) {
+    vecPosition.clear();
+
+    vector<float> vec;
+    for (int i = 0; i < vecLeft.size(); i++) {
+      if (vecLeft[i] == -1) {
+        if (i == 0)
+          vec.push_back(-1);
+        else
+          vec.push_back(vecLeft[i - 1] + 0.1);
+      } else
+        vec.push_back(vecLeft[i]);
+    }
+
+    for (int i = 0; i < vecLeft.size(); i++) {
+      int count = 0;
+
+      for (int j = 0; j < vecLeft.size(); j++) {
+        if (j == i) continue;
+        if (vec[j] < vec[i]) {
+          count++;
+        } else if (vec[j] == vec[i] && j < i) {
+          count++;
+        }
+      }
+      vecPosition.push_back(count);
+    }
+  }
 };
 
-
 #endif /* ARGUMENT_REORDER_MODEL_H_ */