tr_selector.hpp

/* tr_selector.hpp */
/* $Id$ */
#ifndef __tr_selector_hpp
#define __tr_selector_hpp

#include <vector>
#include <string>
#include <iostream>

#include <hds_db/base/tr_header.hpp>

namespace hds
{
  namespace db
  {
    enum TrSelSortOp
      {
    TS_ASC_ORDER = 0,   
    TS_DESC_ORDER = 1,  
    TS_UNIQ = 2         
      };
    
    std::string toString(TrSelSortOp op);
    
    enum TrSelMatchOp
      {
    TS_EQ = 3,  
    TS_NEQ = 4, 
    TS_GT = 5,  
    TS_LT = 6   
      };
    
    std::string toString(TrSelMatchOp op);
    
    enum TrSelRangeOp
      {
    TS_RANGE = 7 
      };
    
    std::string toString(TrSelRangeOp op);
    
    
    class TrSelBaseRule
    {
    public:
      
      TrSelBaseRule();
      
      virtual ~TrSelBaseRule();
      
      virtual TrSelBaseRule* clone() const = 0;
      
      virtual int opType() const = 0;
      
      virtual TrHeaderAttrId hdrAttrId() const = 0;
    };
    
    class TrSelSortRule : public TrSelBaseRule
    {
    public:
      
      TrSelSortRule(TrSelSortOp op, TrHeaderAttrId hdr_attr_id);
      
      virtual ~TrSelSortRule();
      
      virtual TrSelBaseRule* clone() const;
      
      virtual int opType() const;
      
      TrHeaderAttrId hdrAttrId() const;
      
    protected:
      
      TrSelSortOp m_op;

      TrHeaderAttrId m_hdr_attr_id;
    };
    
    template <typename AttrT>
    class TrSelMatchRule : public TrSelBaseRule
    {
    public:
      
      TrSelMatchRule(TrSelMatchOp op, 
             TrHeaderAttrId hdr_attr_id, 
             const AttrT &attr_val);
      
      TrSelMatchRule(TrSelMatchOp op, 
             TrHeaderAttrId hdr_attr_id, 
             std::vector<AttrT> &attr_vals);
      
      virtual ~TrSelMatchRule();
      
      virtual TrSelBaseRule* clone() const;
      
      virtual int opType() const;
    
      TrHeaderAttrId hdrAttrId() const;
      
      const std::vector<AttrT>& hdrAttrVals() const;
      
    protected:
      
      TrSelMatchOp m_op;
      
      TrHeaderAttrId m_hdr_attr_id;
      
      std::vector<AttrT> m_hdr_attr_vals;
    };
    
    template <typename AttrT>
    class TrSelRangeRule : public TrSelBaseRule
    {
    public:
      
      TrSelRangeRule(TrHeaderAttrId hdr_attr_id, 
             const AttrT &av1,
             const AttrT &av2);
      
      virtual ~TrSelRangeRule();
      
      virtual TrSelBaseRule* clone() const;
      
      virtual int opType() const;
      
      TrHeaderAttrId hdrAttrId() const;
      
      const std::pair<AttrT, AttrT>& range() const;
      
    protected:
      
      TrHeaderAttrId m_hdr_attr_id;
      
      std::pair<AttrT, AttrT> m_range;
    };
    
    class TrSelector
    {
    public:
      
      TrSelector();

      TrSelector(const TrSelector &that);

      ~TrSelector();
      
      TrSelector& operator=(const TrSelector &that);
      
      
      TrSelector& operator<<(const TrSelBaseRule &r);
      
      
      void clear();

      size_t rulesNum() const;

      const TrSelBaseRule* rule(size_t id) const;
      
      void info(std::ostream &stream = std::cout) const;
      
    protected:
      
      std::vector<TrSelBaseRule*> m_rules;
    };
  }; // db
}; // hds

#include "tr_selector_inline.hpp"

#endif /* tr_selector.hpp */