第一次提交

zjf

2023-03-06 392b76515f40376b6d36f40a114850ef63650384

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
///////////////////////////////////////////////////////////////////////////////  
// Copyright (C) 2002-2016, 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 Teigha(R) software pursuant to a license  
//   agreement with Open Design Alliance. 
//   Teigha(R) Copyright (C) 2002-2016 by Open Design Alliance.  
//   All rights reserved. 
// 
// By use of this software, its documentation or related materials, you  
// acknowledge and accept the above terms. 
/////////////////////////////////////////////////////////////////////////////// 
 
#ifndef _RXOVERRULE_H 
#define _RXOVERRULE_H 
 
#include "RxObject.h" 
 
#include "TD_PackPush.h" 
class OdRxOverruleIterator; 
 
/** \details 
  This class is an abstract base class for implementation of overrules. An overrule can be registered or unregistered, 
  and overrules can be globally activated or deactivated. Overrules are internally managed by pairs of classes  
  named as "target" and "overrule." The "target" is the class to which the overrule applies. Classes can have multiple  
  overrules registered.  
 
  Library: TD_Db 
  <group OdRx_Classes>  
*/ 
class FIRSTDLL_EXPORT OdRxOverrule : public OdRxObject 
{ 
public: 
  ODRX_DECLARE_MEMBERS(OdRxOverrule); 
 
  /** \details 
    Destructor deletes an instance of this class. 
  */ 
  virtual ~OdRxOverrule(); 
 
  /** \details 
    Determines whether the overrule is applicable and returns True if the overrule can be applied, 
    or False, otherwise. It is a pure virtual method that must be implemented in the derived class. 
 
    \param pOverruledSubject [in]  A raw pointer to an object to be overruled. 
  */ 
  virtual bool isApplicable(const OdRxObject* pOverruledSubject) const = 0; 
 
  /** \details 
    Registers an object for a given class to be overruled. 
    This method returns eOk if successful. 
 
    \param pClass [in]  A raw pointer to the class description object to which the overrule applies. 
    \param pOverrule [in]  A raw pointer to an object to be overruled. 
    \param bAddAtLast [in]  Determines whether the pair should be added in the end of the overrule collection. 
  */ 
  static OdResult addOverrule(OdRxClass* pClass, OdRxOverrule* pOverrule, bool bAddAtLast = false); 
 
  /** \details 
    Unregisters an object for the given class. 
    This method returns eOk if successful. 
 
    \param pClass [in]  A raw pointer to the class description object to which the overrule applies. 
    \param pOverrule [in]  A raw pointer to an object to be overruled. 
  */ 
  static OdResult removeOverrule(OdRxClass* pClass, OdRxOverrule* pOverrule); 
 
  /** \details 
    Enables or disables the overruling mechanism. 
 
    \param bIsOverruling [in]  Determines whether the overruling mechanism is enabled (true) or disabled (false). 
  */ 
  static void setIsOverruling(bool bIsOverruling); 
 
  /** \details 
    Checks whether the overruling mechanism is enabled (true) or disabled (false). 
  */ 
  static bool isOverruling() 
  { 
    return s_bIsOverruling; 
  } 
 
  /** \details 
    Checks whether the specified overrule handles a given object and returns True if the object  
    is to be handled by overrule, or False, otherwise. 
 
    \param pOverruleClass [in]  A raw pointer to the class description object to which the overrule applies. 
    \param pSubject [in]  A raw pointer to an object to be overruled. 
  */ 
  static bool hasOverrule(const OdRxObject* pSubject, OdRxClass* pOverruleClass); 
private: 
  /*!DOM*/ 
  OdRxOverruleIterator* m_pIter; 
  /*!DOM*/ 
  FIRSTDLL_EXPORT_STATIC static bool s_bIsOverruling; 
  /*!DOM*/ 
  friend class OdRxOverruleInternals; 
}; 
 
#include "TD_PackPop.h" 
#endif  // _RXOVERRULE_H