ngs_server 0.1

data/ext/bamtools/src/utils/bamtools_filter_properties.h

@@ -0,0 +1,195 @@
+// ***************************************************************************
+// bamtools_filter_properties.h (c) 2010 Derek Barnett, Erik Garrison
+// Marth Lab, Department of Biology, Boston College
+// ---------------------------------------------------------------------------
+// Last modified: 19 November 2010
+// ---------------------------------------------------------------------------
+// Provides support data structures & methods for FilterEngine
+//
+// The FilterEngine consists, most importantly, of :
+//
+//     a list of possible properties (each tagged whether it has been 'enabled' as a filter)
+//     a map of filterName => propertySet
+//     queue for compound rule expression (i.e. "(filter1 AND filter2) OR !filter3" )
+//     
+// Each propertySet is a list of properties enabled for this particular filter object
+//
+//     Implemented as a map of propertyNames to propertyFilterValue
+//     ( "property1" => pfv1 
+//       "property2" => pfv2 
+//       "property4" => pfv4
+//       etc. )  
+//
+//     Any properties that are 'possible', via FilterEngine::addProperty(), but not enabled 
+//     via FilterEngine::setProperty() (in our example, say "property3"), evaluate to true 
+//     for any query.  Meaning that if a property is not set on this filter, we don't care 
+//     about it here, so it passes though OK.
+//
+// A propertyFilterValue contains a value and comparison type
+//
+//    ( pfv1: Value = 50,    Type = GREATER_THAN_EQUAL
+//      pfv2: Value = "foo", Type = STARTS_WITH
+//      pfv4: Value = "bar", Type = CONTAINS
+//      etc. )  
+//
+//    This allows for more complex queries (than simple isEqual?) against a variety of data types.
+//
+// ***************************************************************************
+
+#ifndef BAMTOOLS_FILTER_PROPERTIES_H
+#define BAMTOOLS_FILTER_PROPERTIES_H
+
+#include <utils/bamtools_utilities.h>
+#include <utils/bamtools_variant.h>
+#include <utils/utils_global.h>
+#include <iostream>
+#include <map>
+#include <string>
+
+namespace BamTools {
+
+// ----------------------------------------------------------
+// PropertyFilterValue
+  
+struct UTILS_EXPORT PropertyFilterValue {
+  
+    // define valid ValueCompareTypes
+    enum ValueCompareType { CONTAINS = 0
+                          , ENDS_WITH
+                          , EXACT
+                          , GREATER_THAN
+                          , GREATER_THAN_EQUAL
+                          , LESS_THAN
+                          , LESS_THAN_EQUAL
+                          , NOT
+                          , STARTS_WITH
+                          };
+                   
+    // ctor
+    PropertyFilterValue(const Variant& value = Variant(),
+                        const ValueCompareType& type = PropertyFilterValue::EXACT)
+        : Value(value)
+        , Type(type)
+    { }
+          
+    // filter check methods      
+    template<typename T>
+    bool check(const T& query) const;
+    bool check(const std::string& query) const;
+             
+    // data members
+    Variant Value;
+    ValueCompareType Type;
+};
+
+// checks a query against a filter (value, compare type)
+template<typename T>
+bool PropertyFilterValue::check(const T& query) const {
+  
+    // ensure filter value & query are same type
+    if ( !Value.is_type<T>() ) { 
+        std::cerr << "Cannot compare different types!" << std::endl;
+        return false;
+    }
+    
+    // string matching
+    if ( Value.is_type<std::string>() ) {
+        std::cerr << "Cannot compare different types - query is a string!" << std::endl;
+        return false;
+    } 
+    
+    // numeric matching based on our filter type
+    switch ( Type ) {
+        case ( PropertyFilterValue::EXACT)              : return ( query == Value.get<T>() );
+        case ( PropertyFilterValue::GREATER_THAN)       : return ( query >  Value.get<T>() ); 
+        case ( PropertyFilterValue::GREATER_THAN_EQUAL) : return ( query >= Value.get<T>() ); 
+        case ( PropertyFilterValue::LESS_THAN)          : return ( query <  Value.get<T>() );
+        case ( PropertyFilterValue::LESS_THAN_EQUAL)    : return ( query <= Value.get<T>() );
+        case ( PropertyFilterValue::NOT)                : return ( query != Value.get<T>() );
+        default : BAMTOOLS_ASSERT_UNREACHABLE;
+    }
+    return false;
+}
+
+// checks a string query against filter (value, compare type)
+inline
+bool PropertyFilterValue::check(const std::string& query) const {
+  
+    // ensure filter value & query are same type
+    if ( !Value.is_type<std::string>() ) {
+        std::cerr << "Cannot compare different types!" << std::endl;
+        return false;
+    }
+  
+    // localize string version of our filter value
+    const std::string& valueString = Value.get<std::string>();
+    
+    // string matching based on our filter type
+    switch ( Type ) {
+        case ( PropertyFilterValue::CONTAINS)           : return ( query.find(valueString) != std::string::npos );
+        case ( PropertyFilterValue::ENDS_WITH)          : return ( query.find(valueString) == (query.length() - valueString.length()) ); 
+        case ( PropertyFilterValue::EXACT)              : return ( query == valueString );
+        case ( PropertyFilterValue::GREATER_THAN)       : return ( query >  valueString ); 
+        case ( PropertyFilterValue::GREATER_THAN_EQUAL) : return ( query >= valueString ); 
+        case ( PropertyFilterValue::LESS_THAN)          : return ( query <  valueString );
+        case ( PropertyFilterValue::LESS_THAN_EQUAL)    : return ( query <= valueString );
+        case ( PropertyFilterValue::NOT)                : return ( query != valueString );
+        case ( PropertyFilterValue::STARTS_WITH)        : return ( query.find(valueString) == 0 );
+        default : BAMTOOLS_ASSERT_UNREACHABLE;
+    }
+    return false;
+}
+
+inline
+const std::string toString(const PropertyFilterValue::ValueCompareType& type) {
+  
+    switch ( type ) {
+        case ( PropertyFilterValue::CONTAINS )           : return std::string( "CONTAINS");
+        case ( PropertyFilterValue::ENDS_WITH )          : return std::string( "ENDS_WITH");
+        case ( PropertyFilterValue::EXACT )              : return std::string( "EXACT");
+        case ( PropertyFilterValue::GREATER_THAN )       : return std::string( "GREATER_THAN");
+        case ( PropertyFilterValue::GREATER_THAN_EQUAL ) : return std::string( "GREATER_THAN_EQUAL");
+        case ( PropertyFilterValue::LESS_THAN )          : return std::string( "LESS_THAN");
+        case ( PropertyFilterValue::LESS_THAN_EQUAL )    : return std::string( "LESS_THAN_EQUAL");
+        case ( PropertyFilterValue::NOT )                : return std::string( "NOT");
+        case ( PropertyFilterValue::STARTS_WITH )        : return std::string( "STARTS_WITH");
+        default : BAMTOOLS_ASSERT_UNREACHABLE;
+    }
+    return std::string();
+}
+
+// property name => property filter value 
+// ('name' => ('SSR', STARTS_WITH), 'mapQuality' => (50, GREATER_THAN_EQUAL), etc...)
+typedef std::map<std::string, PropertyFilterValue> PropertyMap;
+
+// ----------------------------------------------------------
+// PropertyFilter
+
+struct UTILS_EXPORT PropertyFilter {
+    // data members
+    PropertyMap Properties;
+};
+
+// filter name => properties  
+// ('filter1' => properties1, 'filter2' => properties2, etc...)
+typedef std::map<std::string, PropertyFilter> FilterMap;
+  
+// ----------------------------------------------------------
+// Property
+  
+// used to store properties known to engine & keep track of enabled state
+struct UTILS_EXPORT Property {
+    std::string Name;
+    bool IsEnabled;
+    Property(const std::string& name, bool isEnabled = false) 
+        : Name(name)
+        , IsEnabled(isEnabled) 
+    { }
+};
+
+inline bool operator<  (const Property& lhs, const Property& rhs) { return lhs.Name <  rhs.Name; }
+inline bool operator== (const Property& lhs, const Property& rhs) { return lhs.Name == rhs.Name; }
+
+} // namespace BamTools
+
+#endif // BAMTOOLS_FILTER_PROPERTIES_H

data/ext/bamtools/src/utils/bamtools_filter_ruleparser.h

@@ -0,0 +1,319 @@
+// ***************************************************************************
+// bamtools_filter_ruleparser.h (c) 2010 Derek Barnett, Erik Garrison
+// Marth Lab, Department of Biology, Boston College
+// ---------------------------------------------------------------------------
+// Last modified: 19 November 2010
+// ---------------------------------------------------------------------------
+// Provides a compound rule parser for FilterEngine.
+// ***************************************************************************
+
+#ifndef BAMTOOLS_FILTER_RULEPARSER_H
+#define BAMTOOLS_FILTER_RULEPARSER_H
+
+#include <utils/bamtools_utilities.h>
+#include <queue>
+#include <stack>
+#include <string>
+
+namespace BamTools {
+
+// -------------------------------------------
+// char constants  
+  
+const char LEFT_PARENTHESIS_CHAR  = '(';
+const char RIGHT_PARENTHESIS_CHAR = ')';
+const char AND_OPERATOR_CHAR      = '&';
+const char OR_OPERATOR_CHAR       = '|';
+const char NOT_OPERATOR_CHAR      = '!';
+const char SPACE_CHAR             = ' ';
+  
+// -------------------------------------------
+// RuleToken implementation
+  
+struct RuleToken {
+  
+    // enums
+    enum RuleTokenType { OPERAND = 0
+                       , AND_OPERATOR
+                       , OR_OPERATOR
+                       , NOT_OPERATOR
+                       , LEFT_PARENTHESIS
+                       , RIGHT_PARENTHESIS
+                       };
+    
+    // data members
+    RuleTokenType Type;
+    std::string Value;
+};
+
+inline int priority(const RuleToken& token) {
+    switch ( token.Type ) {
+        case ( RuleToken::NOT_OPERATOR )      : return 3;
+        case ( RuleToken::AND_OPERATOR )      : return 2;
+        case ( RuleToken::OR_OPERATOR  )      : return 1;
+        case ( RuleToken::LEFT_PARENTHESIS )  : return 0;
+        case ( RuleToken::RIGHT_PARENTHESIS ) : return 0;
+        default:
+            BAMTOOLS_ASSERT_UNREACHABLE;
+            return -1;
+    } 
+}
+
+inline bool isRightAssociative(const RuleToken& token) {
+    return (token.Type == RuleToken::NOT_OPERATOR || 
+            token.Type == RuleToken::LEFT_PARENTHESIS);
+}
+
+inline bool isLeftAssociative(const RuleToken& token) {
+    return !isRightAssociative(token);
+}
+
+inline bool isLeftParenthesis(const RuleToken& token) {
+    return ( token.Type == RuleToken::LEFT_PARENTHESIS );
+}
+
+inline bool isRightParenthesis(const RuleToken& token) {
+    return ( token.Type == RuleToken::RIGHT_PARENTHESIS );
+}
+
+inline bool isOperand(const RuleToken& token) {
+    return ( token.Type == RuleToken::OPERAND );
+}
+
+inline bool isOperator(const RuleToken& token) {
+    return ( token.Type == RuleToken::AND_OPERATOR ||
+             token.Type == RuleToken::OR_OPERATOR  ||
+             token.Type == RuleToken::NOT_OPERATOR);
+}
+  
+// -------------------------------------------
+// RuleParser implementation  
+  
+class RuleParser {
+
+    // ctor & dtor
+    public:
+        RuleParser(const std::string& ruleString)
+            : m_ruleString(ruleString)
+        { 
+            // initialize char markers
+            m_begin = (char*)m_ruleString.c_str();
+            m_end   = m_begin + m_ruleString.length();
+            ignoreQuotes();
+        }
+        
+        ~RuleParser(void) { }
+  
+    // public interface
+    public:
+        void parse(void);
+        std::queue<std::string> results(void) const { return m_ruleQueue; }
+
+    // internal methods
+    private:
+        char getNextChar(void);
+        void ignoreQuotes(void);
+        bool readToken(RuleToken& token);
+        void skipSpaces(void);
+      
+    // data members
+    private:
+        std::string m_ruleString;
+        char* m_begin;
+        char* m_current;
+        char* m_end;
+        
+        std::queue<std::string> m_ruleQueue;
+        std::stack<RuleToken> m_operatorStack;
+};
+
+inline
+char RuleParser::getNextChar(void) {
+   if ( m_current == m_end ) return 0;
+   return *m_current++;
+}
+
+inline
+void RuleParser::ignoreQuotes(void) {
+    if ( *m_begin == '\"' ) ++m_begin;
+    if ( *m_end   == '\"' ) --m_end;
+}
+
+inline
+void RuleParser::parse(void) {
+  
+    // clear out any prior data
+    while ( !m_ruleQueue.empty() ) 
+        m_ruleQueue.pop();
+    
+    // skip if no rule to parse
+    if ( m_ruleString.empty() ) return;
+  
+    // start at beginning of ruleString
+    m_current = m_begin;
+    
+    // iterate through tokens in rule string
+    RuleToken token;
+    while ( readToken(token) ) {
+      
+        if ( token.Value.empty() ) break;
+      
+        // if token is an operand
+        if ( isOperand(token) )
+            m_ruleQueue.push(token.Value);
+
+        // if token is an operator 
+        else if ( isOperator(token) ) {
+
+            // pop any operators at top of stack with higher priority
+            while ( !m_operatorStack.empty() ) {
+                const RuleToken& opToken = m_operatorStack.top();
+                if ( (isLeftAssociative(token) && (priority(token) <= priority(opToken))) ||
+                     (isRightAssociative(token) && (priority(token) < priority(opToken))) 
+                    )
+                {
+                    m_ruleQueue.push(opToken.Value);
+                    m_operatorStack.pop();
+                }
+                else break;
+            }
+            
+            // push current operator token onto stack
+            m_operatorStack.push(token);
+        }
+        
+        // if token is left parenthesis
+        else if ( isLeftParenthesis(token) )
+            m_operatorStack.push(token);
+        
+        // if token is right parenthesis
+        else if ( isRightParenthesis(token) ) {
+          
+            bool foundLeftParenthesis = false;
+          
+            // push operators into rule queue until left parenthesis found
+            while ( !m_operatorStack.empty() && !foundLeftParenthesis ) {
+                const RuleToken& opToken = m_operatorStack.top();
+                if ( !isLeftParenthesis(opToken) )
+                    m_ruleQueue.push(opToken.Value);
+                else 
+                    foundLeftParenthesis = true;
+                m_operatorStack.pop();
+            }
+          
+            // no left parenthesis found, error
+            BAMTOOLS_ASSERT_MESSAGE( foundLeftParenthesis, "ERROR: Mismatched parenthesis in rule string.1");
+        }
+        
+        // error: unknown operand
+        else BAMTOOLS_ASSERT_UNREACHABLE;
+    }    
+    
+    // while there are still operators on stack
+    while ( !m_operatorStack.empty() ) {
+        const RuleToken& token = m_operatorStack.top();
+        BAMTOOLS_ASSERT_MESSAGE( (!isLeftParenthesis(token) && !isRightParenthesis(token)), "ERROR: Mismatched parenthesis in rule string.2");
+        m_ruleQueue.push(token.Value);
+        m_operatorStack.pop();
+    }
+}
+
+inline
+bool RuleParser::readToken(RuleToken& token) {
+  
+    // skip any preceding whitespace
+    skipSpaces();
+    if ( m_current == m_end ) return false;
+
+    // clear out prior token value
+    token.Value.clear();
+    
+    // read chars while still in token
+    char c = 1;
+    bool keepReading = true;
+    bool inOperandString = false;
+    while ( keepReading && (c != 0) ) {
+      
+      // get next char
+      c = getNextChar();
+      switch (c) {
+        
+          // current char is '('
+          case ( LEFT_PARENTHESIS_CHAR ) :
+              token.Type = RuleToken::LEFT_PARENTHESIS;
+              token.Value.append(1, LEFT_PARENTHESIS_CHAR);
+              keepReading = false;
+              break;
+              
+          // current char is ')'
+          case ( RIGHT_PARENTHESIS_CHAR ) :
+              if ( inOperandString )
+                  --m_current;
+              else {
+                  token.Type = RuleToken::RIGHT_PARENTHESIS;
+                  token.Value.append(1, RIGHT_PARENTHESIS_CHAR);
+              }
+              keepReading = false;
+              break;
+        
+          // current char is '&'
+          case ( AND_OPERATOR_CHAR ) :
+              if ( inOperandString ) 
+                  --m_current;
+              else {
+                  token.Type = RuleToken::AND_OPERATOR;
+                  token.Value.append(1, AND_OPERATOR_CHAR);
+              }
+              keepReading = false;
+              break;
+              
+          // current char is '|' 
+          case ( OR_OPERATOR_CHAR ) :
+              if ( inOperandString )
+                  --m_current;
+              else {  
+                  token.Type = RuleToken::OR_OPERATOR;
+                  token.Value.append(1, OR_OPERATOR_CHAR);
+              }
+              keepReading = false;
+              break;
+              
+          // current char is '!'
+          case ( NOT_OPERATOR_CHAR ) :
+              token.Type = RuleToken::NOT_OPERATOR;
+              token.Value.append(1, NOT_OPERATOR_CHAR);
+              keepReading = false;
+              break;
+              
+          // current char is ' '
+          case ( SPACE_CHAR ) : 
+              keepReading = false;
+              break;
+            
+          // current char is a true value token
+          default:
+              if ( c != 0 ) {
+                  token.Type = RuleToken::OPERAND;
+                  token.Value.append(1, c);
+                  inOperandString = true;
+                  keepReading = true;
+              }
+        }         
+    }
+      
+    return true;
+}
+
+inline
+void RuleParser::skipSpaces(void) {
+    while ( m_current != m_end ) {
+        const char c = *m_current;
+        if ( c == ' ' || c == '\t' || c == '\r' || c == '\n')
+            ++m_current;
+        else break;
+    }
+}
+
+} // namespace BamTools
+
+#endif // BAMTOOLS_FILTER_RULEPARSER_H