C++ DBG_START_METH函数代码示例

 void CompoundVector::ElementWiseMinImpl(const Vector& x)
 {
   DBG_START_METH("CompoundVector::ElementWiseMinImpl", dbg_verbosity);
   DBG_ASSERT(vectors_valid_);
   const CompoundVector* comp_x = static_cast<const CompoundVector*>(&x);
   DBG_ASSERT(dynamic_cast<const CompoundVector*>(&x));
   DBG_ASSERT(NComps() == comp_x->NComps());
   for (Index i=0; i<NComps(); i++) {
     Comp(i)->ElementWiseMin(*comp_x->GetComp(i));
   }
 }

 bool DenseGenSchurDriver::SchurFactorize()
 {
   DBG_START_METH("DenseGenSchurDriver::SchurFactorize", dbg_verbosity);
   /* This function is the very same as the one in DenseGenSchurDriver */
   bool retval;
   if (IsValid(S_)) {
     retval = S_->ComputeLUFactorInPlace();
     return retval;
   }
   return true;
 }

  bool CachedResults<T>::GetCachedResult1Dep(T& retResult, const TaggedObject* dependent1)
  {
#ifdef IP_DEBUG_CACHE
    DBG_START_METH("CachedResults<T>::GetCachedResult1Dep", dbg_verbosity);
#endif

    std::vector<const TaggedObject*> dependents(1);
    dependents[0] = dependent1;

    return GetCachedResult(retResult, dependents);
  }

 SmartPtr<const Vector> StandardScalingBase::unapply_vector_scaling_x(
   const SmartPtr<const Vector>& v)
 {
   DBG_START_METH("NLPScalingObject::unapply_vector_scaling_x", dbg_verbosity);
   if (IsValid(dx_)) {
     return ConstPtr(unapply_vector_scaling_x_NonConst(v));
   }
   else {
     return v;
   }
 }

  inline
  void Subject::Notify(Observer::NotifyType notify_type) const
  {
#ifdef IP_DEBUG_OBSERVER
    DBG_START_METH("Subject::Notify", dbg_verbosity);
#endif

    std::vector<Observer*>::iterator iter;
    for (iter = observers_.begin(); iter != observers_.end(); iter++) {
      (*iter)->ProcessNotification(notify_type, this);
    }
  }

  MumpsSolverInterface::~MumpsSolverInterface()
  {
    DBG_START_METH("MumpsSolverInterface::~MumpsSolverInterface()",
                   dbg_verbosity);

    DMUMPS_STRUC_C* mumps_ = (DMUMPS_STRUC_C*)mumps_ptr_;
    mumps_->job = -2; //terminate mumps
    dmumps_c(mumps_);
    MPI_Finalize();
    delete [] mumps_->a;
    delete mumps_;
  }

  bool CGPenaltyLSAcceptor::RestoreBestPoint()
  {
    DBG_START_METH("CGPenaltyLSAcceptor::RestoreBestPoint",
                   dbg_verbosity);

    if (!IsValid(best_iterate_)) {
      return false;
    }
    SmartPtr<IteratesVector> prev_iterate = best_iterate_->MakeNewContainer();
    IpData().set_trial(prev_iterate);
    return true;
  }

  IterativeWsmpSolverInterface::~IterativeWsmpSolverInterface()
  {
    DBG_START_METH("IterativeWsmpSolverInterface::~IterativeWsmpSolverInterface()",
                   dbg_verbosity);

    // Clear WSMP's memory
    F77_FUNC_(wsmp_clear,WSMP_CLEAR)();

    delete[] IPARM_;
    delete[] DPARM_;
    delete[] a_;
  }

Ma57TSolverInterface::~Ma57TSolverInterface()
{
    DBG_START_METH("Ma57TSolverInterface::~Ma57TSolverInterface()",
                   dbg_verbosity);
    delete [] a_;

    delete [] wd_fact_;
    delete [] wd_ifact_;

    delete [] wd_iwork_;
    delete [] wd_keep_;
}

 SensAlgorithm::~SensAlgorithm()
 {
   DBG_START_METH("SensAlgorithm::~SensAlgorithm", dbg_verbosity);
   if (NULL != DirectionalD_X_) delete [] DirectionalD_X_ ;
   if (NULL != DirectionalD_L_) delete [] DirectionalD_L_ ;
   if (NULL != DirectionalD_Z_U_) delete [] DirectionalD_Z_U_ ;
   if (NULL != DirectionalD_Z_L_) delete [] DirectionalD_Z_L_ ;
   if (NULL != SensitivityM_X_) delete [] SensitivityM_X_ ;
   if (NULL != SensitivityM_L_) delete [] SensitivityM_L_ ;
   if (NULL != SensitivityM_Z_U_) delete [] SensitivityM_Z_U_ ;
   if (NULL != SensitivityM_Z_L_) delete [] SensitivityM_Z_L_ ;
 }

 Number PiecewisePenalty::BiggestBarr()
 {
   DBG_START_METH("PiecewisePenalty::BiggestBarr", dbg_verbosity);
   DBG_ASSERT(!IsPiecewisePenaltyListEmpty());
   Number value = -1e20;
   if (PiecewisePenalty_list_.size() > 0) {
     std::vector<PiecewisePenEntry>::iterator iter;
     iter = PiecewisePenalty_list_.end();
     iter--;
     value = iter->barrier_obj;
   }
   return value;
 }

  bool TSymDependencyDetector::DetermineDependentRows(
    Index n_rows, Index n_cols, Index n_jac_nz, Number* jac_c_vals,
    Index* jac_c_iRow, Index* jac_c_jCol, std::list<Index>& c_deps)
  {
    DBG_START_METH("TSymDependencyDetector::DetermineDependentRows",
                   dbg_verbosity);

    ESymSolverStatus retval =
      tsym_linear_solver_->DetermineDependentRows(n_rows, n_cols, n_jac_nz,
          jac_c_vals, jac_c_iRow,
          jac_c_jCol, c_deps);

    return (retval == SYMSOLVER_SUCCESS);
  }

  bool IndexPCalculator::InitializeImpl(const OptionsList& options,
					const std::string& prefix)
  {
    DBG_START_METH("IndexPCalculator::InitializeImpl", dbg_verbosity);

    SmartPtr<const IteratesVector> iv = IpData().curr();
    nrows_ = 0;
    for (Index i=0; i<iv->NComps(); ++i) {
      nrows_+=iv->GetComp(i)->Dim();
    }
    data_A()->Print(Jnlst(),J_VECTOR,J_USER1,"PCalc SchurData");

    return true;
  }

  WsmpSolverInterface::WsmpSolverInterface()
      :
      a_(NULL),
      negevals_(-1),
      initialized_(false),

      PERM_(NULL),
      INVP_(NULL)
  {
    DBG_START_METH("WsmpSolverInterface::WsmpSolverInterface()",dbg_verbosity);

    IPARM_ = new ipfint[64];
    DPARM_ = new double[64];
  }

 SmartPtr<Vector> StandardScalingBase::unapply_vector_scaling_x_NonConst(
   const SmartPtr<const Vector>& v)
 {
   DBG_START_METH("StandardScalingBase::unapply_vector_scaling_x_NonConst",
                  dbg_verbosity);
   SmartPtr<Vector> unscaled_x = v->MakeNewCopy();
   if (IsValid(dx_)) {
     unscaled_x->ElementWiseDivide(*dx_);
   }
   else {
     DBG_PRINT((1, "Creating copy in unapply_vector_scaling_x_NonConst!"));
   }
   return unscaled_x;
 }