EIC code displayed by LXR master/​include/​opencascade/​Units_Token.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-10-02 09:14:27

 // Created on: 1992-06-22
 // Created by: Gilles DEBARBOUILLE
 // Copyright (c) 1992-1999 Matra Datavision
 // Copyright (c) 1999-2014 OPEN CASCADE SAS
 //
 // This file is part of Open CASCADE Technology software library.
 //
 // This library is free software; you can redistribute it and/or modify it under
 // the terms of the GNU Lesser General Public License version 2.1 as published
 // by the Free Software Foundation, with special exception defined in the file
 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
 // distribution for complete text of the license and disclaimer of any warranty.
 //
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
 #ifndef _Units_Token_HeaderFile
 #define _Units_Token_HeaderFile
 
 #include <Standard.hxx>
 #include <Standard_Type.hxx>
 
 #include <TCollection_AsciiString.hxx>
 #include <Standard_Transient.hxx>
 #include <Standard_Integer.hxx>
 class Units_Dimensions;
 
 //! This class defines an elementary word contained in
 //! a Sentence object.
 class Units_Token : public Standard_Transient
 {
 
 public:
   //! Creates and returns a empty token.
   Standard_EXPORT Units_Token();
 
   //! Creates and returns a token. <aword> is a string
   //! containing the available word.
   Standard_EXPORT Units_Token(const char* const aword);
 
   //! Creates and returns a token. <atoken> is copied in
   //! the returned token.
   Standard_EXPORT Units_Token(const occ::handle<Units_Token>& atoken);
 
   //! Creates and returns a token. <aword> is a string
   //! containing the available word and <amean> gives the
   //! signification of the token.
   Standard_EXPORT Units_Token(const char* const aword, const char* const amean);
 
   //! Creates and returns a token. <aword> is a string
   //! containing the available word, <amean> gives the
   //! signification of the token and <avalue> is the numeric
   //! value of the dimension.
   Standard_EXPORT Units_Token(const char* const aword,
                               const char* const amean,
                               const double      avalue);
 
   //! Creates and returns a token. <aword> is a string
   //! containing the available word, <amean> gives the
   //! signification of the token, <avalue> is the numeric
   //! value of the dimension, and <adimensions> is the
   //! dimension of the given word <aword>.
   Standard_EXPORT Units_Token(const char* const                    aword,
                               const char* const                    amean,
                               const double                         avalue,
                               const occ::handle<Units_Dimensions>& adimension);
 
   //! Creates and returns a token, which is a ShiftedToken.
   Standard_EXPORT virtual occ::handle<Units_Token> Creates() const;
 
   //! Returns the length of the word.
   Standard_EXPORT int Length() const;
 
   //! Returns the string <theword>
   TCollection_AsciiString Word() const;
 
   //! Sets the field <theword> to <aword>.
   void Word(const char* const aword);
 
   //! Returns the significance of the word <theword>, which
   //! is in the field <themean>.
   TCollection_AsciiString Mean() const;
 
   //! Sets the field <themean> to <amean>.
   void Mean(const char* const amean);
 
   //! Returns the value stored in the field <thevalue>.
   double Value() const;
 
   //! Sets the field <thevalue> to <avalue>.
   void Value(const double avalue);
 
   //! Returns the dimensions of the token <thedimensions>.
   occ::handle<Units_Dimensions> Dimensions() const;
 
   //! Sets the field <thedimensions> to <adimensions>.
   Standard_EXPORT void Dimensions(const occ::handle<Units_Dimensions>& adimensions);
 
   //! Updates the token <me> with the additional
   //! signification <amean> by concatenation of the two
   //! strings <themean> and <amean>. If the two
   //! significations are the same, an information message
   //! is written in the output device.
   Standard_EXPORT void Update(const char* const amean);
 
   Standard_EXPORT occ::handle<Units_Token> Add(const int aninteger) const;
 
   //! Returns a token which is the addition of <me> and
   //! another token <atoken>. The addition is possible if
   //! and only if the dimensions are the same.
   Standard_EXPORT occ::handle<Units_Token> Add(const occ::handle<Units_Token>& atoken) const;
 
   //! Returns a token which is the subtraction of <me> and
   //! another token <atoken>. The subtraction is possible if
   //! and only if the dimensions are the same.
   Standard_EXPORT occ::handle<Units_Token> Subtract(const occ::handle<Units_Token>& atoken) const;
 
   //! Returns a token which is the product of <me> and
   //! another token <atoken>.
   Standard_EXPORT occ::handle<Units_Token> Multiply(const occ::handle<Units_Token>& atoken) const;
 
   //! This virtual method is called by the Measurement
   //! methods, to compute the measurement during a
   //! conversion.
   [[nodiscard]] Standard_EXPORT virtual double Multiplied(const double avalue) const;
 
   //! Returns a token which is the division of <me> by another
   //! token <atoken>.
   Standard_EXPORT occ::handle<Units_Token> Divide(const occ::handle<Units_Token>& atoken) const;
 
   //! This virtual method is called by the Measurement
   //! methods, to compute the measurement during a
   //! conversion.
   [[nodiscard]] Standard_EXPORT virtual double Divided(const double avalue) const;
 
   //! Returns a token which is <me> to the power of another
   //! token <atoken>. The computation is possible only if
   //! <atoken> is a dimensionless constant.
   Standard_EXPORT occ::handle<Units_Token> Power(const occ::handle<Units_Token>& atoken) const;
 
   //! Returns a token which is <me> to the power of <anexponent>.
   Standard_EXPORT occ::handle<Units_Token> Power(const double anexponent) const;
 
   //! Returns true if the field <theword> and the string
   //! <astring> are the same, false otherwise.
   Standard_EXPORT bool IsEqual(const char* const astring) const;
 
   //! Returns true if the field <theword> and the string
   //! <theword> contained in the token <atoken> are the
   //! same, false otherwise.
   Standard_EXPORT bool IsEqual(const occ::handle<Units_Token>& atoken) const;
 
   //! Returns false if the field <theword> and the string
   //! <astring> are the same, true otherwise.
   bool IsNotEqual(const char* const astring) const;
 
   //! Returns false if the field <theword> and the string
   //! <theword> contained in the token <atoken> are the
   //! same, true otherwise.
   bool IsNotEqual(const occ::handle<Units_Token>& atoken) const;
 
   //! Returns true if the field <theword> is strictly
   //! contained at the beginning of the string <astring>,
   //! false otherwise.
   bool IsLessOrEqual(const char* const astring) const;
 
   //! Returns false if the field <theword> is strictly
   //! contained at the beginning of the string <astring>,
   //! true otherwise.
   bool IsGreater(const char* const astring) const;
 
   //! Returns false if the field <theword> is strictly
   //! contained at the beginning of the string <astring>,
   //! true otherwise.
   bool IsGreater(const occ::handle<Units_Token>& atoken) const;
 
   //! Returns true if the string <astring> is strictly
   //! contained at the beginning of the field <theword>
   //! false otherwise.
   bool IsGreaterOrEqual(const occ::handle<Units_Token>& atoken) const;
 
   //! Useful for debugging
   Standard_EXPORT virtual void Dump(const int ashift, const int alevel) const;
 
   DEFINE_STANDARD_RTTIEXT(Units_Token, Standard_Transient)
 
 private:
   TCollection_AsciiString       theword;
   TCollection_AsciiString       themean;
   double                        thevalue;
   occ::handle<Units_Dimensions> thedimensions;
 };
 
 #include <Units_Token.lxx>
 
 #endif // _Units_Token_HeaderFile

This page was automatically generated by the 2.3.7 LXR engine. The LXR team