C++ Beagle_StackTraceBeginM函数代码示例

	/*!
	 *  \brief Set the file name where the exception is detected (throwed).
	 *  \param inFileName File name where the exception is detected.
	 */
	inline void setFileName(const std::string& inFileName)
	{
		Beagle_StackTraceBeginM();
		mFileName = inFileName;
		Beagle_StackTraceEndM("void TargetedException::setFileName(const std::string& inFileName)");
	}

	/*!
	 *  \brief Insert an operator in the negative set of the if-then-else operator.
	 *  \param inOperator Operator to insert.
	 *  \warning Insert your operators before the initialization!
	 */
	void insertNegativeOp(Beagle::Operator::Handle inOperator) {
		Beagle_StackTraceBeginM();
		mNegativeOpSet.push_back(inOperator);
		Beagle_StackTraceEndM();
	}

	/*!
	 *  \brief Set parameter value of condition to use.
	 */
	inline void setConditionValue(std::string inValue) {
		Beagle_StackTraceBeginM();
		mConditionValue = inValue;
		Beagle_StackTraceEndM();
	}

 /*!
  *  \brief Validate the fitness.
  */
 inline void setValid() {
     Beagle_StackTraceBeginM();
     mValid = true;
     Beagle_StackTraceEndM();
 }

	/*!
	 *  \brief Return a constant reference to the positive operator set.
	 *  \return Positive operator set constant reference.
	 */
	inline const Beagle::Operator::Bag& getPositiveSet() const {
		Beagle_StackTraceBeginM();
		return mPositiveOpSet;
		Beagle_StackTraceEndM();
	}

	/*!
	 *  \brief Get the wrapped type value.
	 *  \return A constant reference to the wrapped value.
	 */
	inline const T& getWrappedValue() const {
		Beagle_StackTraceBeginM();
		return mWrappedValue;
		Beagle_StackTraceEndM();
	}

 /*!
  *  \brief Return validity of the fitness.
  *  \return True if fitness is valid, false if not.
  */
 inline bool isValid() const {
     Beagle_StackTraceBeginM();
     return mValid;
     Beagle_StackTraceEndM();
 }

/*!
 *  \brief  Test whether an string is not equal to another.
 *  \param  inLeftString  Left string compared.
 *  \param  inRightString Right string compared.
 *  \return True if left string is not equal to the right one, false if it is.
 *  \par Note:
 *    The operator is defined relatively to the function isEqual of Beagle::String.
 */
inline bool operator!=(const Beagle::String& inLeftString, const Beagle::String& inRightString)
{
	Beagle_StackTraceBeginM();
	return ( inLeftString.isEqual(inRightString) == false);
	Beagle_StackTraceEndM("bool operator!=(const String& inLeftString, const String& inRightString)");
}

	/*!	\brief Set the number of threads that OpenMP will use in the parallel sections.
	 *	\param iNumThreads is the number of threads to use.
	 */
	inline virtual void	setNumThreads(unsigned int inNumThreads){
		Beagle_StackTraceBeginM();
		omp_set_num_threads(inNumThreads);
		Beagle_StackTraceEndM("unsigned int OpenMP::setNumThreads(unsigned int)");
	}

	/*!	\brief
	 *	\return
	 */
	inline unsigned int getThreadNum() const{
		Beagle_StackTraceBeginM();
		return omp_get_thread_num();
		Beagle_StackTraceEndM("unsigned int OpenMP::getThreadNum() const");
	}

	/*!	\brief
	 *	\return
	 */
	inline bool	inParallelSection() const{
		Beagle_StackTraceBeginM();
		return (omp_in_parallel()>0)?true:false;
		Beagle_StackTraceEndM("unsigned int OpenMP::inParallelSection() const");
	}

	/*!	\brief Ask OpenMP how many processors are available.
	 *	\return The number of processors on this machine.
	 */
	inline unsigned int getNumProcs() const{
		Beagle_StackTraceBeginM();
		return omp_get_num_procs();
		Beagle_StackTraceEndM("unsigned int OpenMP::getNumProcs() const");
	}

	/*!
	 *  \brief Set the line number in the file where the exception is detected (throwed).
	 *  \param inLineNumber Line number in the file where the exception is detected.
	 */
	inline void setLineNumber(unsigned int inLineNumber)
	{
		Beagle_StackTraceBeginM();
		mLineNumber = inLineNumber;
		Beagle_StackTraceEndM("void TargetedException::setLineNumber(unsigned int inLineNumber)");
	}

	/*!
	 *  \brief Return number of emigrants available in current migration buffer.
	 *  \return Number of emigrants available in current migration buffer.
	 */
	inline unsigned int getNumberOfEmigrants() const
	{
		Beagle_StackTraceBeginM();
		return mEmigrants.size();
		Beagle_StackTraceEndM("unsigned int MigrationBuffer::getNumberOfEmigrants() const");
	}

/*!
 *  \brief  Test whether an unsigned long is less than, or equal to another.
 *  \param  inLeftULong  Left unsigned long compared.
 *  \param  inRightULong Right unsigned long compared.
 *  \return True if left unsigned long is less than, or equal to the right one, false if not.
 *  \par Note:
 *    The operator is defined relatively to the functions isLess and isEqual of Beagle::ULong.
 */
inline bool operator<=(const Beagle::ULong& inLeftULong, const Beagle::ULong& inRightULong)
{
	Beagle_StackTraceBeginM();
	return ( inLeftULong.isLess(inRightULong) || inLeftULong.isEqual(inRightULong) );
	Beagle_StackTraceEndM("bool operator<=(const ULong& inLeftULong, const ULong& inRightULong)");
}