query_impl.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// This file is part of the OpenStructure project <www.openstructure.org>
//
// Copyright (C) 2008-2020 by the OpenStructure authors
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License as published by the Free
// Software Foundation; either version 3.0 of the License, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
// details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this library; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//------------------------------------------------------------------------------
#ifndef OST_QUERY_IMPL_HH
#define OST_QUERY_IMPL_HH

#include <vector>
#include <string>
#include <set>

#include <boost/logic/tribool.hpp>

#include <ost/mol/module_config.hh>
#include "query_impl_fw.hh"
#include "query_ast.hh"
#include <ost/range.hh>
#include <ost/mol/query_error.hh>
#include "atom_impl_fw.hh"
#include "residue_impl_fw.hh"
#include "chain_impl_fw.hh"
#include <ost/mol/mol.hh>
#include <ost/mol/query_state.hh>
#include <ost/mol/entity_property_mapper.hh>

namespace ost { namespace mol { namespace impl {

namespace tok {
  typedef enum {
    IntegralValue,
    FloatingValue,
    Colon,
    Coma,
    Dot, 
    And,
    Or, 
    Not,
    Equal,
    NotEqual,
    GreaterEqualThan,
    GreaterThan,
    LessThan,
    LessEqualThan,
    Identifier,
    Within,
    LeftCurlyBrace,
    RightCurlyBrace,
    LeftParen,
    RightParen,
    LeftBracket,
    RightBracket,
    None,
    UnknownChar,
    UnterminatedQuote,
    String
  }
  Type;
}

class QueryToken {
public:
  QueryToken();
  QueryToken(const Range& range, tok::Type type, 
             const Range& value_range=Range());
  
  tok::Type GetType() const;
  bool IsEOF() const;
  const Range& GetRange() const;
  const Range& GetValueRange() const;
private:
  tok::Type      type_;
  Range          range_;
  Range          value_range_;
};

class QueryLexer {
public:
  QueryLexer(const String& query_string);
  QueryToken NextToken();
  QueryToken CurrentToken() const;
private:  
  //  lexer position.
  void EatWhitespaces();
  QueryToken LexToken();
  QueryToken LexQuotedStringLiteral();
  QueryToken LexNumericToken();
  QueryToken LexIdentOrStringToken();
  
  String   query_string_;
  size_t   current_;  
  QueryToken tok_;
};

struct SelStmt {
  Prop::ID                   sel_id;
  CompOP                       comp_op;
  ParamType                    param;    
  SelStmt()
    : sel_id(Prop::UNDEF),
      comp_op(COP_EQ),
      param(0) { }
  SelStmt(Prop::ID id ,CompOP op, const ParamType& parm) 
    : sel_id(id),
      comp_op(op),
      param(parm) { }
      
  bool operator ==(const SelStmt& rhs) {
    return sel_id == rhs.sel_id && comp_op == rhs.comp_op && param == rhs.param;
  }
};
typedef enum {
  LOGIC, VALUE
} SelItemType;

struct SelItem {
  SelItemType  type;
  size_t       value;
};

struct GenProp {
  EntityPropertyMapper mapper;
  float                default_val;
  bool                 has_default;
  GenProp(EntityPropertyMapper epm) :
         mapper(epm), default_val(0.0), has_default(false) {}
};

typedef std::vector<SelItem> SelStack;

typedef std::vector<SelStmt> SelStmts;
  
class QueryImpl {
public:
  friend class mol::QueryState;
  QueryImpl(const String& query_string="");
  QueryImpl(Node* ast);
  bool IsValid() const;
  
  bool IsEmpty() const;

  const String& GetQueryString() const;
  

  const QueryErrorDesc& GetErrorDescription() const;
  
  mol::QueryState CreateQueryState(const EntityHandle& h) const;
  mol::QueryState CreateQueryState(const EntityView& v) const;
private:
  
  Node* BuildAST();  
  void ASTToSelStack(const Node* src_ast,Prop::Level target_level,
                     SelStack& stack);
  
  bool IsAlwaysUndef(const Node* ast_node, Prop::Level target_level);
  
  void ExtractSelStmts(const Node* ast);
  
  Node* ParsePropValueExpr(QueryLexer& lexer);
  
  Node* ParseSubExpr(QueryLexer& lexer, bool paren=false);

  Node* ParseParenSubExpr(QueryLexer& lexer);  
  
  Node* ParseBracketSubExpr(QueryLexer& lexer);
  
  Node* ParseWithinExpr(QueryLexer& lexer);
  
  bool ParsePoint(QueryLexer& lexer, geom::Vec3& point);
  
  bool Expect(tok::Type type, const String& s, const QueryToken& token);
  
  bool ExpectNumeric(const QueryToken& token);
  
  bool ExpectLogicalOperator(const QueryToken& token);
  
  bool ExpectComparisonOperator(const QueryToken& token);
  
  bool ExpectNotEnd(const QueryToken& token, const String& s);
  
  bool ParseValue(const Prop& sel, const QueryToken& op,
                  QueryLexer& lexer, ParamType& value);

  Node* ParseValueOrRange(const Prop& s, const QueryToken& op, 
                          QueryLexer& lexer);
  Node* Concatenate(Node* lhs, Node* rhs, LogicOP logical_op);
  
  String                            query_string_;
  bool                              has_error_;
  bool                              empty_optimize_;
  QueryErrorDesc                    error_desc_;
  std::vector<GenProp>              gen_prop_list_;
  int                               num_gen_prop_;
protected:  
  std::vector<SelStmt>              sel_values_;
  std::vector<SelStack>             sel_stacks_;
  std::vector<std::set<size_t> >    indices_;
  std::vector<bool>                 inversion_stack_;
  std::vector<QueryImplP>           bracketed_expr_;
};
 
}}} // ns

#endif