自学教程：C++ FromHere函数代码示例

 /// extraction of data from the wrapped object, returned memory is a copy, not a view /// if nullptr is passed (also default parameter), memory is allocated. /// @return pointer to the newly allocated data which is of size size_of()*stride()*size() virtual const void* pack(void* buf=nullptr) const {   if ( is_null(m_data) ) throw cf3::common::BadPointer(FromHere(),name()+": Data expired.");   if (buf==nullptr) buf=new T[m_data->num_elements()*m_stride+1];   if ( buf == nullptr ) throw cf3::common::NotEnoughMemory(FromHere(),name()+": Could not allocate temporary buffer.");   T* ibuf=(T*)buf;   for (int i=0; i<(const int)(m_data->num_elements()*m_stride); i++)     *ibuf++=(*m_data)[i];   return buf; }

CLink& CLink::link_to ( Component::Ptr lnkto ){  if ( is_null(lnkto) )    throw BadValue(FromHere(), "Cannot link to null component");  if (lnkto->is_link())    throw SetupError(FromHere(), "Cannot link a CLink to another CLink");  m_link_component = lnkto;  return *this;}

void NLink::go_to_target(SignalArgs & ){  if ( is_null(m_target) )    throw ValueNotFound (FromHere(), "Target of this link is not set or not valid");  QModelIndex index = NTree::global()->index_from_path(m_target->uri());  if(index.isValid())    NTree::global()->set_current_index(index);  else    throw ValueNotFound (FromHere(), m_target->uri().string() + ": path does not exist");}

RealVector ElementType::plane_jacobian_normal(const RealVector& mapped_coords,                                              const RealMatrix& nodes,                                              const CoordRef direction) const{  throw Common::NotImplemented(FromHere(),"jacobian not implemented for "+derived_type_name());  return RealVector(1);}

 inline void operator()(boost::any& to_set, const boost::any& new_value) {   if(new_value.type() == to_set.type())   {     to_set = new_value;   }   else   {     try     {       std::vector<Uint> int_vals = boost::any_cast< std::vector<Uint> >(new_value);       const Uint nb_vals = int_vals.size();       std::vector<int> result(nb_vals);       for(Uint i = 0; i != nb_vals; ++i)       {         result[i] = static_cast<int>(int_vals[i]);       }       to_set = result;     }     catch(boost::bad_any_cast& e)     {       throw CastingFailed(FromHere(), std::string("Failed to cast object of type ") + new_value.type().name() + " to type std::vector<int>");     }   } }

TreeView::TreeView(CentralPanel * optionsPanel, QMainWindow * parent,                   bool contextMenuAllowed): QTreeView(parent),  m_context_menu_allowed(contextMenuAllowed){  if(m_context_menu_allowed && optionsPanel == nullptr)    throw BadValue(FromHere(), "Options panel is a nullptr pointer");  // instantiate class attributes  m_model_filter = new FilteringModel(this);  m_central_panel = optionsPanel;  m_signal_manager = new SignalManager(parent);  m_model_filter->setSourceModel(NTree::global().get());  m_model_filter->setDynamicSortFilter(true);  this->setModel(m_model_filter);  this->set_read_only(false);  // when right clicking on the Client,  // a "Context menu event" must be generated  this->setContextMenuPolicy(Qt::CustomContextMenu);  this->header()->setResizeMode(QHeaderView::ResizeToContents);  this->header()->setStretchLastSection(true);  if(m_context_menu_allowed)  {    connect(NTree::global().get(),            SIGNAL(current_index_changed(QModelIndex, QModelIndex)),            this,            SLOT(current_index_changed(QModelIndex, QModelIndex)));  }}

  Common_API bool from_str<bool> (const std::string& str)  {    bool match = false;    boost::algorithm::is_equal test_equal;    if ( test_equal(str,"true") ||         test_equal(str,"True") ||         test_equal(str,"on")   ||         test_equal(str,"1")     )    {      return true;    }    if ( test_equal(str,"false") ||         test_equal(str,"False") ||         test_equal(str,"off")   ||         test_equal(str,"0")      )    {      return false;    }    if (!match)      throw ParsingFailed (FromHere(), "Incorrect option conversion to bool of string [" + str + "]" );    return true;  }

const CF::Mesh::ElementType& Triag2DLagrangeP2B::face_type(const CF::Uint face) const{  throw Common::NotImplemented( FromHere(), "Line2DLagrangeP2 does not exist yet" );  static const Line2DLagrangeP1 facetype;  return facetype;}

 /// setup of passing by reference /// @param std::vector of data /// @param stride number of array element grouping void setup(boost::multi_array<T,1>& data, const bool needs_update) {   if (boost::is_pod<T>::value==false) throw cf3::common::BadValue(FromHere(),name()+": Data is not POD (plain old datatype).");   m_data=&data;   m_stride = 1;   m_needs_update=needs_update; }

 /// returning back values into the data wrapped by objectwrapper /// @param pointer to the data to be committed back virtual void unpack(void* buf) const {   if ( is_null(m_data) ) throw cf3::common::BadPointer(FromHere(),name()+": Data expired.");   T* ibuf=(T*)buf;   for (int i=0; i<(const int)(m_data->num_elements()*m_stride); i++)     (*m_data)[i]=*ibuf++; }

  /// Create ElementCache if non-existant, else get the ElementCache and lock it through ElementCacheHandle constructor  ElementCacheT& cache(const Handle<mesh::Entities const>& entities, const Uint elem)  {    typename value_type::iterator it = m_element_caches.find(entities.get());    if(it != m_element_caches.end())    {      m_cache=it->second.get();      if ( get().idx == elem ) // Nothing to be done      {        get().lock();        return get();      }      if (get().locked()) throw common::IllegalCall(FromHere(),"cache "+uri().string()+" is locked to elem "+common::to_str(it->second->idx));      set_cache(elem);      return get();    }    boost::shared_ptr<ElementCacheT> element_cache ( new ElementCacheT );    m_cache=element_cache.get();    m_cache->cache = this->handle<Cache>();    configure_cache(entities);    set_cache(elem);    m_element_caches[entities.get()]=element_cache;    return get();  }

double DerivativesType5::a2(Data::DataStorage& data_Q, Data::DataStorage& data_W, Data::DataStorage& data_MIX,  Data::DataStorage& dp, CHEM::SpeciesSet& species_set, int ND){	double rho = data_MIX(0);	double a2_rho = 0.0;	for (int s= 0; s <= species_set.NS-1; s++)	{		a2_rho	+= data_Q(s)*dp(s);	}	for (int k = species_set.NS; k <= species_set.NS+ND-1; k++)	{		a2_rho += data_Q(k)*dp(k);	}	a2_rho	+= (data_Q(species_set.NS+ND) + data_W(species_set.NS+ND)) * dp(species_set.NS+ND);	a2_rho	+= data_Q(species_set.NS+ND+1) * dp(species_set.NS+ND+1);	if (a2_rho < 0.0 || a2_rho == std::numeric_limits<double>::infinity() || a2_rho != a2_rho)	{		throw Common::ExceptionNegativeValue (FromHere(), "Negative value of a2: Need to check dp_dQ.");	}	//Common::ErrorCheckNonNegative<double>(a2_rho, "DerivativesType5: rho_a2 cannot be negative");	return (a2_rho / rho);}

void CPlotXY::convergence_history( SignalArgs & args ){  if( is_not_null(m_data.get()) )  {    SignalFrame reply = args.create_reply( uri() );    SignalFrame& options = reply.map( Protocol::Tags::key_options() );//    std::vector<Real> data(8000);    CTable<Real>& table = *m_data.get();    std::vector<std::string> labels =        list_of<std::string>("x")("y")("z")("u")("v")("w")("p")("t");    add_multi_array_in(options.main_map, "Table", m_data->array(), ";", labels);//    for(Uint row = 0 ; row < 1000 ; ++row)//    {//      for(Uint col = 0 ; col < 8 ; ++col)//        data[ (row * 8) + col ] = table[row][col];//    }//    XmlNode node = options.add("Table", data, " ; ");//    node.set_attribute("dimensions", "8");  }  else    throw SetupError( FromHere(), "Data to plot not setup" );}

  /// Return the wrapped component  ComponentT& component()  {    if(is_null(m_component))      throw common::SetupError(FromHere(), "ComponentWrapperImpl points to a null component");    return **m_component;  }

Field& Dictionary::create_field(const std::string &name, math::VariablesDescriptor& variables_descriptor){  CFinfo << "Creating field " << uri()/name << CFendl;  if (m_dim == 0) throw SetupError(FromHere(), "dimension not configured");  Handle<Field> field = create_component<Field>(name);  field->set_dict(*this);  field->set_descriptor(variables_descriptor);  if (variables_descriptor.options().option(common::Tags::dimension()).value<Uint>() == 0)  {    field->descriptor().options().set(common::Tags::dimension(),m_dim);  }  field->set_row_size(field->descriptor().size());  field->resize(size());  update_structures();  CFinfo << "Created field " << field->uri() << " with variables /n";  for (Uint var=0; var<field->descriptor().nb_vars(); ++var)  {    CFinfo << "    - " << field->descriptor().user_variable_name(var) << " [" << field->descriptor().var_length(var) << "]/n";  }  CFinfo << CFflush;  return *field;}

void Solve3x3eqn(std::vector< std::vector<double> >& A, std::vector<double> &b,  std::vector<double> &x){	if (fabs<double>(b[0]) <= MATH_ZERO	&& fabs<double>(b[1]) <= MATH_ZERO && fabs<double>(b[2]) <= MATH_ZERO)	{		x.resize(3, 0.0);	}	else	{		x.resize(3, 0.0);		double det = A[0][0]*(A[1][1]*A[2][2] - A[1][2]*A[2][1]) - A[0][1]*(A[1][0]*A[2][2] - A[1][2]*A[2][1]) + A[0][2]*(A[1][0]*A[2][1] - A[1][1]*A[2][0]);		if( fabs<double>(det) < MATH_ZERO) throw Common::ExceptionDimensionMatch (FromHere(), "NO Solution (zero determinent)");		double a11 = A[1][1]*A[2][2] - A[1][2]*A[2][1];		double a12 = -(A[1][0]*A[2][2] - A[1][2]*A[2][0]);		double a13 = A[1][0]*A[2][1] - A[1][1]*A[2][0];		double a21 =-(A[0][1]*A[2][2] - A[0][2]*A[2][1]);		double a22 = A[0][0]*A[2][2] - A[0][2]*A[2][0];		double a23 =-(A[0][0]*A[2][1] - A[0][1]*A[2][0]);		double a31 = A[2][1]*A[1][2] - A[0][2]*A[1][1];		double a32 =-(A[0][0]*A[1][2] - A[0][2]*A[1][0]);		double a33 = A[0][0]*A[1][1] - A[0][1]*A[1][0];		x[0] =  (a11*b[0] + a12*b[1] + a13*b[2])/det;		x[1] =  (a21*b[0] + a22*b[1] + a23*b[2])/det;		x[2] =  (a31*b[0] + a32*b[1] + a33*b[2])/det;	}}

 Real solve_yplus(FunctorT&& f) {   Real yp_low = 0.;   Real yp_high = 1000.;   Uint count = 1;   Real yplus = 0.;   while(((yp_high-yp_low) > 1e-4) && count < 1000)   {     yplus = (yp_low+yp_high)/2.;     if (f(yplus) < yplus)     {       yp_high = yplus;     }     else     {       yp_low = yplus;     }     count += 1;   }   if(count == 1000)   {     throw common::FailedToConverge(FromHere(), "y+ computation did not converge");   }   return yplus; }

Uint CField::var_number ( const std::string& vname ) const{  const std::vector<std::string>::const_iterator var_loc_it = std::find(m_var_names.begin(), m_var_names.end(), vname);  if(var_loc_it == m_var_names.end())    throw Common::ValueNotFound(FromHere(), "Variable " + vname + " was not found in field " + name());  return var_loc_it - m_var_names.begin();}

    typename LIB::Ptr library ()    {      const std::string lname = LIB::library_namespace(); //instead of LIB::type_name();      Component::Ptr clib = get_child_ptr(lname);      typename LIB::Ptr lib;      if ( is_null(clib) ) // doesnt exist so build it      {        CF::Common::TypeInfo::instance().regist< LIB >( lname );        lib = create_component_ptr< LIB >(lname);        cf_assert( is_not_null(lib) );        return lib;      }      // try to convert existing ptr to LIB::Ptr and return it      lib = clib->as_ptr<LIB>();      if( is_null(lib) ) // conversion failed        throw CastingFailed( FromHere(),                            "Found component in CLibraries with name "                            + lname                            + " but is not the actual library "                            + LIB::type_name() );      return lib;    }

  void read_data_block(char *data, const Uint count, const Uint block_idx)  {    static const std::string block_prefix("__CFDATA_BEGIN");        XmlNode block_node = get_block_node(block_idx);          const Uint block_begin = from_str<Uint>(block_node.attribute_value("begin"));    const Uint block_end = from_str<Uint>(block_node.attribute_value("end"));    const Uint compressed_size = block_end - block_begin - block_prefix.size();    // Check the prefix    binary_file.seekg(block_begin);    std::vector<char> prefix_buf(block_prefix.size());    binary_file.read(&prefix_buf[0], block_prefix.size());    const std::string read_prefix(prefix_buf.begin(), prefix_buf.end());    if(read_prefix != block_prefix)      throw SetupError(FromHere(), "Bad block prefix for block " + to_str(block_idx));       if(count != 0)    {      // Build a decompressing stream      boost::iostreams::filtering_istream decompressing_stream;      decompressing_stream.set_auto_close(false);      decompressing_stream.push(boost::iostreams::zlib_decompressor());      decompressing_stream.push(boost::iostreams::restrict(binary_file, 0, compressed_size));            // Read the data      decompressing_stream.read(data, count);      decompressing_stream.pop();    }        cf3_assert(binary_file.tellg() == block_end);  }

void BinaryDataReader::read_data_block(char *data, const Uint count, const Uint block_idx){  if(is_null(m_implementation.get()))    throw SetupError(FromHere(), "No open file for BinaryDataReader at " + uri().path());    m_implementation->read_data_block(data, count, block_idx);}

void VectorialFunction::parse(){  clear();  for(Uint i = 0; i < m_functions.size(); ++i)  {    FunctionParser* ptr = new FunctionParser();    ptr->AddConstant("pi", Consts::pi());    m_parsers.push_back(ptr);    // CFinfo << "Parsing Function: /'" << m_functions[i] << "/' Vars: /'" << m_vars << "/'/n" << CFendl;    ptr->Parse(m_functions[i],m_vars);    if ( ptr->GetParseErrorType() !=  FunctionParser::FP_NO_ERROR )    {      std::string msg("ParseError in VectorialFunction::parse(): ");      msg += " Error [" +std::string(ptr->ErrorMsg()) + "]";      msg += " Function [" + m_functions[i] + "]";      msg += " Vars: ["    + m_vars + "]";      throw common::ParsingFailed (FromHere(),msg);    }  }  m_result.resize(m_functions.size());  m_is_parsed = true;}

  static void compute_properties ( const CV& coord,                                   const SV& sol,                                   const GM& grad_vars,                                   MODEL::Properties& p )  {    p.coords    = coord;       // cache the coordiantes locally    p.vars      = sol;         // cache the variables locally    p.grad_vars = grad_vars;   // cache the gradient of variables locally    p.rho = sol[Z0]*sol[Z0];    p.u   = sol[Z1]/sol[Z0];    p.v   = sol[Z2]/sol[Z0];    p.w   = sol[Z3]/sol[Z0];    p.H   = sol[Z4]/sol[Z0];    p.uuvvww = p.u*p.u + p.v*p.v + p.w*p.w;    p.P = p.gamma_minus_1/p.gamma * p.rho*(p.H - 0.5*p.uuvvww);    p.rhou = p.rho * p.u;    p.rhov = p.rho * p.v;    p.rhow = p.rho * p.w;    p.rhoE = p.rho * p.E;    p.inv_rho = 1. / p.rho;    if( p.P <= 0. )    {          std::cout << "rho    : " << p.rho  << std::endl;          std::cout << "rhou   : " << p.rhou << std::endl;          std::cout << "rhov   : " << p.rhov << std::endl;          std::cout << "rhoE   : " << p.rhoE << std::endl;          std::cout << "P      : " << p.P    << std::endl;          std::cout << "u      : " << p.u    << std::endl;          std::cout << "v      : " << p.v    << std::endl;          std::cout << "w      : " << p.w    << std::endl;          std::cout << "uuvvww : " << p.uuvvww << std::endl;      throw common::FailedToConverge( FromHere(), "Pressure is negative at coordinates ["                                   + common::to_str(coord[XX]) + ","                                   + common::to_str(coord[YY]) + ","                                   + common::to_str(coord[ZZ])                                   + "]");    }    const Real RT = p.P * p.inv_rho;    // RT = p/rho    p.E = p.rhoE * p.inv_rho;           // E = rhoE / rho    p.a2 = p.gamma * RT;    p.a = sqrt( p.a2 );    p.Ma = sqrt( p.uuvvww / p.a2 );    p.T = RT / p.R;    p.half_gm1_v2 = 0.5 * p.gamma_minus_1 * p.uuvvww;  }

solver::CSolver& ActionDirector::solver(){  Handle< solver::CSolver > s = m_solver;  if( is_null(s) )    throw common::SetupError( FromHere(),                             "Solver not yet set for component " + uri().string() );  return *s;}