typename T::return_type operator()(T& t, const char* d, typename T::size_type s) { _clear_flag = false; data_type::size_type offset = 0; if ( _data.empty() ) { if (_data.capacity() > 0 ) data_type(_data).swap(_data); offset = _parse_(t, d, s, 0, 0); if (!_clear_flag) { if (offset == static_cast<data_type::size_type>(-1)) _assign(d, d + s); else if ( static_cast<typename T::size_type>(offset) != s) _assign(d + offset, d + s); } } else { const size_t datasize = _data.size(); if (_data.capacity() < datasize + s) { _data.reserve( datasize < 16384 ? datasize + s : datasize+(datasize>>1)+s); } std::copy(d, d + s, std::back_inserter(_data)); offset = _parse_(t, &(_data[0]), _data.size(), 0, datasize>size_sep ? datasize-size_sep : 0); if (!_clear_flag) { if ( offset == static_cast<typename T::size_type>( _data.size() ) ) _data.clear(); else if ( offset!= static_cast<data_type::size_type>(-1) ) _data.erase( _data.begin(), _data.begin() + offset ); } }
void Conf::load(kchar* cfgFile) { FILE* pf = _ttfopen(cfgFile, "rb"); if(pf) { AutoCall<int (*)(FILE*), FILE*> _a(::fclose, pf); char pred[128]; char val[128]; char line[256]; bool inComment = false; try { while(!feof(pf)) { if(fgets(line,255,pf)) { str_prepline(line); if(*line==0) continue; if(inComment || *line=='#') continue; kchar* pnext = str_ccpy(pred, line,'='); if(*pred=='[') { str_lrtim(pred); _section = pred; continue; } else if(*pred=='}') { _assign("}", " ", 0); } if(pnext && *pnext) { str_scpy(val, (char*)pnext+1, "#"); str_lrtim(val); str_lrtim(pred); _assign(pred, val, 0); } } else break; if(feof(pf)) { break; } } } catch(int& err) { } } else { printf( "Cannot find configuration file in curent folder\r\n"); exit(0); } }
/** * \brief Assignment operator. * \param[in] other Another lexeme sequence to assign to the current object. * \returns Reference to the original object after assignment. */ Lexeme &Lexeme::operator =(const Lexeme &other) { if (this != &other) { _destroy(); _assign(other); } return *this; }
const NEModule& NEModule::operator=(const ThisClass& rhs) { if(this == &rhs) return *this; SuperClass::operator=(rhs); return _assign(rhs); }
// --------------------------------------------------------------------------------- // 히스토리: 2011-07-07 이태훈 개발 완료 // --------------------------------------------------------------------------------- const NESwitchableUnit NE_DLL &NESwitchableUnit::operator=(const NESwitchableUnit& source) { if(this == &source) return *this; NEUnit::operator=(source); return _assign(source); }
GError* meta0_assign_prefix_to_meta1(struct meta0_backend_s *m0, gchar *ns_name, gboolean nocheck) { // GET meta1 list from conscience GList *working_m1list = NULL; GSList *unref_m1list = NULL; GError *error; GPtrArray *new_meta1ref = NULL; GRID_INFO("START Assign prefix"); error = _initContext(m0); if (error) { goto errorLabel; } // build working list , list sorted by score error = _init_assign(ns_name,&working_m1list,&unref_m1list); if ( error ) { goto errorLabel; } if ( nocheck ) { error =_check(working_m1list); if ( error ) { goto errorLabel; } } error = _assign(working_m1list,unref_m1list); if ( error ) { goto errorLabel; } new_meta1ref = _updated_meta1ref(); error = meta0_backend_assign(m0, context->array_meta1_by_prefix, new_meta1ref,FALSE); if ( error ) { GRID_ERROR("failed to update BDD :(%d) %s", error->code, error->message); goto errorLabel; } context->lastAssignTime=g_date_time_new_now_local(); errorLabel : _resetContext(); if (new_meta1ref) { meta0_utils_array_meta1ref_clean(new_meta1ref); } if (working_m1list) { g_list_free(working_m1list); working_m1list=NULL; } if (unref_m1list) { g_slist_free(unref_m1list); unref_m1list=NULL; } GRID_INFO("END ASSIGN"); return error; }
RString::RString(XString x) : owned(nullptr) { const RString *f = x.base(); const char *xb = &*x.begin(); const char *xe = &*x.end(); const char *fb = f ? &*f->begin() : nullptr; const char *fe = f ? &*f->end() : nullptr; if (f && xb == fb && xe == fe) *this = *f; else _assign(x.begin(), x.end()); }
void TreeEqualizer::_assign( Node* node, const Viewport& vp, const Range& range ) { LBLOG( LOG_LB2 ) << "assign " << vp << ", " << range << " time " << node->time << " split " << node->split << std::endl; LBASSERTINFO( vp.isValid(), vp ); LBASSERTINFO( range.isValid(), range ); LBASSERTINFO( node->resources > 0.f || !vp.hasArea() || !range.hasData(), "Assigning work to unused compound: " << vp << ", " << range); Compound* compound = node->compound; if( compound ) { LBASSERTINFO( vp == Viewport::FULL || range == Range::ALL, "Mixed 2D/DB load-balancing not implemented" ); compound->setViewport( vp ); compound->setRange( range ); LBLOG( LOG_LB2 ) << compound->getChannel()->getName() << " set " << vp << ", " << range << std::endl; return; } switch( node->mode ) { case MODE_VERTICAL: { // Ensure minimum size const Compound* root = getCompound(); const float pvpW = float( root->getInheritPixelViewport().w ); const float end = vp.getXEnd(); const float boundary = float( node->boundary2i.x( )) / pvpW; float absoluteSplit = vp.x + vp.w * node->split; if( node->left->resources == 0.f ) absoluteSplit = vp.x; else if( node->right->resources == 0.f ) absoluteSplit = end; else if( boundary > 0 ) { const float right = vp.getXEnd() - absoluteSplit; const float left = absoluteSplit - vp.x; const float maxRight = float( node->right->maxSize.x( )) / pvpW; const float maxLeft = float( node->left->maxSize.x( )) / pvpW; if( right > maxRight ) absoluteSplit = end - maxRight; else if( left > maxLeft ) absoluteSplit = vp.x + maxLeft; if( (absoluteSplit - vp.x) < boundary ) absoluteSplit = vp.x + boundary; if( (end - absoluteSplit) < boundary ) absoluteSplit = end - boundary; const uint32_t ratio = uint32_t( absoluteSplit / boundary + .5f ); absoluteSplit = ratio * boundary; } absoluteSplit = LB_MAX( absoluteSplit, vp.x ); absoluteSplit = LB_MIN( absoluteSplit, end); node->split = (absoluteSplit - vp.x ) / vp.w; LBLOG( LOG_LB2 ) << "Constrained split " << vp << " at X " << node->split << std::endl; // traverse children Viewport childVP = vp; childVP.w = (absoluteSplit - vp.x); _assign( node->left, childVP, range ); childVP.x = childVP.getXEnd(); childVP.w = end - childVP.x; // Fix 2994111: Rounding errors with 2D LB and 16 sources // Floating point rounding may create a width for the 'right' // child which is slightly below the parent width. Correct it. while( childVP.getXEnd() < end ) childVP.w += std::numeric_limits< float >::epsilon(); _assign( node->right, childVP, range ); break; } case MODE_HORIZONTAL: { // Ensure minimum size const Compound* root = getCompound(); const float pvpH = float( root->getInheritPixelViewport().h ); const float end = vp.getYEnd(); const float boundary = float( node->boundary2i.y( )) / pvpH; float absoluteSplit = vp.y + vp.h * node->split; if( node->left->resources == 0.f ) absoluteSplit = vp.y; else if( node->right->resources == 0.f ) absoluteSplit = end; else if( boundary > 0 ) { const float right = vp.getYEnd() - absoluteSplit; const float left = absoluteSplit - vp.y; const float maxRight = float( node->right->maxSize.y( )) / pvpH; const float maxLeft = float( node->left->maxSize.y( )) / pvpH; if( right > maxRight ) absoluteSplit = end - maxRight; else if( left > maxLeft ) absoluteSplit = vp.y + maxLeft; if( (absoluteSplit - vp.y) < boundary ) absoluteSplit = vp.y + boundary; if( (end - absoluteSplit) < boundary ) absoluteSplit = end - boundary; const uint32_t ratio = uint32_t( absoluteSplit / boundary + .5f ); absoluteSplit = ratio * boundary; } absoluteSplit = LB_MAX( absoluteSplit, vp.y ); absoluteSplit = LB_MIN( absoluteSplit, end); node->split = (absoluteSplit - vp.y ) / vp.h; LBLOG( LOG_LB2 ) << "Constrained split " << vp << " at X " << node->split << std::endl; // traverse children Viewport childVP = vp; childVP.h = (absoluteSplit - vp.y); _assign( node->left, childVP, range ); childVP.y = childVP.getYEnd(); childVP.h = end - childVP.y; // Fix 2994111: Rounding errors with 2D LB and 16 sources // Floating point rounding may create a width for the 'right' // child which is slightly below the parent width. Correct it. while( childVP.getYEnd() < end ) childVP.h += std::numeric_limits< float >::epsilon(); _assign( node->right, childVP, range ); break; } case MODE_DB: { LBASSERT( vp == Viewport::FULL ); const float end = range.end; float absoluteSplit = range.start + (range.end-range.start)*node->split; const float boundary( node->boundaryf ); if( node->left->resources == 0.f ) absoluteSplit = range.start; else if( node->right->resources == 0.f ) absoluteSplit = end; const uint32_t ratio = uint32_t( absoluteSplit / boundary + .5f ); absoluteSplit = ratio * boundary; if( (absoluteSplit - range.start) < boundary ) absoluteSplit = range.start; if( (end - absoluteSplit) < boundary ) absoluteSplit = end; node->split = (absoluteSplit-range.start) / (range.end-range.start); LBLOG( LOG_LB2 ) << "Constrained split " << range << " at pos " << node->split << std::endl; Range childRange = range; childRange.end = absoluteSplit; _assign( node->left, vp, childRange ); childRange.start = childRange.end; childRange.end = range.end; _assign( node->right, vp, childRange); break; } default: LBUNIMPLEMENTED; } }
/////////////// // Operators // /////////////// image& image::operator=(const image& src) { _assign(src); return *this; }
/////////////// // Operators // /////////////// triangleMesh& triangleMesh::operator=(const triangleMesh& tm) { _assign(tm); return *this; }
// --------------------------------------------------------------------------------- // 히스토리: 2011-07-07 이태훈 개발 완료 // --------------------------------------------------------------------------------- NE_DLL Kernal::Kernal(const Kernal& source) : NEModule(source), _script_manager(NE_NULL), _node_manager(NE_NULL) { _assign(source); }
NE_DLL NEComponent::NEComponent(const NEComponent& source) : NEUnit(source) { _assign(source); }
void LoadEqualizer::_computeSplit( Node* node, const float time, LBDatas* datas, const Viewport& vp, const Range& range ) { LBLOG( LOG_LB2 ) << "_computeSplit " << vp << ", " << range << " time " << time << std::endl; LBASSERTINFO( vp.isValid(), vp ); LBASSERTINFO( range.isValid(), range ); LBASSERTINFO( node->resources > 0.f || !vp.hasArea() || !range.hasData(), "Assigning " << node->resources << " work to viewport " << vp << ", " << range ); Compound* compound = node->compound; if( compound ) { _assign( compound, vp, range ); return; } LBASSERT( node->left && node->right ); LBDatas workingSet = datas[ node->mode ]; const float leftTime = node->resources > 0 ? time * node->left->resources / node->resources : 0.f; float timeLeft = LB_MIN( leftTime, time ); // correct for fp rounding error switch( node->mode ) { case MODE_VERTICAL: { LBASSERT( range == Range::ALL ); float splitPos = vp.x; const float end = vp.getXEnd(); while( timeLeft > std::numeric_limits< float >::epsilon() && splitPos < end ) { LBLOG( LOG_LB2 ) << timeLeft << "ms left using " << workingSet.size() << " tiles" << std::endl; // remove all irrelevant items from working set for( LBDatas::iterator i = workingSet.begin(); i != workingSet.end(); ) { const Data& data = *i; if( data.vp.getXEnd() > splitPos ) ++i; else i = workingSet.erase( i ); } if( workingSet.empty( )) break; // find next 'discontinouity' in loads float currentPos = 1.0f; for( LBDatas::const_iterator i = workingSet.begin(); i != workingSet.end(); ++i ) { const Data& data = *i; if( data.vp.x > splitPos && data.vp.x < currentPos ) currentPos = data.vp.x; const float xEnd = data.vp.getXEnd(); if( xEnd > splitPos && xEnd < currentPos ) currentPos = xEnd; } const float width = currentPos - splitPos; LBASSERTINFO( width > 0.f, currentPos << "<=" << splitPos ); LBASSERT( currentPos <= 1.0f ); // accumulate normalized load in splitPos...currentPos LBLOG( LOG_LB2 ) << "Computing load in X " << splitPos << "..." << currentPos << std::endl; float currentTime = 0.f; for( LBDatas::const_iterator i = workingSet.begin(); i != workingSet.end(); ++i ) { const Data& data = *i; if( data.vp.x >= currentPos ) // not yet needed data sets break; float yContrib = data.vp.h; if( data.vp.y < vp.y ) yContrib -= (vp.y - data.vp.y); const float dataEnd = data.vp.getYEnd(); const float vpEnd = vp.getYEnd(); if( dataEnd > vpEnd ) yContrib -= (dataEnd - vpEnd); if( yContrib > 0.f ) { const float percentage = ( width / data.vp.w ) * ( yContrib / data.vp.h ); currentTime += ( data.time * percentage ); LBLOG( LOG_LB2 ) << data.vp << " contributes " << yContrib << " in " << vp.h << " (" << percentage << ") with " << data.time << ": " << ( data.time * percentage ) << " vp.y " << vp.y << " dataEnd " << dataEnd << " vpEnd " << vpEnd << std::endl; LBASSERT( percentage < 1.01f ) } } LBLOG( LOG_LB2 ) << splitPos << "..." << currentPos << ": t=" << currentTime << " of " << timeLeft << std::endl; if( currentTime >= timeLeft ) // found last region { splitPos += ( width * timeLeft / currentTime ); timeLeft = 0.0f; } else { timeLeft -= currentTime; splitPos = currentPos; } } LBLOG( LOG_LB2 ) << "Should split at X " << splitPos << std::endl; if( getDamping() < 1.f ) splitPos = (1.f - getDamping()) * splitPos + getDamping() * node->split; LBLOG( LOG_LB2 ) << "Dampened split at X " << splitPos << std::endl; // There might be more time left due to MIN_PIXEL rounding by parent // LBASSERTINFO( timeLeft <= .001f, timeLeft ); // Ensure minimum size const Compound* root = getCompound(); const float pvpW = static_cast< float >( root->getInheritPixelViewport().w ); const float boundary = static_cast< float >( node->boundary2i.x()) / pvpW; if( node->left->resources == 0.f ) splitPos = vp.x; else if( node->right->resources == 0.f ) splitPos = end; else if( boundary > 0 ) { const float lengthRight = vp.getXEnd() - splitPos; const float lengthLeft = splitPos - vp.x; const float maxRight = static_cast< float >( node->right->maxSize.x( )) / pvpW; const float maxLeft = static_cast< float >( node->left->maxSize.x( )) / pvpW; if( lengthRight > maxRight ) splitPos = end - maxRight; else if( lengthLeft > maxLeft ) splitPos = vp.x + maxLeft; if( (splitPos - vp.x) < boundary ) splitPos = vp.x + boundary; if( (end - splitPos) < boundary ) splitPos = end - boundary; const uint32_t ratio = static_cast< uint32_t >( splitPos / boundary + .5f ); splitPos = ratio * boundary; } splitPos = LB_MAX( splitPos, vp.x ); splitPos = LB_MIN( splitPos, end); const float newPixelW = pvpW * splitPos; const float oldPixelW = pvpW * node->split; if( int( fabs(newPixelW - oldPixelW) ) < node->resistance2i.x( )) splitPos = node->split; else node->split = splitPos; LBLOG( LOG_LB2 ) << "Constrained split " << vp << " at X " << splitPos << std::endl; // balance children Viewport childVP = vp; childVP.w = (splitPos - vp.x); _computeSplit( node->left, leftTime, datas, childVP, range ); childVP.x = childVP.getXEnd(); childVP.w = end - childVP.x; // Fix 2994111: Rounding errors with 2D LB and 16 sources // Floating point rounding may create a width for the 'right' // child which is slightly below the parent width. Correct it. while( childVP.getXEnd() < end ) childVP.w += std::numeric_limits< float >::epsilon(); _computeSplit( node->right, time-leftTime, datas, childVP, range ); break; } case MODE_HORIZONTAL: { LBASSERT( range == Range::ALL ); float splitPos = vp.y; const float end = vp.getYEnd(); while( timeLeft > std::numeric_limits< float >::epsilon() && splitPos < end ) { LBLOG( LOG_LB2 ) << timeLeft << "ms left using " << workingSet.size() << " tiles" << std::endl; // remove all unrelevant items from working set for( LBDatas::iterator i = workingSet.begin(); i != workingSet.end(); ) { const Data& data = *i; if( data.vp.getYEnd() > splitPos ) ++i; else i = workingSet.erase( i ); } if( workingSet.empty( )) break; // find next 'discontinuouity' in loads float currentPos = 1.0f; for( LBDatas::const_iterator i = workingSet.begin(); i != workingSet.end(); ++i ) { const Data& data = *i; if( data.vp.y > splitPos && data.vp.y < currentPos ) currentPos = data.vp.y; const float yEnd = data.vp.getYEnd(); if( yEnd > splitPos && yEnd < currentPos ) currentPos = yEnd; } const float height = currentPos - splitPos; LBASSERTINFO( height > 0.f, currentPos << "<=" << splitPos ); LBASSERT( currentPos <= 1.0f ); // accumulate normalized load in splitPos...currentPos LBLOG( LOG_LB2 ) << "Computing load in Y " << splitPos << "..." << currentPos << std::endl; float currentTime = 0.f; for( LBDatas::const_iterator i = workingSet.begin(); i != workingSet.end(); ++i ) { const Data& data = *i; if( data.vp.y >= currentPos ) // not yet needed data sets break; float xContrib = data.vp.w; if( data.vp.x < vp.x ) xContrib -= (vp.x - data.vp.x); const float dataEnd = data.vp.getXEnd(); const float vpEnd = vp.getXEnd(); if( dataEnd > vpEnd ) xContrib -= (dataEnd - vpEnd); if( xContrib > 0.f ) { const float percentage = ( height / data.vp.h ) * ( xContrib / data.vp.w ); currentTime += ( data.time * percentage ); LBLOG( LOG_LB2 ) << data.vp << " contributes " << xContrib << " in " << vp.w << " (" << percentage << ") with " << data.time << ": " << ( data.time * percentage ) << " total " << currentTime << " vp.x " << vp.x << " dataEnd " << dataEnd << " vpEnd " << vpEnd << std::endl; LBASSERT( percentage < 1.01f ) } } LBLOG( LOG_LB2 ) << splitPos << "..." << currentPos << ": t=" << currentTime << " of " << timeLeft << std::endl; if( currentTime >= timeLeft ) // found last region { splitPos += (height * timeLeft / currentTime ); timeLeft = 0.0f; } else { timeLeft -= currentTime; splitPos = currentPos; } } LBLOG( LOG_LB2 ) << "Should split at Y " << splitPos << std::endl; if( getDamping() < 1.f ) splitPos = (1.f - getDamping( )) * splitPos + getDamping() * node->split; LBLOG( LOG_LB2 ) << "Dampened split at Y " << splitPos << std::endl; const Compound* root = getCompound(); const float pvpH = static_cast< float >( root->getInheritPixelViewport().h ); const float boundary = static_cast< float >(node->boundary2i.y( )) / pvpH; if( node->left->resources == 0.f ) splitPos = vp.y; else if( node->right->resources == 0.f ) splitPos = end; else if ( boundary > 0 ) { const float lengthRight = vp.getYEnd() - splitPos; const float lengthLeft = splitPos - vp.y; const float maxRight = static_cast< float >( node->right->maxSize.y( )) / pvpH; const float maxLeft = static_cast< float >( node->left->maxSize.y( )) / pvpH; if( lengthRight > maxRight ) splitPos = end - maxRight; else if( lengthLeft > maxLeft ) splitPos = vp.y + maxLeft; if( (splitPos - vp.y) < boundary ) splitPos = vp.y + boundary; if( (end - splitPos) < boundary ) splitPos = end - boundary; const uint32_t ratio = static_cast< uint32_t >( splitPos / boundary + .5f ); splitPos = ratio * boundary; } splitPos = LB_MAX( splitPos, vp.y ); splitPos = LB_MIN( splitPos, end ); const float newPixelH = pvpH * splitPos; const float oldPixelH = pvpH * node->split; if( int( fabs(newPixelH - oldPixelH) ) < node->resistance2i.y( )) splitPos = node->split; else node->split = splitPos; LBLOG( LOG_LB2 ) << "Constrained split " << vp << " at Y " << splitPos << std::endl; Viewport childVP = vp; childVP.h = (splitPos - vp.y); _computeSplit( node->left, leftTime, datas, childVP, range ); childVP.y = childVP.getYEnd(); childVP.h = end - childVP.y; while( childVP.getYEnd() < end ) childVP.h += std::numeric_limits< float >::epsilon(); _computeSplit( node->right, time - leftTime, datas, childVP, range); break; } case MODE_DB: { LBASSERT( vp == Viewport::FULL ); float splitPos = range.start; const float end = range.end; while( timeLeft > std::numeric_limits< float >::epsilon() && splitPos < end ) { LBLOG( LOG_LB2 ) << timeLeft << "ms left using " << workingSet.size() << " tiles" << std::endl; // remove all irrelevant items from working set for( LBDatas::iterator i = workingSet.begin(); i != workingSet.end(); ) { const Data& data = *i; if( data.range.end > splitPos ) ++i; else i = workingSet.erase( i ); } if( workingSet.empty( )) break; // find next 'discontinouity' in loads float currentPos = 1.0f; for( LBDatas::const_iterator i = workingSet.begin(); i != workingSet.end(); ++i ) { const Data& data = *i; currentPos = LB_MIN( currentPos, data.range.end ); } const float size = currentPos - splitPos; LBASSERTINFO( size > 0.f, currentPos << "<=" << splitPos ); LBASSERT( currentPos <= 1.0f ); // accumulate normalized load in splitPos...currentPos LBLOG( LOG_LB2 ) << "Computing load in range " << splitPos << "..." << currentPos << std::endl; float currentTime = 0.f; for( LBDatas::const_iterator i = workingSet.begin(); i != workingSet.end(); ++i ) { const Data& data = *i; if( data.range.start >= currentPos ) // not yet needed data break; #if 0 // make sure we cover full area LBASSERTINFO( data.range.start <= splitPos, data.range.start << " > " << splitPos ); LBASSERTINFO( data.range.end >= currentPos, data.range.end << " < " << currentPos); #endif currentTime += data.time * size / data.range.getSize(); } LBLOG( LOG_LB2 ) << splitPos << "..." << currentPos << ": t=" << currentTime << " of " << timeLeft << std::endl; if( currentTime >= timeLeft ) // found last region { const float width = currentPos - splitPos; splitPos += (width * timeLeft / currentTime ); timeLeft = 0.0f; } else { timeLeft -= currentTime; splitPos = currentPos; } } LBLOG( LOG_LB2 ) << "Should split at " << splitPos << std::endl; if( getDamping() < 1.f ) splitPos = (1.f - getDamping( )) * splitPos + getDamping() * node->split; LBLOG( LOG_LB2 ) << "Dampened split at " << splitPos << std::endl; const float boundary( node->boundaryf ); if( node->left->resources == 0.f ) splitPos = range.start; else if( node->right->resources == 0.f ) splitPos = end; const uint32_t ratio = static_cast< uint32_t > ( splitPos / boundary + .5f ); splitPos = ratio * boundary; if( (splitPos - range.start) < boundary ) splitPos = range.start; if( (end - splitPos) < boundary ) splitPos = end; if( fabs( splitPos - node->split ) < node->resistancef ) splitPos = node->split; else node->split = splitPos; LBLOG( LOG_LB2 ) << "Constrained split " << range << " at pos " << splitPos << std::endl; Range childRange = range; childRange.end = splitPos; _computeSplit( node->left, leftTime, datas, vp, childRange ); childRange.start = childRange.end; childRange.end = range.end; _computeSplit( node->right, time - leftTime, datas, vp, childRange); break; } default: LBUNIMPLEMENTED; } }
void THPalette::_assign(THRenderTarget* pTarget) const { _assign(pTarget->getRawSurface()); }
RString::RString(const MString& s) : owned(nullptr) { _assign(s.begin(), s.end()); }
RString::RString(XPair p) : owned(nullptr) { _assign(p.begin(), p.end()); }
// -------------------------------------------------------------------------------- // 히스토리: 2011-07-07 이태훈 개발 완료 // -------------------------------------------------------------------------------- NE_DLL NEModule::NEModule(const NEModule& source) : NENamedUnit(source), _is_argument_fetched(false), _owner(0x00), _index(NE_INDEX_ERROR) { _assign(source); }
Matrix& Matrix::operator=(const Matrix& x) { return _assign(*this,x); }
Resource(const ThisClass& source) : SuperClass(source) { _assign(source); }
////////////// // Mutators // ////////////// ray& ray::operator=(const ray& r) { _assign(r); return *this; }
Affine2Vector& Affine2Vector::operator=(const IntervalVector& x) { return _assign(*this,x); }
////////////// // Operator // ////////////// bilinearTexturedAlbedo& bilinearTexturedAlbedo::operator=(const bilinearTexturedAlbedo& bta) { _assign(bta); return *this; }
IntervalMatrix& IntervalMatrix::operator=(const IntervalMatrix& x) { resize(x.nb_rows(), x.nb_cols()); // need to be resized when called from operator*= (dimension can change) return _assign(*this,x); }
// --------------------------------------------------------------------------------- // 히스토리: 2011-07-07 이태훈 개발 완료 // --------------------------------------------------------------------------------- NE_DLL NEExportable::Identifier::Identifier(const Identifier& source) :NEObject(source) { _assign(source); }
const NEComponent NE_DLL &NEComponent::operator=(const NEComponent& source) { return _assign(source); }
// --------------------------------------------------------------------------------- // 히스토리: 2011-07-07 이태훈 개발 완료 // --------------------------------------------------------------------------------- const NEExportable::Identifier NE_DLL &NEExportable::Identifier::operator=(const Identifier& source) { return _assign(source); }
// --------------------------------------------------------------------------------- // 히스토리: 2011-07-07 이태훈 개발 완료 // --------------------------------------------------------------------------------- const Kernal NE_DLL &Kernal::operator=(const Kernal& source) { NEModule::operator=(source); return _assign(source); }
//----------------------------------------------------------------------------- bool Conf::load(const char* cfgFile) { FILE* pf; char locations[512]; ::sprintf(locations,"/etc/%s",cfgFile); pf = _ttfopen(locations, "rb"); if(pf) goto done; ::sprintf(locations,"/home/%s/.%s",getenv("USER"),cfgFile); pf = _ttfopen(locations, "rb"); if(pf) goto done; pf = _ttfopen(cfgFile, "rb"); done: if(pf) { AutoCall<int (*)(FILE*), FILE*> _a(::fclose, pf); char pred[128]; char val[128]; char line[512]; bool in_comment = false; try { while(!::feof(pf)) { if(::fgets(line,512,pf)) { ::str_prepline(line); if(*line==0) continue; if(in_comment || *line=='#') continue; const char* pnext = ::str_ccpy(pred, line,'='); if(*pred=='[') { str_lrtim(pred); _section = pred; continue; } else if(*pred=='}') { _assign("}", " ", 0); } if(pnext && *pnext) { ::str_scpy(val, (char*)pnext+1, "#"); ::str_lrtim(val); ::str_lrtim(pred); //cheak the logs folder if(pred[0]=='l') _bind(pred, "logs_path", _logs_path, val); _assign(pred, val, 0); } } else break; if(feof(pf)) { break; } } } catch(int& err) { ;//noting } } else { printf( "Cannot find configuration file in any of /etc/, ~/. and ./. \r\n"); //exit(0); } return finalize(); }
/////////////// // Operators // /////////////// vec2d& vec2d::operator=(const vec2d& v) { _assign(v); return *this; }
/////////////// // Operators // /////////////// sceneGraphNode& sceneGraphNode::operator=(const sceneGraphNode& node) { _assign(node); return *this; }