AsyncDnsLookup.h

Go to the documentation of this file.

 
#ifndef ASYNC_DNS_LOOKUP_INCLUDED
#define ASYNC_DNS_LOOKUP_INCLUDED
 
 
/****************************************************************************
 *
 * System Includes
 *
 ****************************************************************************/
 
#include <sigc++/sigc++.h>
 
#include <vector>
#include <memory>
#include <random>
 
 
/****************************************************************************
 *
 * Project Includes
 *
 ****************************************************************************/
 
#include <AsyncIpAddress.h>
#include <AsyncDnsResourceRecord.h>
 
 
/****************************************************************************
 *
 * Local Includes
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Forward declarations
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Namespace
 *
 ****************************************************************************/
 
namespace Async
{
 
/****************************************************************************
 *
 * Defines & typedefs
 *
 ****************************************************************************/
 
class DnsLookupWorker;
 
 
/****************************************************************************
 *
 * Exported Global Variables
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Class definitions
 *
 ****************************************************************************/
 
class DnsLookup : public sigc::trackable
{
  public:
    using Type = DnsResourceRecord::Type;
    template <class RR> using RRList = std::vector<std::unique_ptr<RR>>;
    template <class RR> using SharedRRList = std::vector<std::shared_ptr<RR>>;
 
    DnsLookup(void);
 
    DnsLookup(const std::string& label, Type type=Type::A);
 
    ~DnsLookup(void);
 
    DnsLookup& operator=(DnsLookup&& other);
 
    void setLookupParams(const std::string& label, Type type=Type::A);
 
    bool lookup(const std::string& label, Type type=Type::A);
 
    bool lookup(void);
 
    void abort(void);
 
    Type type(void) const { return m_type; }
 
    std::string typeStr(void) const
    {
      return DnsResourceRecord::typeToString(type());
    }
 
    const std::string &label(void) const { return m_label; }
 
    bool isPending(void) const;
 
    bool lookupFailed(void) const;
 
    bool resultsAreReady(void) const;
 
    bool recordsValid(void) const;
 
    bool empty(void) const { return resourceRecordsP().empty(); }
 
    void clear(void);
 
    void addStaticResourceRecord(DnsResourceRecord* rr);
 
    const RRList<DnsResourceRecord>& staticResourceRecords(void) const
    {
      return m_static_rrs;
    }
 
    std::vector<IpAddress> addresses(void);
 
    DnsResourceRecord::List resourceRecords(Type type=Type::ANY) const
    {
      DnsResourceRecord::List rrs;
      cloneResourceRecords(rrs, type);
      return rrs;
    }
 
    template <class RR>
    void resourceRecords(RRList<RR>& rrs) const
    {
      rrs.clear();
      cloneResourceRecords(rrs, RR::staticType());
    }
 
    template <class RR>
    void resourceRecords(SharedRRList<RR>& rrs) const
    {
      rrs.clear();
      cloneResourceRecords(rrs, RR::staticType());
    }
 
    sigc::signal<void, DnsLookup&> resultsReady;
 
  private:
    typedef std::vector<DnsResourceRecord*> RRListP;
 
    std::string                 m_label;
    Type                        m_type          = Type::A;
    DnsLookupWorker*            m_worker        = 0;
    RRList<DnsResourceRecord>   m_static_rrs;
    std::default_random_engine  m_rng;
 
    void onResultsReady(void);
    const RRListP& resourceRecordsP(void) const;
 
    template <class RR>
    void cloneResourceRecords(RRList<RR>& rrs, Type type) const
    {
      for (const auto& rr : resourceRecordsP())
      {
        if ((type == RR::Type::ANY) || (rr->type() == type))
        {
          rrs.push_back(std::unique_ptr<RR>(static_cast<RR*>(rr->clone())));
        }
      }
    }
 
    template <class RR>
    void cloneResourceRecords(SharedRRList<RR>& rrs, Type type) const
    {
      for (const auto& rr : resourceRecordsP())
      {
        if ((type == RR::Type::ANY) || (rr->type() == type))
        {
          rrs.push_back(std::shared_ptr<RR>(static_cast<RR*>(rr->clone())));
        }
      }
    }
 
};  /* class DnsLookup */
 
 
} /* namespace */
 
#endif /* ASYNC_DNS_LOOKUP_INCLUDED */
 
 
 
/*
 * This file has not been truncated
 */