boarddesignrulecheckmessages.h

Go to the documentation of this file.

/*
 * LibrePCB - Professional EDA for everyone!
 * Copyright (C) 2013 LibrePCB Developers, see AUTHORS.md for contributors.
 * https://librepcb.org/
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef LIBREPCB_CORE_BOARDDESIGNRULECHECKMESSAGES_H
#define LIBREPCB_CORE_BOARDDESIGNRULECHECKMESSAGES_H
 
/*******************************************************************************
 *  Includes
 ******************************************************************************/
#include "../../../rulecheck/rulecheckmessage.h"
#include "boarddesignrulecheckdata.h"
 
#include <QtCore>
 
/*******************************************************************************
 *  Namespace / Forward Declarations
 ******************************************************************************/
namespace librepcb {
 
/*******************************************************************************
 *  Class DrcHoleRef
 ******************************************************************************/
 
struct DrcHoleRef {
  using Data = BoardDesignRuleCheckData;
 
  bool isPadHole() const noexcept { return mDevice && mPad && mHole; }
  bool isViaHole() const noexcept { return mSegment && mVia; }
  bool isPlated() const noexcept { return isPadHole() || isViaHole(); }
  const QString& getNetName() const noexcept { return mNetName; }
  const Data::Pad* getPad() const noexcept { return mPad; }
  PositiveLength getDiameter() const noexcept {
    if (mHole) {
      return mHole->diameter;
    } else if (mVia) {
      return mVia->drillDiameter;
    } else {
      Q_ASSERT(false);
      qCritical() << "DrcHoleRef: Unknown object type.";
      return PositiveLength(1);
    }
  }
  PositiveLength getDiameter() const noexcept {…}
  void serialize(SExpression& node) const;
 
  static DrcHoleRef boardHole(const Data::Hole& hole) {
    DrcHoleRef obj;
    obj.mHole = &hole;
    return obj;
  }
  static DrcHoleRef boardHole(const Data::Hole& hole) {…}
  static DrcHoleRef deviceHole(const Data::Device& device,
                               const Data::Hole& hole) {
    DrcHoleRef obj;
    obj.mDevice = &device;
    obj.mHole = &hole;
    return obj;
  }
  static DrcHoleRef deviceHole(const Data::Device& device, {…}
  static DrcHoleRef padHole(const Data::Device& device, const Data::Pad& pad,
                            const Data::Hole& hole) {
    DrcHoleRef obj;
    obj.mDevice = &device;
    obj.mPad = &pad;
    obj.mHole = &hole;
    obj.mNetName = pad.netName;
    return obj;
  }
  static DrcHoleRef padHole(const Data::Device& device, const Data::Pad& pad, {…}
  static DrcHoleRef via(const Data::Segment& segment, const Data::Via& via) {
    DrcHoleRef obj;
    obj.mSegment = &segment;
    obj.mVia = &via;
    obj.mNetName = segment.netName;
    return obj;
  }
  static DrcHoleRef via(const Data::Segment& segment, const Data::Via& via) {…}
 
private:
  const Data::Hole* mHole = nullptr;
  const Data::Segment* mSegment = nullptr;
  const Data::Via* mVia = nullptr;
  const Data::Device* mDevice = nullptr;
  const Data::Pad* mPad = nullptr;
  QString mNetName;  // Empty if no net.
};
struct DrcHoleRef {…};
 
/*******************************************************************************
 *  Class DrcMsgMissingDevice
 ******************************************************************************/
 
class DrcMsgMissingDevice final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgMissingDevice)
 
public:
  // Constructors / Destructor
  DrcMsgMissingDevice() = delete;
  DrcMsgMissingDevice(const Uuid& uuid, const QString& name) noexcept;
  DrcMsgMissingDevice(const DrcMsgMissingDevice& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgMissingDevice(const DrcMsgMissingDevice& other) noexcept {…}
  virtual ~DrcMsgMissingDevice() noexcept {}
};
class DrcMsgMissingDevice final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgMissingConnection
 ******************************************************************************/
 
class DrcMsgMissingConnection final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgMissingConnection)
 
public:
  using Data = BoardDesignRuleCheckData;
  struct Anchor {
    QString getName() const;
    void serialize(SExpression& node) const;
 
    static Anchor pad(const Data::Device& device, const Data::Pad& pad) {
      Anchor obj;
      obj.mDevice = &device;
      obj.mPad = &pad;
      return obj;
    }
    static Anchor pad(const Data::Device& device, const Data::Pad& pad) {…}
    static Anchor junction(const Data::Segment& segment,
                           const Data::Junction& junction) {
      Anchor obj;
      obj.mSegment = &segment;
      obj.mJunction = &junction;
      return obj;
    }
    static Anchor junction(const Data::Segment& segment, {…}
    static Anchor via(const Data::Segment& segment, const Data::Via& via) {
      Anchor obj;
      obj.mSegment = &segment;
      obj.mVia = &via;
      return obj;
    }
    static Anchor via(const Data::Segment& segment, const Data::Via& via) {…}
 
  private:
    // Either it's a pad...
    const Data::Device* mDevice = nullptr;
    const Data::Pad* mPad = nullptr;
    // ... or a junction or via
    const Data::Segment* mSegment = nullptr;
    const Data::Junction* mJunction = nullptr;
    const Data::Via* mVia = nullptr;
  };
  struct Anchor {…};
 
  // Constructors / Destructor
  DrcMsgMissingConnection() = delete;
  DrcMsgMissingConnection(const Anchor& p1, const Anchor& p2,
                          const QString& netName,
                          const QVector<Path>& locations);
  DrcMsgMissingConnection(const DrcMsgMissingConnection& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgMissingConnection(const DrcMsgMissingConnection& other) noexcept {…}
  virtual ~DrcMsgMissingConnection() noexcept {}
};
class DrcMsgMissingConnection final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgMissingBoardOutline
 ******************************************************************************/
 
class DrcMsgMissingBoardOutline final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgMissingBoardOutline)
 
public:
  // Constructors / Destructor
  DrcMsgMissingBoardOutline() noexcept;
  DrcMsgMissingBoardOutline(const DrcMsgMissingBoardOutline& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgMissingBoardOutline(const DrcMsgMissingBoardOutline& other) noexcept {…}
  virtual ~DrcMsgMissingBoardOutline() noexcept {}
};
class DrcMsgMissingBoardOutline final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgMultipleBoardOutlines
 ******************************************************************************/
 
class DrcMsgMultipleBoardOutlines final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgMultipleBoardOutlines)
 
public:
  // Constructors / Destructor
  explicit DrcMsgMultipleBoardOutlines(const QVector<Path>& locations) noexcept;
  DrcMsgMultipleBoardOutlines(const DrcMsgMultipleBoardOutlines& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgMultipleBoardOutlines(const DrcMsgMultipleBoardOutlines& other) noexcept {…}
  virtual ~DrcMsgMultipleBoardOutlines() noexcept {}
};
class DrcMsgMultipleBoardOutlines final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgOpenBoardOutlinePolygon
 ******************************************************************************/
 
class DrcMsgOpenBoardOutlinePolygon final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgOpenBoardOutlinePolygon)
 
public:
  // Constructors / Destructor
  DrcMsgOpenBoardOutlinePolygon() = delete;
  DrcMsgOpenBoardOutlinePolygon(const Uuid& polygon,
                                const std::optional<Uuid>& device,
                                const QVector<Path>& locations) noexcept;
  DrcMsgOpenBoardOutlinePolygon(
      const DrcMsgOpenBoardOutlinePolygon& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgOpenBoardOutlinePolygon( {…}
  virtual ~DrcMsgOpenBoardOutlinePolygon() noexcept {}
};
class DrcMsgOpenBoardOutlinePolygon final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgMinimumBoardOutlineInnerRadiusViolation
 ******************************************************************************/
 
class DrcMsgMinimumBoardOutlineInnerRadiusViolation final
  : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgMinimumBoardOutlineInnerRadiusViolation)
 
public:
  // Constructors / Destructor
  DrcMsgMinimumBoardOutlineInnerRadiusViolation() = delete;
  DrcMsgMinimumBoardOutlineInnerRadiusViolation(
      const UnsignedLength& minRadius, const QVector<Path>& locations) noexcept;
  DrcMsgMinimumBoardOutlineInnerRadiusViolation(
      const DrcMsgMinimumBoardOutlineInnerRadiusViolation& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgMinimumBoardOutlineInnerRadiusViolation( {…}
  virtual ~DrcMsgMinimumBoardOutlineInnerRadiusViolation() noexcept {}
};
class DrcMsgMinimumBoardOutlineInnerRadiusViolation final {…};
 
/*******************************************************************************
 *  Class DrcMsgEmptyNetSegment
 ******************************************************************************/
 
class DrcMsgEmptyNetSegment final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgEmptyNetSegment)
 
public:
  using Data = BoardDesignRuleCheckData;
 
  // Constructors / Destructor
  DrcMsgEmptyNetSegment() = delete;
  explicit DrcMsgEmptyNetSegment(const Data::Segment& ns) noexcept;
  DrcMsgEmptyNetSegment(const DrcMsgEmptyNetSegment& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgEmptyNetSegment(const DrcMsgEmptyNetSegment& other) noexcept {…}
  virtual ~DrcMsgEmptyNetSegment() noexcept {}
};
class DrcMsgEmptyNetSegment final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgUnconnectedJunction
 ******************************************************************************/
 
class DrcMsgUnconnectedJunction final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgUnconnectedJunction)
 
public:
  using Data = BoardDesignRuleCheckData;
 
  // Constructors / Destructor
  DrcMsgUnconnectedJunction() = delete;
  DrcMsgUnconnectedJunction(const Data::Junction& junction,
                            const Data::Segment& ns,
                            const QVector<Path>& locations) noexcept;
  DrcMsgUnconnectedJunction(const DrcMsgUnconnectedJunction& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgUnconnectedJunction(const DrcMsgUnconnectedJunction& other) noexcept {…}
  virtual ~DrcMsgUnconnectedJunction() noexcept {}
};
class DrcMsgUnconnectedJunction final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgMinimumTextHeightViolation
 ******************************************************************************/
 
class DrcMsgMinimumTextHeightViolation final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgMinimumTextHeightViolation)
 
public:
  using Data = BoardDesignRuleCheckData;
 
  // Constructors / Destructor
  DrcMsgMinimumTextHeightViolation() = delete;
  DrcMsgMinimumTextHeightViolation(const Data::StrokeText& st,
                                   const Data::Device* device,
                                   const UnsignedLength& minHeight,
                                   const QVector<Path>& locations) noexcept;
  DrcMsgMinimumTextHeightViolation(
      const DrcMsgMinimumTextHeightViolation& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgMinimumTextHeightViolation( {…}
  virtual ~DrcMsgMinimumTextHeightViolation() noexcept {}
};
class DrcMsgMinimumTextHeightViolation final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgMinimumWidthViolation
 ******************************************************************************/
 
class DrcMsgMinimumWidthViolation final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgMinimumWidthViolation)
 
public:
  using Data = BoardDesignRuleCheckData;
 
  // Constructors / Destructor
  DrcMsgMinimumWidthViolation() = delete;
  DrcMsgMinimumWidthViolation(const Data::Segment& segment,
                              const Data::Trace& trace,
                              const UnsignedLength& minWidth,
                              const QVector<Path>& locations) noexcept;
  DrcMsgMinimumWidthViolation(const Data::Plane& plane,
                              const UnsignedLength& minWidth,
                              const QVector<Path>& locations) noexcept;
  DrcMsgMinimumWidthViolation(const Data::Polygon& polygon,
                              const UnsignedLength& minWidth,
                              const QVector<Path>& locations) noexcept;
  DrcMsgMinimumWidthViolation(const Data::StrokeText& text,
                              const Data::Device* device,
                              const UnsignedLength& minWidth,
                              const QVector<Path>& locations) noexcept;
  DrcMsgMinimumWidthViolation(const Data::Device& device,
                              const Data::Polygon& polygon,
                              const UnsignedLength& minWidth,
                              const QVector<Path>& locations) noexcept;
  DrcMsgMinimumWidthViolation(const Data::Device& device,
                              const Data::Circle& circle,
                              const UnsignedLength& minWidth,
                              const QVector<Path>& locations) noexcept;
  DrcMsgMinimumWidthViolation(const DrcMsgMinimumWidthViolation& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgMinimumWidthViolation(const DrcMsgMinimumWidthViolation& other) noexcept {…}
  virtual ~DrcMsgMinimumWidthViolation() noexcept {}
};
class DrcMsgMinimumWidthViolation final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgCopperCopperClearanceViolation
 ******************************************************************************/
 
class DrcMsgCopperCopperClearanceViolation final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgCopperCopperClearanceViolation)
 
public:
  using Data = BoardDesignRuleCheckData;
 
  struct Object {
    QString getName() const;
    void serialize(SExpression& node) const;
 
    static Object pad(const Data::Pad& pad, const Data::Device& device) {
      Object obj;
      obj.mPad = &pad;
      obj.mDevice = &device;
      obj.mNetName = pad.netName;
      return obj;
    }
    static Object pad(const Data::Pad& pad, const Data::Device& device) {…}
    static Object trace(const Data::Trace& trace,
                        const Data::Segment& segment) {
      Object obj;
      obj.mTrace = &trace;
      obj.mSegment = &segment;
      obj.mNetName = segment.netName;
      return obj;
    }
    static Object trace(const Data::Trace& trace, {…}
    static Object via(const Data::Via& via, const Data::Segment& segment) {
      Object obj;
      obj.mVia = &via;
      obj.mSegment = &segment;
      obj.mNetName = segment.netName;
      return obj;
    }
    static Object via(const Data::Via& via, const Data::Segment& segment) {…}
    static Object plane(const Data::Plane& plane) {
      Object obj;
      obj.mPlane = &plane;
      obj.mNetName = plane.netName;
      return obj;
    }
    static Object plane(const Data::Plane& plane) {…}
    static Object polygon(const Data::Polygon& polygon,
                          const Data::Device* device) {
      Object obj;
      obj.mPolygon = &polygon;
      obj.mDevice = device;
      return obj;
    }
    static Object polygon(const Data::Polygon& polygon, {…}
    static Object circle(const Data::Circle& circle,
                         const Data::Device* device) {
      Object obj;
      obj.mCircle = &circle;
      obj.mDevice = device;
      return obj;
    }
    static Object circle(const Data::Circle& circle, {…}
    static Object strokeText(const Data::StrokeText& txt,
                             const Data::Device* device) {
      Object obj;
      obj.mStrokeText = &txt;
      obj.mDevice = device;
      return obj;
    }
    static Object strokeText(const Data::StrokeText& txt, {…}
 
    bool operator==(const Object& rhs) const {
      std::unique_ptr<SExpression> obj1 = SExpression::createList("object");
      serialize(*obj1);
      std::unique_ptr<SExpression> obj2 = SExpression::createList("object");
      rhs.serialize(*obj2);
      return (*obj1) == (*obj2);
    }
    bool operator==(const Object& rhs) const  {…}
 
  private:
    // Actual object (one of them)
    const Data::Pad* mPad = nullptr;
    const Data::Trace* mTrace = nullptr;
    const Data::Via* mVia = nullptr;
    const Data::Plane* mPlane = nullptr;
    const Data::Polygon* mPolygon = nullptr;
    const Data::Circle* mCircle = nullptr;
    const Data::StrokeText* mStrokeText = nullptr;
 
    // Optional context (depending on object type)
    const Data::Segment* mSegment = nullptr;
    const Data::Device* mDevice = nullptr;
    QString mNetName;  // Empty if no net.
  };
  struct Object {…};
 
  // Constructors / Destructor
  DrcMsgCopperCopperClearanceViolation() = delete;
  DrcMsgCopperCopperClearanceViolation(const Object& obj1, const Object& obj2,
                                       const QSet<const Layer*>& layers,
                                       const Length& minClearance,
                                       const QVector<Path>& locations);
  DrcMsgCopperCopperClearanceViolation(
      const DrcMsgCopperCopperClearanceViolation& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgCopperCopperClearanceViolation( {…}
  virtual ~DrcMsgCopperCopperClearanceViolation() noexcept {}
 
private:
  static QString getLayerName(const QSet<const Layer*>& layers);
};
class DrcMsgCopperCopperClearanceViolation final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgCopperBoardClearanceViolation
 ******************************************************************************/
 
class DrcMsgCopperBoardClearanceViolation final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgCopperBoardClearanceViolation)
 
public:
  using Data = BoardDesignRuleCheckData;
 
  // Constructors / Destructor
  DrcMsgCopperBoardClearanceViolation() = delete;
  DrcMsgCopperBoardClearanceViolation(const Data::Segment& segment,
                                      const Data::Via& via,
                                      const UnsignedLength& minClearance,
                                      const QVector<Path>& locations) noexcept;
  DrcMsgCopperBoardClearanceViolation(const Data::Segment& segment,
                                      const Data::Trace& trace,
                                      const UnsignedLength& minClearance,
                                      const QVector<Path>& locations) noexcept;
  DrcMsgCopperBoardClearanceViolation(const Data::Device& device,
                                      const Data::Pad& pad,
                                      const UnsignedLength& minClearance,
                                      const QVector<Path>& locations) noexcept;
  DrcMsgCopperBoardClearanceViolation(const Data::Plane& plane,
                                      const UnsignedLength& minClearance,
                                      const QVector<Path>& locations) noexcept;
  DrcMsgCopperBoardClearanceViolation(const Data::Polygon& polygon,
                                      const Data::Device* device,
                                      const UnsignedLength& minClearance,
                                      const QVector<Path>& locations) noexcept;
  DrcMsgCopperBoardClearanceViolation(const Data::Device& device,
                                      const Data::Circle& circle,
                                      const UnsignedLength& minClearance,
                                      const QVector<Path>& locations) noexcept;
  DrcMsgCopperBoardClearanceViolation(const Data::StrokeText& strokeText,
                                      const Data::Device* device,
                                      const UnsignedLength& minClearance,
                                      const QVector<Path>& locations) noexcept;
  DrcMsgCopperBoardClearanceViolation(
      const DrcMsgCopperBoardClearanceViolation& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgCopperBoardClearanceViolation( {…}
  virtual ~DrcMsgCopperBoardClearanceViolation() noexcept {}
};
class DrcMsgCopperBoardClearanceViolation final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgCopperHoleClearanceViolation
 ******************************************************************************/
 
class DrcMsgCopperHoleClearanceViolation final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgCopperHoleClearanceViolation)
 
public:
  using Data = BoardDesignRuleCheckData;
 
  // Constructors / Destructor
  DrcMsgCopperHoleClearanceViolation() = delete;
  DrcMsgCopperHoleClearanceViolation(const Data::Hole& hole,
                                     const Data::Device* device,
                                     const UnsignedLength& minClearance,
                                     const QVector<Path>& locations) noexcept;
  DrcMsgCopperHoleClearanceViolation(
      const DrcMsgCopperHoleClearanceViolation& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgCopperHoleClearanceViolation( {…}
  virtual ~DrcMsgCopperHoleClearanceViolation() noexcept {}
};
class DrcMsgCopperHoleClearanceViolation final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgCopperInKeepoutZone
 ******************************************************************************/
 
class DrcMsgCopperInKeepoutZone final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgCopperInKeepoutZone)
 
public:
  using Data = BoardDesignRuleCheckData;
 
  // Constructors / Destructor
  DrcMsgCopperInKeepoutZone() = delete;
  DrcMsgCopperInKeepoutZone(const Data::Zone& zone,
                            const Data::Device* zoneDevice,
                            const Data::Device& device, const Data::Pad& pad,
                            const QVector<Path>& locations) noexcept;
  DrcMsgCopperInKeepoutZone(const Data::Zone& zone,
                            const Data::Device* zoneDevice,
                            const Data::Segment& ns, const Data::Via& via,
                            const QVector<Path>& locations) noexcept;
  DrcMsgCopperInKeepoutZone(const Data::Zone& zone,
                            const Data::Device* zoneDevice,
                            const Data::Segment& ns, const Data::Trace& trace,
                            const QVector<Path>& locations) noexcept;
  DrcMsgCopperInKeepoutZone(const Data::Zone& zone,
                            const Data::Device* zoneDevice,
                            const Data::Polygon& polygon,
                            const QVector<Path>& locations) noexcept;
  DrcMsgCopperInKeepoutZone(const Data::Zone& zone,
                            const Data::Device* zoneDevice,
                            const Data::Device& device,
                            const Data::Polygon& polygon,
                            const QVector<Path>& locations) noexcept;
  DrcMsgCopperInKeepoutZone(const Data::Zone& zone,
                            const Data::Device* zoneDevice,
                            const Data::Device& device,
                            const Data::Circle& circle,
                            const QVector<Path>& locations) noexcept;
  DrcMsgCopperInKeepoutZone(const DrcMsgCopperInKeepoutZone& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgCopperInKeepoutZone(const DrcMsgCopperInKeepoutZone& other) noexcept {…}
  virtual ~DrcMsgCopperInKeepoutZone() noexcept {}
 
private:
  void addZoneApprovalNodes(const Data::Zone& zone,
                            const Data::Device* zoneDevice) noexcept;
  static QString getDescription() noexcept;
};
class DrcMsgCopperInKeepoutZone final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgDrillDrillClearanceViolation
 ******************************************************************************/
 
class DrcMsgDrillDrillClearanceViolation final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgDrillDrillClearanceViolation)
 
public:
  // Constructors / Destructor
  DrcMsgDrillDrillClearanceViolation() = delete;
  DrcMsgDrillDrillClearanceViolation(const DrcHoleRef& hole1,
                                     const DrcHoleRef& hole2,
                                     const UnsignedLength& minClearance,
                                     const QVector<Path>& locations);
  DrcMsgDrillDrillClearanceViolation(
      const DrcMsgDrillDrillClearanceViolation& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgDrillDrillClearanceViolation( {…}
  virtual ~DrcMsgDrillDrillClearanceViolation() noexcept {}
};
class DrcMsgDrillDrillClearanceViolation final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgDrillBoardClearanceViolation
 ******************************************************************************/
 
class DrcMsgDrillBoardClearanceViolation final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgDrillBoardClearanceViolation)
 
public:
  // Constructors / Destructor
  DrcMsgDrillBoardClearanceViolation() = delete;
  DrcMsgDrillBoardClearanceViolation(const DrcHoleRef& hole,
                                     const UnsignedLength& minClearance,
                                     const QVector<Path>& locations) noexcept;
  DrcMsgDrillBoardClearanceViolation(
      const DrcMsgDrillBoardClearanceViolation& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgDrillBoardClearanceViolation( {…}
  virtual ~DrcMsgDrillBoardClearanceViolation() noexcept {}
};
class DrcMsgDrillBoardClearanceViolation final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgDeviceInCourtyard
 ******************************************************************************/
 
class DrcMsgDeviceInCourtyard final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgDeviceInCourtyard)
 
public:
  using Data = BoardDesignRuleCheckData;
 
  // Constructors / Destructor
  DrcMsgDeviceInCourtyard() = delete;
  DrcMsgDeviceInCourtyard(const Data::Device& device1,
                          const Data::Device& device2,
                          const QVector<Path>& locations) noexcept;
  DrcMsgDeviceInCourtyard(const DrcMsgDeviceInCourtyard& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgDeviceInCourtyard(const DrcMsgDeviceInCourtyard& other) noexcept {…}
  virtual ~DrcMsgDeviceInCourtyard() noexcept {}
};
class DrcMsgDeviceInCourtyard final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgOverlappingDevices
 ******************************************************************************/
 
class DrcMsgOverlappingDevices final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgOverlappingDevices)
 
public:
  using Data = BoardDesignRuleCheckData;
 
  // Constructors / Destructor
  DrcMsgOverlappingDevices() = delete;
  DrcMsgOverlappingDevices(const Data::Device& device1,
                           const Data::Device& device2,
                           const QVector<Path>& locations) noexcept;
  DrcMsgOverlappingDevices(const DrcMsgOverlappingDevices& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgOverlappingDevices(const DrcMsgOverlappingDevices& other) noexcept {…}
  virtual ~DrcMsgOverlappingDevices() noexcept {}
};
class DrcMsgOverlappingDevices final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgDeviceInKeepoutZone
 ******************************************************************************/
 
class DrcMsgDeviceInKeepoutZone final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgDeviceInKeepoutZone)
 
public:
  using Data = BoardDesignRuleCheckData;
 
  // Constructors / Destructor
  DrcMsgDeviceInKeepoutZone() = delete;
  DrcMsgDeviceInKeepoutZone(const Data::Zone& zone,
                            const Data::Device* zoneDevice,
                            const Data::Device& device,
                            const QVector<Path>& locations) noexcept;
  DrcMsgDeviceInKeepoutZone(const DrcMsgDeviceInKeepoutZone& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgDeviceInKeepoutZone(const DrcMsgDeviceInKeepoutZone& other) noexcept {…}
  virtual ~DrcMsgDeviceInKeepoutZone() noexcept {}
 
private:
  void addZoneApprovalNodes(const Data::Zone& zone,
                            const Data::Device* zoneDevice) noexcept;
  static QString getDescription() noexcept;
};
class DrcMsgDeviceInKeepoutZone final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgExposureInKeepoutZone
 ******************************************************************************/
 
class DrcMsgExposureInKeepoutZone final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgExposureInKeepoutZone)
 
public:
  using Data = BoardDesignRuleCheckData;
 
  // Constructors / Destructor
  DrcMsgExposureInKeepoutZone() = delete;
  DrcMsgExposureInKeepoutZone(const Data::Zone& zone,
                              const Data::Device* zoneDevice,
                              const Data::Device& device, const Data::Pad& pad,
                              const QVector<Path>& locations) noexcept;
  DrcMsgExposureInKeepoutZone(const Data::Zone& zone,
                              const Data::Device* zoneDevice,
                              const Data::Segment& ns, const Data::Via& via,
                              const QVector<Path>& locations) noexcept;
  DrcMsgExposureInKeepoutZone(const Data::Zone& zone,
                              const Data::Device* zoneDevice,
                              const Data::Polygon& polygon,
                              const QVector<Path>& locations) noexcept;
  DrcMsgExposureInKeepoutZone(const Data::Zone& zone,
                              const Data::Device* zoneDevice,
                              const Data::Device& device,
                              const Data::Polygon& polygon,
                              const QVector<Path>& locations) noexcept;
  DrcMsgExposureInKeepoutZone(const Data::Zone& zone,
                              const Data::Device* zoneDevice,
                              const Data::Device& device,
                              const Data::Circle& circle,
                              const QVector<Path>& locations) noexcept;
  DrcMsgExposureInKeepoutZone(const DrcMsgExposureInKeepoutZone& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgExposureInKeepoutZone(const DrcMsgExposureInKeepoutZone& other) noexcept {…}
  virtual ~DrcMsgExposureInKeepoutZone() noexcept {}
 
private:
  void addZoneApprovalNodes(const Data::Zone& zone,
                            const Data::Device* zoneDevice) noexcept;
  static QString getDescription() noexcept;
};
class DrcMsgExposureInKeepoutZone final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgMinimumAnnularRingViolation
 ******************************************************************************/
 
class DrcMsgMinimumAnnularRingViolation final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgMinimumAnnularRingViolation)
 
public:
  using Data = BoardDesignRuleCheckData;
 
  // Constructors / Destructor
  DrcMsgMinimumAnnularRingViolation() = delete;
  DrcMsgMinimumAnnularRingViolation(const Data::Segment& ns,
                                    const Data::Via& via,
                                    const UnsignedLength& minAnnularWidth,
                                    const QVector<Path>& locations) noexcept;
  DrcMsgMinimumAnnularRingViolation(const Data::Device& device,
                                    const Data::Pad& pad,
                                    const UnsignedLength& minAnnularWidth,
                                    const QVector<Path>& locations) noexcept;
  DrcMsgMinimumAnnularRingViolation(
      const DrcMsgMinimumAnnularRingViolation& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgMinimumAnnularRingViolation( {…}
  virtual ~DrcMsgMinimumAnnularRingViolation() noexcept {}
};
class DrcMsgMinimumAnnularRingViolation final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgMinimumDrillDiameterViolation
 ******************************************************************************/
 
class DrcMsgMinimumDrillDiameterViolation final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgMinimumDrillDiameterViolation)
 
public:
  // Constructors / Destructor
  DrcMsgMinimumDrillDiameterViolation() = delete;
  DrcMsgMinimumDrillDiameterViolation(const DrcHoleRef& hole,
                                      const UnsignedLength& minDiameter,
                                      const QVector<Path>& locations) noexcept;
  DrcMsgMinimumDrillDiameterViolation(
      const DrcMsgMinimumDrillDiameterViolation& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgMinimumDrillDiameterViolation( {…}
  virtual ~DrcMsgMinimumDrillDiameterViolation() noexcept {}
 
private:
  static QString determineMessage(const DrcHoleRef& hole,
                                  const UnsignedLength& minDiameter) noexcept;
  static QString determineDescription(const DrcHoleRef& hole) noexcept;
};
class DrcMsgMinimumDrillDiameterViolation final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgMinimumSlotWidthViolation
 ******************************************************************************/
 
class DrcMsgMinimumSlotWidthViolation final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgMinimumSlotWidthViolation)
 
public:
  // Constructors / Destructor
  DrcMsgMinimumSlotWidthViolation() = delete;
  DrcMsgMinimumSlotWidthViolation(const DrcHoleRef& hole,
                                  const UnsignedLength& minWidth,
                                  const QVector<Path>& locations) noexcept;
  DrcMsgMinimumSlotWidthViolation(
      const DrcMsgMinimumSlotWidthViolation& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgMinimumSlotWidthViolation( {…}
  virtual ~DrcMsgMinimumSlotWidthViolation() noexcept {}
 
private:
  static QString determineMessage(bool plated,
                                  const PositiveLength& actualWidth,
                                  const UnsignedLength& minWidth) noexcept;
  static QString determineDescription(bool plated) noexcept;
};
class DrcMsgMinimumSlotWidthViolation final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgInvalidPadConnection
 ******************************************************************************/
 
class DrcMsgInvalidPadConnection final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgInvalidPadConnection)
 
public:
  using Data = BoardDesignRuleCheckData;
 
  // Constructors / Destructor
  DrcMsgInvalidPadConnection() = delete;
  DrcMsgInvalidPadConnection(const Data::Device& device, const Data::Pad& pad,
                             const Layer& layer,
                             const QVector<Path>& locations) noexcept;
  DrcMsgInvalidPadConnection(const DrcMsgInvalidPadConnection& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgInvalidPadConnection(const DrcMsgInvalidPadConnection& other) noexcept {…}
  virtual ~DrcMsgInvalidPadConnection() noexcept {}
};
class DrcMsgInvalidPadConnection final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgForbiddenSlot
 ******************************************************************************/
 
class DrcMsgForbiddenSlot final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgForbiddenSlot)
 
public:
  using Data = BoardDesignRuleCheckData;
 
  // Constructors / Destructor
  DrcMsgForbiddenSlot() = delete;
  DrcMsgForbiddenSlot(const Data::Hole& hole, const Data::Device* device,
                      const Data::Pad* pad,
                      const QVector<Path>& locations) noexcept;
  DrcMsgForbiddenSlot(const DrcMsgForbiddenSlot& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgForbiddenSlot(const DrcMsgForbiddenSlot& other) noexcept {…}
  virtual ~DrcMsgForbiddenSlot() noexcept {}
 
private:
  static QString determineMessage(const NonEmptyPath& path) noexcept;
  static QString determineDescription(const NonEmptyPath& path) noexcept;
};
class DrcMsgForbiddenSlot final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgForbiddenVia
 ******************************************************************************/
 
class DrcMsgForbiddenVia final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgForbiddenVia)
 
public:
  using Data = BoardDesignRuleCheckData;
 
  // Constructors / Destructor
  DrcMsgForbiddenVia() = delete;
  DrcMsgForbiddenVia(const Data::Segment& ns, const Data::Via& via,
                     const QVector<Path>& locations) noexcept;
  DrcMsgForbiddenVia(const DrcMsgForbiddenVia& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgForbiddenVia(const DrcMsgForbiddenVia& other) noexcept {…}
  virtual ~DrcMsgForbiddenVia() noexcept {}
 
private:
  static QString determineMessage(const Data::Segment& ns,
                                  const Data::Via& via) noexcept;
  static QString determineDescription(const Data::Via& via) noexcept;
};
class DrcMsgForbiddenVia final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgInvalidVia
 ******************************************************************************/
 
class DrcMsgInvalidVia final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgInvalidVia)
 
public:
  using Data = BoardDesignRuleCheckData;
 
  // Constructors / Destructor
  DrcMsgInvalidVia() = delete;
  DrcMsgInvalidVia(const Data::Segment& ns, const Data::Via& via,
                   const QVector<Path>& locations) noexcept;
  DrcMsgInvalidVia(const DrcMsgInvalidVia& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgInvalidVia(const DrcMsgInvalidVia& other) noexcept {…}
  virtual ~DrcMsgInvalidVia() noexcept {}
};
class DrcMsgInvalidVia final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgSilkscreenClearanceViolation
 ******************************************************************************/
 
class DrcMsgSilkscreenClearanceViolation final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgSilkscreenClearanceViolation)
 
public:
  using Data = BoardDesignRuleCheckData;
 
  // Constructors / Destructor
  DrcMsgSilkscreenClearanceViolation() = delete;
  DrcMsgSilkscreenClearanceViolation(const Data::StrokeText& st,
                                     const Data::Device* device,
                                     const UnsignedLength& minClearance,
                                     const QVector<Path>& locations) noexcept;
  DrcMsgSilkscreenClearanceViolation(
      const DrcMsgSilkscreenClearanceViolation& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgSilkscreenClearanceViolation( {…}
  virtual ~DrcMsgSilkscreenClearanceViolation() noexcept {}
};
class DrcMsgSilkscreenClearanceViolation final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgUselessZone
 ******************************************************************************/
 
class DrcMsgUselessZone final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgUselessZone)
 
public:
  using Data = BoardDesignRuleCheckData;
 
  // Constructors / Destructor
  DrcMsgUselessZone() = delete;
  DrcMsgUselessZone(const Data::Zone& zone,
                    const QVector<Path>& locations) noexcept;
  DrcMsgUselessZone(const DrcMsgUselessZone& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgUselessZone(const DrcMsgUselessZone& other) noexcept {…}
  virtual ~DrcMsgUselessZone() noexcept {}
};
class DrcMsgUselessZone final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgUselessVia
 ******************************************************************************/
 
class DrcMsgUselessVia final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgUselessVia)
 
public:
  using Data = BoardDesignRuleCheckData;
 
  // Constructors / Destructor
  DrcMsgUselessVia() = delete;
  DrcMsgUselessVia(const Data::Segment& ns, const Data::Via& via,
                   const QVector<Path>& locations) noexcept;
  DrcMsgUselessVia(const DrcMsgUselessVia& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgUselessVia(const DrcMsgUselessVia& other) noexcept {…}
  virtual ~DrcMsgUselessVia() noexcept {}
};
class DrcMsgUselessVia final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgDisabledLayer
 ******************************************************************************/
 
class DrcMsgDisabledLayer final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgDisabledLayer)
 
public:
  // Constructors / Destructor
  DrcMsgDisabledLayer() = delete;
  explicit DrcMsgDisabledLayer(const Layer& layer) noexcept;
  DrcMsgDisabledLayer(const DrcMsgDisabledLayer& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgDisabledLayer(const DrcMsgDisabledLayer& other) noexcept {…}
  virtual ~DrcMsgDisabledLayer() noexcept {}
};
class DrcMsgDisabledLayer final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  Class DrcMsgUnusedLayer
 ******************************************************************************/
 
class DrcMsgUnusedLayer final : public RuleCheckMessage {
  Q_DECLARE_TR_FUNCTIONS(DrcMsgUnusedLayer)
 
public:
  // Constructors / Destructor
  DrcMsgUnusedLayer() = delete;
  explicit DrcMsgUnusedLayer(const Layer& layer) noexcept;
  DrcMsgUnusedLayer(const DrcMsgUnusedLayer& other) noexcept
    : RuleCheckMessage(other) {}
  DrcMsgUnusedLayer(const DrcMsgUnusedLayer& other) noexcept {…}
  virtual ~DrcMsgUnusedLayer() noexcept {}
};
class DrcMsgUnusedLayer final : public RuleCheckMessage {…};
 
/*******************************************************************************
 *  End of File
 ******************************************************************************/
 
}  // namespace librepcb
 
#endif