Changes in src/Parser/TremoloParser.cpp [23fd43:ca331c]

File:

• src/Parser/TremoloParser.cpp (modified) (12 diffs)

src/Parser/TremoloParser.cpp

@@ -41 +41 @@
 
 #include <algorithm>
+#include <boost/lambda/lambda.hpp>
 #include <boost/lexical_cast.hpp>
 #include <boost/tokenizer.hpp>
@@ -47 +48 @@
 #include <map>
 #include <sstream>
+#include <string>
 #include <vector>
+
+#include <boost/assign/list_of.hpp> // for 'map_list_of()'
+#include <boost/assert.hpp>
 
 // declare specialized static variables
@@ -54 +59 @@
 const ParserTypes FormatParserTrait<tremolo>::type = tremolo;
 
+// static instances
+std::map<std::string, TremoloKey::atomDataKey> FormatParser<tremolo>::knownKeys =
+    boost::assign::map_list_of("x",TremoloKey::x)
+    ("u",TremoloKey::u)
+    ("F",TremoloKey::F)
+    ("stress",TremoloKey::stress)
+    ("Id",TremoloKey::Id)
+    ("neighbors",TremoloKey::neighbors)
+    ("imprData",TremoloKey::imprData)
+    ("GroupMeasureTypeNo",TremoloKey::GroupMeasureTypeNo)
+    ("type",TremoloKey::type)
+    ("extType",TremoloKey::extType)
+    ("name",TremoloKey::name)
+    ("resName",TremoloKey::resName)
+    ("chainID",TremoloKey::chainID)
+    ("resSeq",TremoloKey::resSeq)
+    ("occupancy",TremoloKey::occupancy)
+    ("tempFactor",TremoloKey::tempFactor)
+    ("segID",TremoloKey::segID)
+    ("Charge",TremoloKey::Charge)
+    ("charge",TremoloKey::charge)
+    ("GrpTypeNo",TremoloKey::GrpTypeNo)
+    ("torsion",TremoloKey::torsion)
+    (" ",TremoloKey::noKey); // with this we can detect invalid keys
+
 /**
  * Constructor.
@@ -60 +90 @@
   FormatParser_common(NULL)
 {
-  knownKeys["x"] = TremoloKey::x;
-  knownKeys["u"] = TremoloKey::u;
-  knownKeys["F"] = TremoloKey::F;
-  knownKeys["stress"] = TremoloKey::stress;
-  knownKeys["Id"] = TremoloKey::Id;
-  knownKeys["neighbors"] = TremoloKey::neighbors;
-  knownKeys["imprData"] = TremoloKey::imprData;
-  knownKeys["GroupMeasureTypeNo"] = TremoloKey::GroupMeasureTypeNo;
-  knownKeys["type"] = TremoloKey::type;
-  knownKeys["extType"] = TremoloKey::extType;
-  knownKeys["name"] = TremoloKey::name;
-  knownKeys["resName"] = TremoloKey::resName;
-  knownKeys["chainID"] = TremoloKey::chainID;
-  knownKeys["resSeq"] = TremoloKey::resSeq;
-  knownKeys["occupancy"] = TremoloKey::occupancy;
-  knownKeys["tempFactor"] = TremoloKey::tempFactor;
-  knownKeys["segID"] = TremoloKey::segID;
-  knownKeys["Charge"] = TremoloKey::Charge;
-  knownKeys["charge"] = TremoloKey::charge;
-  knownKeys["GrpTypeNo"] = TremoloKey::GrpTypeNo;
-  knownKeys["torsion"] = TremoloKey::torsion;
-  knownKeys[" "] = TremoloKey::noKey; // with this we can detect invalid keys
-
   createKnownTypesByIdentity();
 
@@ -92 +99 @@
 }
 
+
 /**
  * Destructor.
@@ -99 +107 @@
   usedFields_save.clear();
   additionalAtomData.clear();
-  knownKeys.clear();
 }
 
@@ -182 +189 @@
 }
 
+struct usedFieldsWeakComparator
+{
+  /** Special comparator regards "neighbors=4" and "neighbors=2" as equal
+   *
+   * \note This one is used for making usedFields unique, i.e. throwing out the "smaller"
+   * neighbors.
+   */
+  bool operator()(const std::string &a, const std::string &b) const
+  {
+    // only compare up to first equality sign
+    return (a.substr(0, a.find_first_of('=')) == b.substr(0, b.find_first_of('=')));
+  }
+};
+
+struct usedFieldsSpecialOrderer
+{
+  /** Special string comparator that regards "neighbors=4" < "neighbors=2" as true and
+   * the other way round as false.
+   *
+   * Here, we implement the operator "\a < \b" in a special way to allow the
+   * above.
+   *
+   * \note This one is used for sorting usedFields in preparation for making it unique.
+   */
+  bool operator()(const std::string &a, const std::string &b) const
+  {
+    // only compare up to first equality sign
+    size_t a_equality = a.find_first_of('=');
+    size_t b_equality = b.find_first_of('=');
+    // if key before equality is not equal, return whether it is smaller or not
+    if (a.substr(0, a_equality) != b.substr(0, b_equality)) {
+      return a.substr(0, a_equality) < b.substr(0, b_equality);
+    } else { // now we know that the key before equality is the same in either string
+      // if one of them has no equality, the one with equality must go before
+      if ((a_equality != std::string::npos) && (b_equality == std::string::npos))
+        return true;
+      if ((a_equality == std::string::npos) && (b_equality != std::string::npos))
+        return false;
+      // if both don't have equality (and the token before is equal), it is not "<" but "=="
+      if ((a_equality == std::string::npos) && (b_equality == std::string::npos))
+        return false;
+      // if now both have equality sign, the larger value after it, must come first
+      return a.substr(a_equality, std::string::npos) > b.substr(b_equality, std::string::npos);
+    }
+  }
+};
+
 /** Helper function to make \given fields unique while preserving the order of first appearance.
  *
@@ -191 +245 @@
  * @param fields usedFields to make unique while preserving order of appearance
  */
-void FormatParser< tremolo >::makeUsedFieldsUnique(usedFields_t &fields)
+void FormatParser< tremolo >::makeUsedFieldsUnique(usedFields_t &fields) const
 {
   // std::unique only removes if predecessor is equal, not over whole range, hence do it manually
-  usedFields_t temp_fields(usedFields_save);
-  std::sort(temp_fields.begin(), temp_fields.end());
+  usedFields_t temp_fields(fields);
+  usedFieldsSpecialOrderer SpecialOrderer;
+  usedFieldsWeakComparator WeakComparator;
+  std::sort(temp_fields.begin(), temp_fields.end(), SpecialOrderer);
   usedFields_t::iterator it =
-      std::unique(temp_fields.begin(), temp_fields.end()); // skips all duplicates in the vector
+      std::unique(temp_fields.begin(), temp_fields.end(), WeakComparator);
   temp_fields.erase(it, temp_fields.end());
-  usedFields_t usedfields(usedFields_save);
-  usedFields_save.clear();
-  usedFields_save.reserve(temp_fields.size());
+  usedFields_t usedfields(fields);
+  fields.clear();
+  fields.reserve(temp_fields.size());
   // now go through each usedFields entry, check if in temp_fields and remove there on first occurence
   for (usedFields_t::const_iterator iter = usedfields.begin();
@@ -208 +264 @@
         std::find(temp_fields.begin(), temp_fields.end(), *iter);
     if (uniqueiter != temp_fields.end()) {
-      usedFields_save.push_back(*iter);
+      fields.push_back(*iter);
       // add only once to ATOMDATA
       temp_fields.erase(uniqueiter);
@@ -441 +497 @@
     if (knownKeys[keyword.substr(0, keyword.find("="))] == TremoloKey::noKey) {
       // TODO: throw exception about unknown key
-      cout << "Unknown key: " << keyword << " is not part of the tremolo format specification." << endl;
+      cout << "Unknown key: " << keyword.substr(0, keyword.find("=")) << " is not part of the tremolo format specification." << endl;
+      throw IllegalParserKeyException();
       break;
     }
@@ -449 +506 @@
 }
 
+/**
+ * Tests whether the keys from the ATOMDATA line can be read correctly.
+ *
+ * \param line to parse the keys from
+ */
+bool FormatParser< tremolo >::testParseAtomDataKeysLine(
+    const std::string &line) {
+  std::string keyword;
+  std::stringstream lineStream;
+
+  // check string after ATOMDATA
+  const std::string AtomData("ATOMDATA");
+  const size_t AtomDataOffset = line.find(AtomData, 0);
+  if (AtomDataOffset == std::string::npos)
+    lineStream << line;
+  else
+    lineStream << line.substr(AtomDataOffset + AtomData.length());
+  while (lineStream.good()) {
+    lineStream >> keyword;
+    //LOG(2, "DEBUG: Checking key " << keyword.substr(0, keyword.find("=")) << ".");
+    if (knownKeys[keyword.substr(0, keyword.find("="))] == TremoloKey::noKey)
+      return false;
+  }
+  //LOG(1, "INFO: " << fields);
+  return true;
+}
+
+std::string FormatParser< tremolo >::getAtomData() const
+{
+  std::stringstream output;
+  std::for_each(usedFields_save.begin(), usedFields_save.end(),
+      output << boost::lambda::_1 << " ");
+  const std::string returnstring(output.str());
+  return returnstring.substr(0, returnstring.find_last_of(" "));
+}
+
+/** Appends the properties per atom to print to .data file by parsing line from
+ *  \a atomdata_string.
+ *
+ *  We just call \sa  FormatParser< tremolo >::parseAtomDataKeysLine().
+ *
+ * @param atomdata_string line to parse with space-separated values
+ */
+void FormatParser< tremolo >::setAtomData(const std::string &atomdata_string)
+{
+  parseAtomDataKeysLine(atomdata_string, 0, usedFields_save);
+}
+
 /** Sets the properties per atom to print to .data file by parsing line from
  *  \a atomdata_string.
@@ -457 +562 @@
  * @param atomdata_string line to parse with space-separated values
  */
-void FormatParser< tremolo >::setAtomData(const std::string &atomdata_string)
+void FormatParser< tremolo >::resetAtomData(const std::string &atomdata_string)
 {
   usedFields_save.clear();