/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////

// This file is generated automatically.

#ifndef _IFC4_IFCRELINTERFERESELEMENTS_AUTO_IMPL_H
#define _IFC4_IFCRELINTERFERESELEMENTS_AUTO_IMPL_H

#include "IfcRelConnectsAutoImpl.h"
#include "IfcElementAutoImpl.h"
#include "IfcConnectionGeometryAutoImpl.h"

#include "TD_PackPush.h"

/** \details
  The namespace contains schema-dependent classes, definitions and sub routines
  for work with IFC4 express schema definitions.
*/
namespace OdIfc4 {

/** \details
  The IfcRelInterferesElements objectified relationship indicates that two elements interfere.
  It is a 1 to 1 relationship, and the concept of two elements interfering 
  physically or logically is described independently of the elements.
  
  The interference can be related to the shape representation of the entities by providing an interference geometry or zone:
  * when the interference is between two physical products, the InterferenceGeometry attribute is used to define the physical interference shape, 
    it can be part of the shape of one of the elements used in the relationship or define the interface between the two shapes using a IfcConnectionGeometry.
  * when the interference is between two spatial objects, the InterferenceSpace attribute is used to define the interference space between the 
    two footprints associated to the spatial objects, expressed by a specific IfcSpatialZone of predefined type IfcSpatialZoneTypeEnum INTERFERENCE.
  
  If the interference geometry and Zone are omitted then the interference is provided as a logical relationship. 
  Under this circumstance, the connection point, curve, surface, or solid has to be recalculated by the receiving application. 
  Both InterferenceGeometry and InterferenceSpace should not be set together.
  
  The RelatingElement and RelatedElement define the two elements in the relationship, that can have different roles. 
  The relation orientation can be required by certain InterferenceType values or InterferenceGeometry calculation, 
  this is done by setting the attribute ImpliedOrder accordingly:
  * ImpliedOrder=TRUE The RelatingElement constitutes the primary element of the interference relationship 
    that is oriented from RelatingElement (source) to RelatedElement (target). 
    If the interference is to be resolved by subtracting the overlapping part, 
    it should be subtracted from the RelatingElement. 
    The net result would be the RelatingElement subtracted by the InterferenceGeometry. 
    This would be the case in interference relationships where the RelatedElement creates a void in the RelatingElement dynamically.
  * ImpliedOrder=FALSE The RelatingElement and RelatedElement have no priority among each other. 
    If the interference is to be resolved then no information about whether the InterferenceGeometry 
    should be subtracted from the RelatingElement or the RelatedElement can be traced. 
    This would be the case for clash detection results.
  * ImpliedOrder=UNKNOWN No information about the priorities is provided.
  
  The InterferenceType property optionally specifies the type of interference between the two elements, two set of default types are provided:
  * Oriented interferences types imply usage of ImpliedOrder set to TRUE 
    and specific choice of RelatingElement and RelatedElement to be meaningful:
      * Crosses: the RelatingElement is crossing the RelatedElement (e.g. Railway crossing a road)
      * PassesThrough: the RelatingElement is passing through the RelatedElement (e.g. a Road passing inside a tunnel)
      * PassesOver: the RelatingElement is passing over the RelatedElement (e.g a bridge passing over a water canal)
      * PassesUnder: the RelatingElement is passing under the RelatedElement (e.g a Tunnel passing under a road)
  * Non oriented interferences types do not imply specific values of ImpliedOrder (but can still be set to detail shape interference calculation)
      * Clash: The RelatingElement and RelatedElement have a spatial or shape-based clash
      * Along: The RelatingElement and RelatedElement have a common frontier/surface

  \changes
  
  * IFC4 changes: 
    * Type of the ImpliedOrder attribute changed from logical to IfcLogical.
    * Type of the RelatedElement attribute changed from IfcElement to IfcInterferenceSelect.
    * Type of the RelatingElement attribute changed from IfcElement to IfcInterferenceSelect.
*/
class IFC4_EXPORT IfcRelInterferesElements : public IfcRelConnects
{
  //DOM-IGNORE-BEGIN
  OD_EXP_DECLARE_MEMBERS(OdIfc4::IfcRelInterferesElements);
  //DOM-IGNORE-END

public:


  //
  // OdDAI early binding accessors
  //


  /** \details
  Returns the value of RelatingElement attribute. 
  This attribute represents one of two elements in the relationship that can have a certain role.
  See class description for more information.
  \returns
  Returns the value of RelatingElement attribute.
  */
  const OdDAIObjectId& getRelatingElement() const;

  /** \details
  Sets the value of RelatingElement attribute.
  This attribute represents one of two elements in the relationship that can have a certain role.
  See class description for more information.
  \param RelatingElement [in] Relating element to set.
  */
  void setRelatingElement(const OdDAIObjectId& RelatingElement);

  /** \details
  Returns the value of RelatedElement attribute.
  This attribute represents one of two elements in the relationship that can have a certain role.
  See class description for more information.
  \returns
  Returns the value of RelatedElement attribute.
  */
  const OdDAIObjectId& getRelatedElement() const;

  /** \details
  Sets the value of RelatedElement attribute.
  This attribute represents one of two elements in the relationship that can have a certain role.
  See class description for more information.
  \param RelatedElement [in] Related element to set.
  */
  void setRelatedElement(const OdDAIObjectId& RelatedElement);

  /** \details
  Returns the value of InterferenceGeometry attribute.
  This attribute represents the geometric shape representation of the interference geometry that is provided 
  in the object coordinate system of the RelatingElement (mandatory) and in the object coordinate system of the RelatedElement (optionally).
  \returns
  Returns the value of InterferenceGeometry attribute.
  */
  const OdDAIObjectId& getInterferenceGeometry() const;

  /** \details
  Sets the value of InterferenceGeometry attribute. 
  This attribute represents the geometric shape representation of the interference geometry that is provided 
  in the object coordinate system of the RelatingElement (mandatory) and in the object coordinate system of the RelatedElement (optionally).
  \param InterferenceGeometry [in] Interference geometry to set.
  */
  void setInterferenceGeometry(const OdDAIObjectId& InterferenceGeometry);

  /** \details
  Returns the value of InterferenceType attribute. 
  This is optional identifier that describes the nature of the interference.
  \returns
  Returns the value of InterferenceType attribute.
  */
  const OdAnsiString& getInterferenceType() const;

  /** \details
  Sets the value of InterferenceType attribute. 
  This is optional identifier that describes the nature of the interference.
  \param InterferenceType [in] Interference type to set.
  */
  void setInterferenceType(const OdAnsiString& InterferenceType);

  /** \details
  Returns the value of ImpliedOrder attribute. 
  This attribute represents logical value indicating if the RelatingElement is considered a source 
  and the RelatedElement a target (giving a formal orientation to the relation). 
  It shall be provided in regards to InterferenceGeometry usage and InterferenceType declaration.
  \returns
  Returns the value of ImpliedOrder attribute.
  */
  OdDAI::Logical getImpliedOrder() const;

  /** \details
  Sets the value of ImpliedOrder attribute. 
  This attribute represents logical value indicating if the RelatingElement is considered a source 
  and the RelatedElement a target (giving a formal orientation to the relation). 
  It shall be provided in regards to InterferenceGeometry usage and InterferenceType declaration.
  \param ImpliedOrder [in] Implied order to set.
  */
  void setImpliedOrder(OdDAI::Logical ImpliedOrder);


public:

  /** \details
  Default constructor for the IfcRelInterferesElements class.
  */
  IfcRelInterferesElements();

  /** \details
  Reads object's data from the specified filer.
  \param rdFiler [in] Pointer to a filer from which to read the data.
  \returns
  A value of OdResult type that contains the result of the method execution.
  */
  virtual OdResult inFields(OdDAI::OdSpfFilerBase* rdFiler) override;

  /** \details
  Writes object's data the the specified filer.
  \param wrFiler [in] Pointer to a filer to which to write the data.
  \returns
  A value of OdResult type that contains the result of the method execution.
  */
  virtual OdResult outFields(OdDAI::OdSpfFilerBase* wrFiler) override;

  /** \details
  Sets the object ID of this instance to inverse attributes of related instances according to schema specification of inverse attributes.
  */
  virtual void setInverseCounterParts() override;

  /** \details
  Returns a type of a class instance.
  \returns
  Pointer to the <exref target="OdDAI__Entity.html">OdDAI::Entity</exref> type that determines an entity definition within a schema.
  */
  virtual OdDAI::Entity* getInstanceType() const override;

  /** \details
  Returns an attribute value for the specified attribute name.
  \param attrName [in] Name of an attribute to query.
  \returns
  OdRxValue object that represents a generic variant type value.
  */
  virtual OdRxValue getAttr(const char * attrName) const override;

  /** \details
  Early-bound version of instances comparison.
  \param pOther [in] Other application instance.
  \param ordering [out] Receives the ordering (comparison) status.
  \returns
  true if comparison was performed, false if method has no implementation, so late-bound version could be applied.
  \remarks
  If the method returns true,
  the ordering parameter can receive one of the following statuses:
  <table>
    Name             Value    Description
    _kLessThan_      -1       This object < Other Object.
    _kEqual_          0       This object = Other Object.
    _kGreaterThan_    1       This object > Other Object.
    _kNotOrderable_   2       This class is not orderable.
  </table>
  */
  virtual bool comparedToEarlyImpl(const OdDAI::ApplicationInstance *pOther, OdRx::Ordering &ordering) const override;

  /** \details
  Resets a value for the specified attribute.
  \param explicitAttrName [in] Explicit name of the attribute to reset.
  */
  virtual void unsetAttr(const char * explicitAttrName) override;

  /** \details
  Checks whether the specified attribute is set.
  \param explicitAttrName [in] Explicit name of the attribute to test.
  \returns
  true if the specified attribute is set, false otherwise.
  */
  virtual bool testAttr(const char * explicitAttrName) const override;

  /** \details
  Sets the specified attribute with a given value.
  \param explicitAttrName [in] Explicit name of the attribute to set.
  \param val [in] Value to set.
  \returns
  true if the value is successfully set for the specified attribute, false otherwise.
  */
  virtual bool putAttr(const char * explicitAttrName, const OdRxValue &val) override;

  /** \details
  Checks whether the specified instance is the object derived from or belongs to this class.
  \param entityType [in] Entity to check.
  \returns
  true if the specified instance is the object derived from or belongs to this class, false otherwise.
  */
  virtual bool isKindOf(OdIfc::OdIfcEntityType entityType) const override;

  /** \details
  Returns the type of this entity.
  \returns
  A value of the <exref target="OdIfc__OdIfcEntityType.html">OdIfc::OdIfcEntityType</exref> type that represents type of this entity.
  */
  virtual OdIfc::OdIfcEntityType type() const override;

  /** \details
  Returns an attribute value for the specified attribute definition.
  \param attrDef [in] Attribute definition to query.
  \returns
  OdRxValue object that represents a generic variant type value.
  */
  virtual OdRxValue getAttr(const OdIfc::OdIfcAttribute attrDef) const override;

  /** \details
  Resets a value for the specified attribute.
  \param explicitAttrDef [in] Explicit definition that represents an attribute to reset.
  */
  virtual void unsetAttr(const OdIfc::OdIfcAttribute explicitAttrDef) override;

  /** \details
  Checks whether the specified attribute is set.
  \param explicitAttrDef [in] Attribute definition to test.
  \returns
  true if the specified attribute is set, false otherwise.
  */
  virtual bool testAttr(const OdIfc::OdIfcAttribute explicitAttrDef) const override;

  /** \details
  Sets the specified attribute with a given value.
  \param explicitAttrDef [in] Explicit attribute definition to set.
  \param val [in] Value to set.
  \returns
  true if the value is successfully set for the specified attribute, false otherwise.
  */
  virtual bool putAttr(const OdIfc::OdIfcAttribute explicitAttrDef, const OdRxValue &val) override;

protected:
  // Fields declaration: 
  OdDAIObjectId m_RelatingElement;   // IfcElement
  OdDAIObjectId m_RelatedElement;   // IfcElement
  OdDAIObjectId m_InterferenceGeometry;   // IfcConnectionGeometry  [optional]
  OdAnsiString m_InterferenceType;   // IfcIdentifier  [optional]
  OdDAI::Logical m_ImpliedOrder;   // LOGICAL
};

/** \details
  A data type that represents a smart pointer to a <exref target="OdIfc4__IfcRelInterferesElements.html">IfcRelInterferesElements</exref> object.
*/
typedef OdSmartPtr<IfcRelInterferesElements> IfcRelInterferesElementsPtr;

} // namespace

#include "TD_PackPop.h"

#endif // _IFC4_IFCRELINTERFERESELEMENTS_AUTO_IMPL_H