In This Package:

ParameterDescription.h

Go to the documentation of this file.

#ifndef PARAMETERDESCRIPTION_H
#define PARAMETERDESCRIPTION_H

#include <vector>
#include <string>
#include <typeinfo>
#include <boost/shared_ptr.hpp>


namespace RuleParser{

class RuleFactory;

class ParameterDescription
{
public:
  // For complex, user-driven parameter types
  ParameterDescription(unsigned int id,                    // ID number for use with queryParam
                       const std::string& name,            // String that matches this paramter when parsing
                       const std::type_info& type,         // Type of returned parameter, int, double, string, or custom
                       const std::vector<std::string>& operators, // List of operators valid for this parameter.
                       const boost::shared_ptr<RuleFactory>& ruleFactory // Optional factory that will produce rule for this paramater
                       );

  ParameterDescription(unsigned int id,                    // ID number for use with queryParam
                       const std::string& name,            // String that matches this paramter when parsing
                       const std::type_info& type,         // Type of returned parameter, int, double, string, or custom
                       const std::vector<std::string>& operators, // List of operators valid for this parameter.
                       RuleFactory* ruleFactory           // Optional factory that will produce rule for this paramater
                       );

  // For simple parameters (int,double,string match)
  ParameterDescription(unsigned int id,                    // ID number for use with queryParam
                       const std::string& name,            // String that matches this paramter when parsing
                       const std::type_info& type          // Type of returned parameter, int, double, string, or custom
                       );

  ~ParameterDescription();

  const std::string&   name()  const{ return m_name; };
  unsigned int         id()    const{ return m_id;   };
  const std::string&   type()  const{ return m_type; };
  
  const std::vector<std::string>&       operators() const{ return m_operators; };
  const boost::shared_ptr<RuleFactory>& factory()   const{ return m_factory; };
  bool                                  isCustom()  const{ return m_factory.get(); };
  
protected:
  unsigned int                   m_id;
  std::string                    m_name;
  std::string                    m_type;
  std::vector<std::string>       m_operators;
  boost::shared_ptr<RuleFactory> m_factory;
};


class ParameterList;

class ParameterList : public std::vector<ParameterDescription>
{
public:
  // Some easier ways to add paramters to the list.
  
  ParameterList& add(const ParameterDescription& d) { push_back(d); return *this; };

  template<typename T>
  ParameterList& add(unsigned int id, const std::string& name)
    { push_back(ParameterDescription(id,name,typeid(T))); return *this; }  ;

  template<typename T>
  ParameterList& add(unsigned int id, 
                    const std::string& name, 
                    const std::string& alias1)
    { 
      push_back(ParameterDescription(id,name,  typeid(T)));
      push_back(ParameterDescription(id,alias1,typeid(T)));
      return *this; 
    }; 
  
  template<typename T>
  ParameterList& add(unsigned int id, 
                    const std::string& name, 
                    const std::string& alias1,
                    const std::string& alias2)
    { 
      push_back(ParameterDescription(id,name,  typeid(T)));
      push_back(ParameterDescription(id,alias1,typeid(T)));
      push_back(ParameterDescription(id,alias2,typeid(T)));
      return *this; 
    };  

  template<typename T>
  ParameterList& add(unsigned int id, 
                    const std::string& name, 
                    const std::string& alias1,
                    const std::string& alias2,
                    const std::string& alias3)
    { 
      push_back(ParameterDescription(id,name,  typeid(T)));
      push_back(ParameterDescription(id,alias1,typeid(T)));
      push_back(ParameterDescription(id,alias2,typeid(T)));
      push_back(ParameterDescription(id,alias3,typeid(T)));
      return *this; 
    }; 
  
  template<typename T>
  ParameterList& add(unsigned int id, 
                    const std::string& name,
                    const std::string& opname,
                    RuleFactory* factory)
    { 
      push_back(ParameterDescription(id,name,typeid(T),std::vector<std::string>(1,opname),factory)); 
      return *this; 
    };  
  
  template<typename T>
  ParameterList& add(unsigned int id, 
                    const std::string& name,
                    const std::string& opname,
                    const boost::shared_ptr<RuleFactory>& factory)
    { 
      push_back(ParameterDescription(id,name,typeid(T),std::vector<std::string>(1,opname),factory)); 
      return *this; 
    };  
  
};

}

#endif /* PARAMETERDESCRIPTION_H */

---