RuleManager.hxx

//--------------------------------------------------------------------------
// Copyright 2024 Siemens
//--------------------------------------------------------------------------
//  C++ 接口的 JA API 头文件
//--------------------------------------------------------------------------
//
//  源文件:
//     RuleManager.ja
//
//  生成方式:
//     apiwrap
//
//  警告:
//    此文件为自动生成 - 请勿手动编辑
//
#pragma once
#include <NXOpen/NXDeprecation.hxx>
#include <vector>
#include <NXOpen/NXString.hxx>
#include <NXOpen/Callback.hxx>
#include <NXOpen/Session.hxx>
#include <NXOpen/TaggedObject.hxx>
#include <NXOpen/libnxopencpp_exports.hxx>
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4996)
#endif
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
namespace NXOpen
{
    class RuleManager;
    class BasePart;
    class NXObject;
    class RuleManagerImpl;
    class NXOPENCPPEXPORT  RuleManager
    {
        public: enum RuleType
        {
            RuleTypeBoolean ,
            RuleTypeFrame ,
            RuleTypeInteger ,
            RuleTypeList ,
            RuleTypeName ,
            RuleTypeNumber ,
            RuleTypePoint ,
            RuleTypeString ,
            RuleTypeVector ,
            RuleTypeInstance ,
            RuleTypeAny ,
            RuleTypeHostPointer
        };

        public:
        struct ParameterRule
        {
            public: NXString Name;
            public: NXString Rule;
            public: ParameterRule() :
                Name(),
                Rule()
            {
            }
            public: ParameterRule(const NXString &nameInitial ,
                    const NXString &ruleInitial ) :
                Name(nameInitial),
                Rule(ruleInitial)
            {
            }
        };

        public:
        struct FunctionInformation
        {
            public: NXString ReturnType;
            public: int NumArguments;
            public: NXString BriefDescription;
            public: NXString FullDescription;
            public: NXString ReturnDescription;
            public: bool IsDynamic;
            public: bool DesignLogic;
            public: NXString SeeAlso;
            public: FunctionInformation() :
                ReturnType(),
                NumArguments(),
                BriefDescription(),
                FullDescription(),
                ReturnDescription(),
                IsDynamic(),
                DesignLogic(),
                SeeAlso()
{
            }
            public: FunctionInformation(const NXString &returnTypeInitial ,
                    int numArgumentsInitial ,
                    const NXString &briefDescriptionInitial ,
                    const NXString &fullDescriptionInitial ,
                    const NXString &returnDescriptionInitial ,
                    bool isDynamicInitial ,
                    bool designLogicInitial ,
                    const NXString &seeAlsoInitial ) :
                ReturnType(returnTypeInitial),
                NumArguments(numArgumentsInitial),
                BriefDescription(briefDescriptionInitial),
                FullDescription(fullDescriptionInitial),
                ReturnDescription(returnDescriptionInitial),
                IsDynamic(isDynamicInitial),
                DesignLogic(designLogicInitial),
                SeeAlso(seeAlsoInitial)
            {
            }
        };

        public:
        struct FunctionArgumentsInformation
        {
            public: NXString ArgumentName;
            public: NXString ArgumentType;
            public: NXString ArgumentStyle;
            public: NXString ArgumentDefault;
            public: NXString ArgumentDimensionality;
            public: NXString ArgumentDescription;
            public: NXString ArgumentSelectionTypes;
            public: FunctionArgumentsInformation() :
                ArgumentName(),
                ArgumentType(),
                ArgumentStyle(),
                ArgumentDefault(),
                ArgumentDimensionality(),
                ArgumentDescription(),
                ArgumentSelectionTypes()
            {
            }
            public: FunctionArgumentsInformation(const NXString &argumentNameInitial ,
                    const NXString &argumentTypeInitial ,
                    const NXString &argumentStyleInitial ,
                    const NXString &argumentDefaultInitial ,
                    const NXString &argumentDimensionalityInitial ,
                    const NXString &argumentDescriptionInitial ,
                    const NXString &argumentSelectionTypesInitial ) :
                ArgumentName(argumentNameInitial),
                ArgumentType(argumentTypeInitial),
                ArgumentStyle(argumentStyleInitial),
                ArgumentDefault(argumentDefaultInitial),
                ArgumentDimensionality(argumentDimensionalityInitial),
                ArgumentDescription(argumentDescriptionInitial),
                ArgumentSelectionTypes(argumentSelectionTypesInitial)
            {
            }
        };

        public:
        struct AdoptableTypes
        {
            public:  int ObjectType;
            public:  int ObjectSubtype;
            public:  int FeatureType;
            public: AdoptableTypes() :
                ObjectType(),
                ObjectSubtype(),
                FeatureType()
            {
            }
            public: AdoptableTypes(int objectTypeInitial  ,
                    int objectSubtypeInitial  ,
                    int featureTypeInitial  ) :
                ObjectType(objectTypeInitial),
                ObjectSubtype(objectSubtypeInitial),
                FeatureType(featureTypeInitial)
            {
            }
        };

        public: enum LicenseType
        {
            LicenseTypeNoLicense ,
            LicenseTypeAuthor ,
            LicenseTypeExecute ,
            LicenseTypePipeline ,
            LicenseTypeKfFeature ,
            LicenseTypeKfInterop ,
            LicenseTypeKfNewGeom ,
            LicenseTypeKfChecking
        };

        public: enum InitializationStatusType
        {
            InitializationStatusTypeSuccess,
            InitializationStatusTypeFailure,
            InitializationStatusTypeUnavailable,
            InitializationStatusTypeUnableToObtainLicense,
            InitializationStatusTypeCloseFailure
        };

        public: enum Filter
        {
            FilterUser,
            FilterSystem,
            FilterBoth,
            FilterUserPlus,
            FilterUserLoaded,
            FilterSystemLoaded,
            FilterBothLoaded,
            FilterUserPlusLoaded
        };

        public:
        struct DebugInstance
        {
            public: NXString PartName;
            public: NXString RefChain;
            public: NXString NhaChain;
            public: int NRules;
            public: int Rules0;
            public: DebugInstance() :
                PartName(),
                RefChain(),
                NhaChain(),
                NRules(),
                Rules0()
{
            }
            public: DebugInstance(const NXString &partNameInitial ,
                    const NXString &refChainInitial ,
                    const NXString &nhaChainInitial ,
                    int nRulesInitial ,
                    int rules0Initial ) :
                PartName(partNameInitial),
                RefChain(refChainInitial),
                NhaChain(nhaChainInitial),
                NRules(nRulesInitial),
                Rules0(rules0Initial)
            {
            }
        };

        public:
        struct DebugRule
        {
            public: NXString Unit;
            public: NXString Name;
            public: NXString Formula;
            public: NXString Type;
            public: NXString Value;
            public: DebugRule() :
                Unit(),
                Name(),
                Formula(),
                Type(),
                Value()
            {
            }
            public: DebugRule(const NXString &unitInitial ,
                    const NXString &nameInitial ,
                    const NXString &formulaInitial ,
                    const NXString &typeInitial ,
                    const NXString &valueInitial ) :
                Unit(unitInitial),
                Name(nameInitial),
                Formula(formulaInitial),
                Type(typeInitial),
                Value(valueInitial)
            {
            }
        };
        private: RuleManagerImpl * m_rulemanager_impl;
        private: NXOpen::BasePart* m_owner;
        public: explicit RuleManager(NXOpen::BasePart *owner);
        public:
        tag_t Tag() const;
        public: ~RuleManager();
        public: NXOpen::RuleManager::InitializationStatusType Initialize
        (
            NXOpen::RuleManager::LicenseType licenseToTake ,
            int* intentStatus 
        );
        public: void CreateDynamicRule
        (
            const NXString & referenceChain ,
            const NXString & ruleName ,
            NXOpen::RuleManager::RuleType ruleType ,
            const NXString & ruleText 
        );
        void CreateDynamicRule
        (
            const char * referenceChain ,
            const char * ruleName ,
            NXOpen::RuleManager::RuleType ruleType ,
            const char * ruleText 
        );
        public: void CreateDynamicRule
        (
            const NXString & referenceChain ,
            const NXString & ruleName ,
            const NXString & behaviors ,
            const NXString & ruleUnits ,
            const NXString & ruleText ,
            const NXString & leadingComment 
        );
        void CreateDynamicRule
        (
            const char * referenceChain ,
            const char * ruleName ,
            const char * behaviors ,
            const char * ruleUnits ,
            const char * ruleText ,
            const char * leadingComment 
        );
        public: void CreateDynamicRule
        (
            const NXString & referenceChain ,
            const NXString & ruleName ,
            const NXString & behaviors ,
            const NXString & ruleText ,
            const NXString & leadingComment 
        );
        void CreateDynamicRule
        (
            const char * referenceChain ,
            const char * ruleName ,
            const char * behaviors ,
            const char * ruleText ,
            const char * leadingComment 
        );
        public: int DoKfUpdate
        (
            NXOpen::Session::UndoMarkId undoMark 
        );
        public: void DeleteDynamicRule
        (
            const NXString & referenceChain ,
            const NXString & ruleName 
        );
        void DeleteDynamicRule
        (
            const char * referenceChain ,
            const char * ruleName 
        );
        public: void CreateChildRule
        (
            const NXString & ruleName ,
            const NXString & className ,
            const std::vector<NXOpen::RuleManager::ParameterRule> & parameters 
        );
        void CreateChildRule
        (
            const char * ruleName ,
            const char * className ,
            const std::vector<NXOpen::RuleManager::ParameterRule> & parameters 
        );
        public: void DeleteChildRule
        (
            const NXString & ruleName 
        );
        void DeleteChildRule
        (
            const char * ruleName 
        );
        public: void RemoveRuleOnly
        (
            const NXString & referenceChain 
        );
        void RemoveRuleOnly
        (
            const char * referenceChain 
        );
        public: bool IsUserClass
        (
            const NXString & className 
        );
        bool IsUserClass
        (
            const char * className 
        );
        public: std::vector<NXString> GetRulesOfClass
        (
            const NXString & className 
        );
        std::vector<NXString> GetRulesOfClass
        (
            const char * className 
        );
        public: std::vector<NXString> GetDynamicRules
        (
            const NXString & childRuleName 
        );
        std::vector<NXString> GetDynamicRules
        (
            const char * childRuleName 
        );
        public: std::vector<NXString> GetSpecifiedParameters
        (
            const NXString & referenceChain 
        );
        std::vector<NXString> GetSpecifiedParameters
        (
            const char * referenceChain 
        );
        public: NXString GetParameterFormula
        (
            const NXString & referenceChain ,
            const NXString & parameterName 
        );
        NXString GetParameterFormula
        (
            const char * referenceChain ,
            const char * parameterName 
        );
        public: void Rename
        (
            const NXString & referenceChain ,
            const NXString & newName 
        );
        void Rename
        (
            const char * referenceChain ,
            const char * newName 
        );
        public: void Copy
        (
            const NXString & oldNameChain ,
            const NXString & oldLeafName ,
            const NXString & newNameChain ,
            const NXString & newLeafName 
        );
        void Copy
        (
            const char * oldNameChain ,
            const char * oldLeafName ,
            const char * newNameChain ,
            const char * newLeafName 
        );
        public: NXString GetClass
        (
            const NXString & referenceChain 
        );
        NXString GetClass
        (
            const char * referenceChain 
        );
        public: std::vector<NXString> GetClassesOfChildList
        (
            const NXString & referenceChain 
        );
        std::vector<NXString> GetClassesOfChildList
        (
            const char * referenceChain 
        );
        public: std::vector<NXString> GetDependents
        (
            const NXString & referenceChain 
        );
        std::vector<NXString> GetDependents
        (
            const char * referenceChain 
        );
        public: std::vector<NXString> GetDependencies
        (
            const NXString & referenceChain 
        );
        std::vector<NXString> GetDependencies
        (
            const char * referenceChain 
        );
        public: NXOpen::RuleManager::RuleType GetRuleType
        (
            const NXString & className ,
            const NXString & ruleName 
        );
        NXOpen::RuleManager::RuleType GetRuleType
        (
            const char * className ,
            const char * ruleName 
        );
        public: NXOpen::RuleManager::RuleType GetRuleType
        (
            const NXString & referenceChain 
        );
        NXOpen::RuleManager::RuleType GetRuleType
        (
            const char * referenceChain 
        );
        public: NXOpen::RuleManager::RuleType GetParameterType
        (
            const NXString & referenceChain 
        );
        NXOpen::RuleManager::RuleType GetParameterType
        (
            const char * referenceChain 
        );
        public: bool IsChildRule
        (
            const NXString & className ,
            const NXString & ruleName 
        );
        bool IsChildRule
        (
            const char * className ,
            const char * ruleName 
        );
        public: bool IsChildRule
        (
            const NXString & referenceChain 
        );
        bool IsChildRule
        (
            const char * referenceChain 
        );
        public: bool IsChildList
        (
            const NXString & className ,
            const NXString & ruleName 
        );
        bool IsChildList
        (
            const char * className ,
            const char * ruleName 
        );
        public: bool IsChildList
        (
            const NXString & referenceChain 
        );
        bool IsChildList
        (
            const char * referenceChain 
        );
        public: bool IsUncached
        (
            const NXString & className ,
            const NXString & ruleName 
        );
        bool IsUncached
        (
            const char * className ,
            const char * ruleName 
        );
        public: bool IsUncached
        (
            const NXString & referenceChain 
        );
        bool IsUncached
        (
            const char * referenceChain 
        );
        public: bool IsHidden
        (
            const NXString & className ,
            const NXString & ruleName 
        );
        bool IsHidden
        (
            const char * className ,
            const char * ruleName 
        );
        public: bool IsHidden
        (
            const NXString & referenceChain 
        );
        bool IsHidden
        (
            const char * referenceChain 
        );
        public: bool IsLocal
        (
            const NXString & className ,
            const NXString & ruleName 
        );
        bool IsLocal
        (
            const char * className ,
            const char * ruleName 
        );
        public: bool IsParameter
        (
            const NXString & className ,
            const NXString & ruleName 
        );
        bool IsParameter
        (
            const char * className ,
            const char * ruleName 
        );
        public: bool IsCanonical
        (
            const NXString & className ,
            const NXString & ruleName 
        );
        bool IsCanonical
        (
            const char * className ,
            const char * ruleName 
        );
        public: bool IsModifiable
        (
            const NXString & className ,
            const NXString & ruleName 
        );
        bool IsModifiable
        (
            const char * className ,
            const char * ruleName 
        );
        public: bool IsModifiable
        (
            const NXString & referenceChain 
        );
        bool IsModifiable
        (
            const char * referenceChain 
        );
        public: bool IsMethod
        (
            const NXString & className ,
            const NXString & ruleName 
        );
        bool IsMethod
        (
            const char * className ,
            const char * ruleName 
        );
        public: bool IsMethod
        (
            const NXString & referenceChain 
        );
        bool IsMethod
        (
            const char * referenceChain 
        );
        public: bool IsComputed
        (
            const NXString & referenceChain 
        );
        bool IsComputed
        (
            const char * referenceChain 
        );
        public: void RebuildTrees
        (
        );
        public: bool IsRuleInClass
        (
            const NXString & className ,
            const NXString & ruleName 
        );
        bool IsRuleInClass
        (
            const char * className ,
            const char * ruleName 
        );
        public: NXString GetDefaultFormula
        (
            const NXString & className ,
            const NXString & ruleName 
        );
        NXString GetDefaultFormula
        (
            const char * className ,
            const char * ruleName 
        );
        public: NXString EvaluateAsString
        (
            const NXString & referenceChain 
        );
        NXString EvaluateAsString
        (
            const char * referenceChain 
        );
        public: NXString EvaluateAnyAsString
        (
            const NXString & referenceChain 
        );
        NXString EvaluateAnyAsString
        (
            const char * referenceChain 
        );
        public: NXString GetNameChain
        (
            NXOpen::NXObject * ugObject 
        );
        public: void RegenerateAll
        (
        );
        public: void SyntaxCheck
        (
            const NXString & fileName 
        );
        void SyntaxCheck
        (
            const char * fileName 
        );
        public: std::vector<NXString> GetAncestorClasses
        (
            const NXString & className 
        );
        std::vector<NXString> GetAncestorClasses
        (
            const char * className 
        );
        public: void Reload
        (
            bool refreshUserClassDir 
        );
        public: void ReloadSingleClass
        (
            const NXString & className 
        );
        void ReloadSingleClass
        (
            const char * className 
        );
        public: void ReloadClassesAndFunctions
        (
            std::vector<NXString> & classes ,
            std::vector<NXString> & functions 
        );
        public: std::vector<NXString> GetRuleTypes
        (
        );
        public: std::vector<NXString> GetClasses
        (
            NXOpen::RuleManager::Filter filter 
        );
        public: std::vector<NXString> GetFunctions
        (
            NXOpen::RuleManager::Filter filter ,
            bool doSort 
        );
        public: void RemoveAllRules
        (
        );
        public: NXString ReadDfaFile
        (
            const NXString & fileName 
        );
        NXString ReadDfaFile
        (
            const char * fileName 
        );
        public: void WriteDfaFile
        (
            const NXString & fileName ,
            const NXString & fileString ,
            bool replace 
        );
        void WriteDfaFile
        (
            const char * fileName ,
            const char * fileString ,
            bool replace 
        );
        public: NXString GetClassDfaFile
        (
            const NXString & className 
        );
        NXString GetClassDfaFile
        (
            const char * className 
        );
        public: std::vector<NXString> GetLastError
        (
        );
        public: NXString GetReferenceText
        (
            NXOpen::NXObject * ugObject 
        );
        public: NXString GetObjectText
        (
            NXOpen::NXObject * ugObject 
        );
        public: bool AdoptObjects
        (
            const std::vector<NXOpen::NXObject *> & ugObjects 
        );
        public: std::vector<NXOpen::RuleManager::AdoptableTypes> GetAdoptableTypes
        (
        );
        public: NXString GetRulesForObjects
        (
            const std::vector<NXOpen::NXObject *> & ugObjects 
        );
        public: NXOpen::RuleManager::FunctionInformation GetFunctionInformation
        (
            const NXString & functionName ,
            const NXString & instanceOrClassName ,
            bool isInstance ,
            bool briefOnly 
        );
        NXOpen::RuleManager::FunctionInformation GetFunctionInformation
        (
            const char * functionName ,
            const char * instanceOrClassName ,
            bool isInstance ,
            bool briefOnly 
        );
        public: std::vector<NXOpen::RuleManager::FunctionArgumentsInformation> GetFunctionArgumentsInformation
        (
            const NXString & functionName ,
            const NXString & instanceOrClassName ,
            bool isInstance ,
            bool briefOnly 
        );
        std::vector<NXOpen::RuleManager::FunctionArgumentsInformation> GetFunctionArgumentsInformation
        (
            const char * functionName ,
            const char * instanceOrClassName ,
            bool isInstance ,
            bool briefOnly 
        );
        public: NXString GetFunctionFile
        (
            const NXString & functionName 
        );
        NXString GetFunctionFile
        (
            const char * functionName 
        );
        public: bool IsUserFunction
        (
            const NXString & functionName 
        );
        bool IsUserFunction
        (
            const char * functionName 
        );
        public: bool IsExpressionRule
        (
            const NXString & ruleName 
        );
        bool IsExpressionRule
        (
            const char * ruleName 
        );
        public: NXString GetDynamicRuleText
        (
            const NXString & referenceChain 
        );
        NXString GetDynamicRuleText
        (
            const char * referenceChain 
        );
        public: bool DebugFlag
        (
        );
        public: void SetDebugFlag
        (
            bool debugFlag 
        );
        public: void GetDebugInstances
        (
            std::vector<NXOpen::RuleManager::DebugInstance> & instances ,
            std::vector<NXOpen::RuleManager::DebugRule> & rules 
        );
        public: bool CreateMode
        (
        );
        public: int GetErrorStart
        (
        );
        public: int GetErrorEnd
        (
        );
        public: NXOpen::NXObject * GetObjectOfInstance
        (
            const NXString & nameChain 
        );
        NXOpen::NXObject * GetObjectOfInstance
        (
            const char * nameChain 
        );
    }; //lint !e1712 default constructor not defined for class
}
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#ifdef __GNUC__
#ifndef NX_NO_GCC_DEPRECATION_WARNINGS
#pragma GCC diagnostic warning "-Wdeprecated-declarations"
#endif
#endif
#undef EXPORTLIBRARY