ServicePattern.hpp

Go to the documentation of this file.

#ifndef _SERVICE_DISCOVERY_SERVICEPATTERN_CORE_H_
#define _SERVICE_DISCOVERY_SERVICEPATTERN_CORE_H_

#include <string>
#include <vector>
#include <boost/regex.hpp>
#include <service_discovery/impl/avahi/ServiceConfiguration.hpp>

namespace servicediscovery { 
namespace avahi {

struct SearchPattern 
{
        SearchPattern(const std::string& _name = ".*" , const std::string& _label = ".*", const std::string& _txt = ".*", const std::string _type = ".*")
            : namePattern(_name)
            , labelPattern(_label)
            , txtPattern(_txt)
            , typePattern(_type)
        {}

        virtual ~SearchPattern() {}

        boost::regex namePattern;
        boost::regex labelPattern;
        boost::regex txtPattern;
        boost::regex typePattern;

        virtual bool isMatching(const ServiceDescription& description) const;
};

                
namespace pattern {

  enum Flags {
    BUSY = 1,
    READY = 2,
    SLAM = 4,
    MANIPULATOR = 8,
    REMOTE = 16
  };

  std::string castFlags(Flags flags);  
}

struct ServicePattern 
{
  virtual ~ServicePattern() {}
  virtual bool matchDescription(const ServiceDescription& service) const = 0;
};

// ----------------------------------------------------------------------------

struct PropertyPattern : public ServicePattern 
{
  PropertyPattern(const std::string& label = "*", const std::string& expression = ".*")
   : label(label), expression(expression, boost::regex::extended) {}

  virtual ~PropertyPattern() {}

  bool matchDescription(const ServiceDescription& service) const;

 private:
  std::string label;
  boost::regex expression;
};

namespace pattern {
  std::string hasAuthority(int authority);
}

// ----------------------------------------------------------------------------

struct PositionPattern : public ServicePattern 
{
  PositionPattern(int x, int y, int z, double distance) 
    : x(x), y(y), z(z), distance(distance) {}

  virtual ~PositionPattern() {}

  bool matchDescription(const ServiceDescription& service) const;

 private:
  int x, y, z;    
  double distance;
};

// ----------------------------------------------------------------------------

struct FlagPattern : public ServicePattern 
{
  FlagPattern(int flags) : flags(flags) {}

  virtual ~FlagPattern() {}

  bool matchDescription(const ServiceDescription& service) const;

 private:
  int flags;
};

// ----------------------------------------------------------------------------

struct MultiPattern : public ServicePattern 
{
  MultiPattern() {}

  virtual ~MultiPattern() {}

  bool matchDescription(const ServiceDescription& service) const;

  MultiPattern& operator<<(const ServicePattern& pattern) {
    patterns.push_back(&pattern);
    return *this;
  }

  private:
    std::vector<const ServicePattern*> patterns;    
};

// ----------------------------------------------------------------------------

struct AuthorityPattern : public ServicePattern 
{
  AuthorityPattern(int authority, bool atleast = true) : authority(authority), atleast(atleast) {}  

  virtual ~AuthorityPattern() {}

  bool matchDescription(const ServiceDescription& service) const;

 private:
  int authority;
  bool atleast;
};

} // end namespace avahi
} // end namespace servicediscovery
#endif // _SERVICE_DISCOVERY_SERVICEPATTERN_CORE_H_