Gateway_MassLimitationBuilder.hxx

//--------------------------------------------------------------------------
// Copyright 2024 Siemens
//--------------------------------------------------------------------------
// C++接口到JA API的头文件
//--------------------------------------------------------------------------
//
// 源文件:
//     Gateway_MassLimitationBuilder.ja
//
// 生成方式:
//     apiwrap
//
// 警告:
//    此文件由自动生成 - 请勿手动编辑
//
#pragma once
#include <NXOpen/NXDeprecation.hxx>
#include <vector>
#include <NXOpen/NXString.hxx>
#include <NXOpen/Callback.hxx>
#include <NXOpen/Expression.hxx>
#include <NXOpen/Builder.hxx>
#include <NXOpen/SelectObjectList.hxx>
#include <NXOpen/libnxopencpp_gateway_exports.hxx>
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4996)
#endif
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
namespace NXOpen
{
    namespace Gateway
    {
        class MassLimitationBuilder;
    }
    class Builder;
    class Expression;
    class SelectNXObjectList;
    namespace Gateway
    {
        class _MassLimitationBuilderBuilder;
        class MassLimitationBuilderImpl;
        class NXOPENCPP_GATEWAYEXPORT  MassLimitationBuilder : public NXOpen::Builder
        {
            private: MassLimitationBuilderImpl * m_masslimitationbuilder_impl;
            private: friend class  _MassLimitationBuilderBuilder;
            protected: MassLimitationBuilder();
            public: ~MassLimitationBuilder();

            public: NXOpen::SelectNXObjectList * Objects
            (
            );

            public: bool MaximumMassStatus
            (
            );

            public: void SetMaximumMassStatus
            (
                bool massLimitStatus 
            );

            public: NXOpen::Expression * MaximumMass
            (
            );

            public: bool MinimumMassStatus
            (
            );

            public: void SetMinimumMassStatus
            (
                bool massLimitStatus 
            );

            public: NXOpen::Expression * MinimumMass
            (
            );

            public: bool MaximumDensityStatus
            (
            );

            public: void SetMaximumDensityStatus
            (
                bool densityLimitStatus 
            );

            public: NXOpen::Expression * MaximumDensity
            (
            );

            public: bool MinimumDensityStatus
            (
            );

            public: void SetMinimumDensityStatus
            (
                bool densityLimitStatus 
            );

            public: NXOpen::Expression * MinimumDensity
            (
            );

            public: bool MaximumVolumeStatus
            (
            );

            public: void SetMaximumVolumeStatus
            (
                bool volumeLimitStatus 
            );

            public: NXOpen::Expression * MaximumVolume
            (
            );

            public: bool MinimumVolumeStatus
            (
            );

            public: void SetMinimumVolumeStatus
            (
                bool volumeLimitStatus 
            );

            public: NXOpen::Expression * MinimumVolume
            (
            );

            public: bool MaximumAreaStatus
            (
            );

            public: void SetMaximumAreaStatus
            (
                bool areaLimitStatus 
            );

            public: NXOpen::Expression * MaximumArea
            (
            );

            public: bool MinimumAreaStatus
            (
            );

            public: void SetMinimumAreaStatus
            (
                bool areaLimitStatus 
            );

            public: NXOpen::Expression * MinimumArea
            (
            );

            public: bool MaximumGravityCenterStatusX
            (
            );

            public: void SetMaximumGravityCenterStatusX
            (
                bool gravityCenterLimitStatus 
            );

            public: NXOpen::Expression * MaximumGravityCenterX
            (
            );

            public: bool MinimumGravityCenterStatusX
            (
            );

            public: void SetMinimumGravityCenterStatusX
            (
                bool gravityCenterLimitStatus 
            );

            public: NXOpen::Expression * MinimumGravityCenterX
            (
            );

            public: bool MaximumGravityCenterStatusY
            (
            );

            public: void SetMaximumGravityCenterStatusY
            (
                bool gravityCenterLimitStatus 
            );

            public: NXOpen::Expression * MaximumGravityCenterY
            (
            );

            public: bool MinimumGravityCenterStatusY
            (
            );

            public: void SetMinimumGravityCenterStatusY
            (
                bool gravityCenterLimitStatus 
            );

            public: NXOpen::Expression * MinimumGravityCenterY
            (
            );

            public: bool MaximumGravityCenterStatusZ
            (
            );

            public: void SetMaximumGravityCenterStatusZ
            (
                bool gravityCenterLimitStatus 
            );

            public: NXOpen::Expression * MaximumGravityCenterZ
            (
            );

            public: bool MinimumGravityCenterStatusZ
            (
            );

            public: void SetMinimumGravityCenterStatusZ
            (
                bool gravityCenterLimitStatus 
            );

            public: NXOpen::Expression * MinimumGravityCenterZ
            (
            );

            public: bool MaximumMomentsInertiaStatusXX
            (
            );

            public: void SetMaximumMomentsInertiaStatusXX
            (
                bool inertiaLimitStatus 
            );

            public: NXOpen::Expression * MaximumMomentsInertiaXX
            (
            );

            public: bool MinimumMomentsInertiaStatusXX
            (
            );

            public: void SetMinimumMomentsInertiaStatusXX
            (
                bool inertiaLimitStatus 
            );

            public: NXOpen::Expression * MinimumMomentsInertiaXX
            (
            );

            public: bool MaximumMomentsInertiaStatusYY
            (
            );

            public: void SetMaximumMomentsInertiaStatusYY
            (
                bool inertiaLimitStatus 
            );

            public: NXOpen::Expression * MaximumMomentsInertiaYY
            (
            );

            public: bool MinimumMomentsInertiaStatusYY
            (
            );

            public: void SetMinimumMomentsInertiaStatusYY
            (
                bool inertiaLimitStatus 
            );

            public: NXOpen::Expression * MinimumMomentsInertiaYY
            (
            );

            public: bool MaximumMomentsInertiaStatusZZ
            (
            );

            public: void SetMaximumMomentsInertiaStatusZZ
            (
                bool inertiaLimitStatus 
            );

            public: NXOpen::Expression * MaximumMomentsInertiaZZ
            (
            );

            public: bool MinimumMomentsInertiaStatusZZ
            (
            );

            public: void SetMinimumMomentsInertiaStatusZZ
            (
                bool inertiaLimitStatus 
            );

            public: NXOpen::Expression * MinimumMomentsInertiaZZ
            (
            );

            public: bool MaximumProductsInertiaStatusXY
            (
            );

            public: void SetMaximumProductsInertiaStatusXY
            (
                bool inertiaLimitStatus 
            );

            public: NXOpen::Expression * MaximumProductsInertiaXY
            (
            );

            public: bool MinimumProductsInertiaStatusXY
            (
            );

            public: void SetMinimumProductsInertiaStatusXY
            (
                bool inertiaLimitStatus 
            );

            public: NXOpen::Expression * MinimumProductsInertiaXY
            (
            );

            public: bool MaximumProductsInertiaStatusXZ
            (
            );

            public: void SetMaximumProductsInertiaStatusXZ
            (
                bool inertiaLimitStatus 
            );

            public: NXOpen::Expression * MaximumProductsInertiaXZ
            (
            );

            public: bool MinimumProductsInertiaStatusXZ
            (
            );

            public: void SetMinimumProductsInertiaStatusXZ
            (
                bool inertiaLimitStatus 
            );

            public: NXOpen::Expression * MinimumProductsInertiaXZ
            (
            );

            public: bool MaximumProductsInertiaStatusYZ
            (
            );

            public: void SetMaximumProductsInertiaStatusYZ
            (
                bool inertiaLimitStatus 
            );

            public: NXOpen::Expression * MaximumProductsInertiaYZ
            (
            );

            public: bool MinimumProductsInertiaStatusYZ
            (
            );

            public: void SetMinimumProductsInertiaStatusYZ
            (
                bool inertiaLimitStatus 
            );

            public: NXOpen::Expression * MinimumProductsInertiaYZ
            (
            );

            public: void GetLimitationValues
            (
            );
        };
    }
}
#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