scanner_config_builder.h

Go to the documentation of this file.

// Copyright (c) 2020-2021 Pilz GmbH & Co. KG
//
// This program 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 of the License, or
// (at your option) any later version.
//
// This program 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 program.  If not, see <https://www.gnu.org/licenses/>.
 
#ifndef PSEN_SCAN_V2_STANDALONE_SCANNER_CONFIG_BUILDER_H
#define PSEN_SCAN_V2_STANDALONE_SCANNER_CONFIG_BUILDER_H
 
#include <cmath>
#include <stdexcept>
#include <string>
 
#include "psen_scan_v2_standalone/scanner_configuration.h"
#include "psen_scan_v2_standalone/configuration/scanner_ids.h"
#include "psen_scan_v2_standalone/scan_range.h"
#include "psen_scan_v2_standalone/data_conversion_layer/angle_conversions.h"
#include "psen_scan_v2_standalone/util/ip_conversion.h"
 
namespace psen_scan_v2_standalone
{
class ScannerConfigurationBuilder
{
public:
  ScannerConfigurationBuilder(const std::string& scanner_ip);  // IP is mandatory
  ScannerConfiguration build() const;
 
public:
  ScannerConfigurationBuilder& hostIP(const std::string& host_ip);
  ScannerConfigurationBuilder& hostDataPort(const int& host_data_port);
  ScannerConfigurationBuilder& hostControlPort(const int& host_control_port);
  ScannerConfigurationBuilder& scannerIp(const std::string& scanner_ip);
  ScannerConfigurationBuilder& scannerDataPort(const int& scanner_data_port);
  ScannerConfigurationBuilder& scannerControlPort(const int& scanner_control_port);
  ScannerConfigurationBuilder& scanRange(const ScanRange& scan_range);
  ScannerConfigurationBuilder& scanResolution(const util::TenthOfDegree& scan_resolution);
  ScannerConfigurationBuilder& enableDiagnostics(const bool& enable);
  ScannerConfigurationBuilder& enableIntensities(const bool& enable);
  ScannerConfigurationBuilder& enableFragmentedScans(const bool& enable);
  ScannerConfigurationBuilder& nrSubscribers(const uint8_t& nr_subscribers);
  operator ScannerConfiguration();
 
private:
  static uint16_t convertPort(const int& port);
 
private:
  ScannerConfiguration config_;
};
 
ScannerConfigurationBuilder::ScannerConfigurationBuilder(const std::string& scanner_ip)
{
  scannerIp(scanner_ip);
}
 
inline ScannerConfiguration ScannerConfigurationBuilder::build() const
{
  if (!config_.isComplete())
  {
    throw std::runtime_error("Scanner configuration not complete");
  }
  else if (!config_.isValid())
  {
    throw std::invalid_argument("Scanner configuration not valid");
  }
 
  return config_;
}
 
inline ScannerConfigurationBuilder& ScannerConfigurationBuilder::hostIP(const std::string& ip)
{
  if (!ip.empty() && ip != "auto")
  {
    config_.host_ip_ = util::convertIP(ip);
  }
  return *this;
}
 
inline ScannerConfigurationBuilder& ScannerConfigurationBuilder::hostDataPort(const int& port)
{
  config_.host_data_port_ = util::convertPort(port);
  return *this;
}
 
inline ScannerConfigurationBuilder& ScannerConfigurationBuilder::hostControlPort(const int& port)
{
  config_.host_control_port_ = util::convertPort(port);
  return *this;
}
 
inline ScannerConfigurationBuilder& ScannerConfigurationBuilder::scannerIp(const std::string& ip)
{
  config_.scanner_ip_ = util::convertIP(ip);
  return *this;
}
 
inline ScannerConfigurationBuilder& ScannerConfigurationBuilder::scannerDataPort(const int& port)
{
  config_.scanner_data_port_ = util::convertPort(port);
  return *this;
}
 
inline ScannerConfigurationBuilder& ScannerConfigurationBuilder::scannerControlPort(const int& port)
{
  config_.scanner_control_port_ = util::convertPort(port);
  return *this;
}
 
inline ScannerConfigurationBuilder& ScannerConfigurationBuilder::scanRange(const ScanRange& scan_range)
{
  config_.scan_range_ = scan_range;
  return *this;
}
 
inline ScannerConfigurationBuilder&
ScannerConfigurationBuilder::scanResolution(const util::TenthOfDegree& scan_resolution)
{
  if (scan_resolution < util::TenthOfDegree(1) || scan_resolution > util::TenthOfDegree(100))
  {
    throw std::invalid_argument("Scan resolution has to be between 0.1 and 10 degrees.");
  }
  config_.scan_resolution_ = scan_resolution;
  return *this;
}
 
inline ScannerConfigurationBuilder& ScannerConfigurationBuilder::enableDiagnostics(const bool& enable = true)
{
  config_.diagnostics_enabled_ = enable;
  return *this;
}
 
inline ScannerConfigurationBuilder& ScannerConfigurationBuilder::enableIntensities(const bool& enable = true)
{
  config_.intensities_enabled_ = enable;
  return *this;
}
 
inline ScannerConfigurationBuilder& ScannerConfigurationBuilder::enableFragmentedScans(const bool& enable = true)
{
  config_.fragmented_scans_ = enable;
  return *this;
}
 
inline ScannerConfigurationBuilder& ScannerConfigurationBuilder::nrSubscribers(const uint8_t& nr_subscribers = 0)
{
  if (nr_subscribers > configuration::MAX_NR_SUBSCRIBERS)
  {
    throw std::invalid_argument("No more than 3 subscribers are supported.");
  }
  config_.nr_subscribers_ = nr_subscribers;
  return *this;
}
 
ScannerConfigurationBuilder::operator ScannerConfiguration()
{
  return build();
}
 
}  // namespace psen_scan_v2_standalone
 
#endif  // PSEN_SCAN_V2_STANDALONE_SCANNER_CONFIG_BUILDER_H