Reference Scope:: get_reference(const std::string& name, bool create_when_found_not) { auto ptr = get_pointer(name); if(ptr) { return Reference(space,ptr.data); } else if(create_when_found_not) { auto ln = space.make_object(); ln.name = name; link_table.emplace_back(std::move(ln)); return Reference(space,ln.index); } throw Exception("参照が見つかりませんでした"); }
bool DeclReferencer::VisitCXXConstructExpr(const clang::CXXConstructExpr *E) { auto ConstructedType = E->getType(); if (!ConstructedType.isNull()) Reference(ConstructedType.getTypePtr()); return Reference(E->getConstructor()); }
Directory_MTP *Device::GeneratePartialDirectory( Signal &sig, uint32_t storageId, const char *pathName, const char **pPathNamePartial) const { const char *p = pathName; if (IsFileSeparator(*p)) p++; *pPathNamePartial = p; Directory_MTP *pDirectory = new Directory_MTP( nullptr, "/", Directory::TYPE_Container, Reference(), storageId, LIBMTP_FILES_AND_FOLDERS_ROOT, new Stat("", "", 0, DateTime(), LIBMTP_FILETYPE_FOLDER)); while (*p != '\0') { if (!pDirectory->IsContainer()) { sig.SetError(ERR_IOError, "can't browse inside an item"); return nullptr; } String field; for ( ; ; p++) { if (*p == '\0') { break; } else if (IsFileSeparator(*p)) { p++; break; } field += *p; } if (field.empty()) { sig.SetError(ERR_FormatError, "wrong format of path name"); return nullptr; } //::printf("[%s]\n", field.c_str()); LIBMTP_file_t *mtpfileHead = ::LIBMTP_Get_Files_And_Folders(_mtpDevice, storageId, pDirectory->GetItemId()); if (mtpfileHead == nullptr) { ::LIBMTP_Dump_Errorstack(_mtpDevice); ::LIBMTP_Clear_Errorstack(_mtpDevice); sig.SetError(ERR_LibraryError, "failed to get file information from MTP"); return nullptr; } LIBMTP_file_t *mtpfileFound = nullptr; for (LIBMTP_file_t *mtpfile = mtpfileHead; mtpfile != nullptr; mtpfile = mtpfile->next) { if (field == mtpfile->filename) { mtpfileFound = mtpfile; break; } } if (mtpfileFound == nullptr) { DestroyMtpfileList(mtpfileHead); break; } *pPathNamePartial = p; pDirectory = new Directory_MTP( pDirectory, mtpfileFound->filename, (mtpfileFound->filetype == LIBMTP_FILETYPE_FOLDER)? Directory::TYPE_Container : Directory::TYPE_Item, Reference(), storageId, mtpfileFound->item_id, new Stat(pDirectory->MakePathName(false).c_str(), mtpfileFound)); DestroyMtpfileList(mtpfileHead); } return pDirectory; }
TPZIntelGen<TSHAPE>::~TPZIntelGen(){ if(Reference()) { if(Reference()->Reference()) { RemoveSideRestraintsII(EDelete); } Reference()->ResetReference(); } }
bool DeclReferencer::VisitCXXDeleteExpr(const clang::CXXDeleteExpr *E) { auto DestroyedType = E->getDestroyedType(); if (!DestroyedType.isNull()) Reference(DestroyedType.getTypePtr()); return Reference(E->getOperatorDelete()); }
// Same as function TransformGraphicShapesWithClearanceToPolygonSet but // this only render text void MODULE::TransformGraphicTextWithClearanceToPolygonSet( PCB_LAYER_ID aLayer, SHAPE_POLY_SET& aCornerBuffer, int aInflateValue, int aError ) const { std::vector<TEXTE_MODULE *> texts; // List of TEXTE_MODULE to convert for( EDA_ITEM* item = GraphicalItemsList(); item != NULL; item = item->Next() ) { switch( item->Type() ) { case PCB_MODULE_TEXT_T: { TEXTE_MODULE* text = static_cast<TEXTE_MODULE*>( item ); if( text->GetLayer() == aLayer && text->IsVisible() ) texts.push_back( text ); break; } case PCB_MODULE_EDGE_T: // This function does not render this break; default: break; } } // Convert texts sur modules if( Reference().GetLayer() == aLayer && Reference().IsVisible() ) texts.push_back( &Reference() ); if( Value().GetLayer() == aLayer && Value().IsVisible() ) texts.push_back( &Value() ); prms.m_cornerBuffer = &aCornerBuffer; for( unsigned ii = 0; ii < texts.size(); ii++ ) { TEXTE_MODULE *textmod = texts[ii]; prms.m_textWidth = textmod->GetThickness() + ( 2 * aInflateValue ); prms.m_error = aError; wxSize size = textmod->GetTextSize(); if( textmod->IsMirrored() ) size.x = -size.x; DrawGraphicText( NULL, NULL, textmod->GetTextPos(), BLACK, textmod->GetShownText(), textmod->GetDrawRotation(), size, textmod->GetHorizJustify(), textmod->GetVertJustify(), textmod->GetThickness(), textmod->IsItalic(), true, addTextSegmToPoly, &prms ); } }
void Device::LookupStorages(Object_list *pObjList) const { LIBMTP_devicestorage_t *deviceStorage = _mtpDevice->storage; for ( ; deviceStorage != nullptr; deviceStorage = deviceStorage->next) { pObjList->Add(Value(new Object_storage(new Storage(Reference(), deviceStorage)))); } }
void DeclReferencer::ReferenceTemplateArguments(const clang::NamedDecl *D) { const clang::TemplateArgumentList *InstArgs = nullptr; if (auto Func = dyn_cast<clang::FunctionDecl>(D)) InstArgs = Func->getTemplateSpecializationArgs(); if (!InstArgs) return; for (auto& Arg: InstArgs->asArray()) { switch (Arg.getKind()) { case clang::TemplateArgument::Expression: TraverseStmt(Arg.getAsExpr()); break; case clang::TemplateArgument::Type: Reference(Arg.getAsType().getTypePtr()); break; case clang::TemplateArgument::Template: // TODO break; default: break; } } }
bool DeclReferencer::VisitDeclRef(const clang::NamedDecl *D) { if (isa<clang::FunctionDecl>(D) || isa<clang::VarDecl>(D)) return Reference(D); return true; }
inline Reference Reference::operator[](const Constant& index) const { SFun_Reference_Impl* pResult = SFun_Reference_op_subscript_C( fpImpl, index.getImpl()); return Reference(pResult); }
CCXMLWrapper::CCXMLWrapper (CXMLElement *pXML, ICCItem *pRef) : ICCAtom(NULL) // CCXMLWrapper constructor { ASSERT(pXML); // If we have a reference, then we don't need a copy. if (pRef) { m_pXML = pXML; m_pRef = pRef->Reference(); } // Otherwise, we need a copy else { m_pXML = pXML->OrphanCopy(); m_pRef = NULL; } Reference(); }
static void mapping(IO &IO, FunctionInfo &I) { SymbolInfoMapping(IO, I); IO.mapOptional("IsMethod", I.IsMethod, false); IO.mapOptional("Parent", I.Parent, Reference()); IO.mapOptional("Params", I.Params); IO.mapOptional("ReturnType", I.ReturnType); IO.mapOptional("Access", I.Access, clang::AccessSpecifier::AS_none); }
ModelObjectsTemp TransformationSymmetry::do_get_inputs( kernel::Model *m, const kernel::ParticleIndexes &pis) const { kernel::ModelObjectsTemp ret = IMP::kernel::get_particles(m, pis); for (unsigned int i = 0; i < pis.size(); ++i) { ret.push_back(Reference(m, pis[i]).get_reference_particle()); } return ret; }
bool DeclReferencer::Reference(const clang::Type *T) { if (auto TT = T->getAs<clang::TagType>()) if (!TT->isUnionType()) Reference(TT->getDecl()); return true; }
inline Reference CodeConstructor::createLocal(const Type& dataType, const char* name) { SFun_Reference_Impl* pResult = SFun_Block_createLocal_T_c( fpImpl, dataType.getImpl(), name); return Reference(pResult); }
void TransformationSymmetry::apply_index(kernel::Model *m, kernel::ParticleIndex pi) const { set_was_used(true); if (RigidBody::get_is_setup(m, pi)) { RigidBody rrb(Reference(m, pi).get_reference_particle()); RigidBody rb(m, pi); // We do the non-lazy version in order as it is hard // for the dependency checker to get the dependencies right // Is it really? We should check this. rb.set_reference_frame_lazy(algebra::ReferenceFrame3D( t_ * rrb.get_reference_frame().get_transformation_to())); } else { XYZ rd(Reference(m, pi).get_reference_particle()); XYZ d(m, pi); d.set_coordinates(t_.get_transformed(rd.get_coordinates())); } }
TTime DateTimeToSymbian(datetime_t Time) { // reference is 1st January 2001 00:00:00.000 UTC TTime Reference(ToInt64(LL(0x00e05776f452a000))); TTimeIntervalSeconds Diff; Diff = Time; return Reference + Diff; }
void TransformationAndReflectionSymmetry::apply_index( kernel::Model *m, kernel::ParticleIndex pi) const { IMP_USAGE_CHECK(!RigidBody::get_is_setup(m, pi), "Particle must not be a rigid body particle"); set_was_used(true); XYZ rd(Reference(m, pi).get_reference_particle()); XYZ d(m, pi); d.set_coordinates(t_.get_transformed(r_.get_reflected(rd.get_coordinates()))); }
ICCItem *CCNil::Clone (CCodeChain *pCC) // Clone // // Returns a new item with a single ref-count { return Reference(); }
ModelObjectsTemp TransformationAndReflectionSymmetry::do_get_inputs( kernel::Model *m, const kernel::ParticleIndexes &pis) const { kernel::ModelObjectsTemp ret(2 * pis.size()); for (unsigned int i = 0; i < pis.size(); ++i) { ret[2 * i + 0] = m->get_particle(pis[i]); ret[2 * i + 0] = Reference(m, pis[i]).get_reference_particle(); } return ret; }
virtual void Serialize( Serializer & s ) { if( s.IsSerialized( this )) return; s & this; s & mName; s & Reference( this, mParent, MemberOffset<SceneNode>( &SceneNode::mParent )); s & mChildren; s & mProperties; }
Reference access(boost::type<Reference>,index idx,TPtr base, const size_type* extents, const index* strides, const index* index_base) const { // return a sub_array<T,NDims-1> proxy object TPtr newbase = base + idx * strides[0]; return Reference(newbase,extents+1,strides+1,index_base+1); }
Reference Manager::get( const std::string& filename ) { auto it = resources.find( filename ); if ( it == resources.end() ) { it = resources.emplace( std::make_pair( filename, std::unique_ptr< Data >() ) ).first; it->second.reset( new Data( ( * this ), filename ) ); } return Reference( it->second.get() ); }
void ViewWidget::handleReference(int ref_idx) { try { Reference ref; //Creating a reference to a column if(static_cast<unsigned>(ref_type_cmb->currentIndex())==Reference::REFER_COLUMN) { ref=Reference(dynamic_cast<Table *>(table_sel->getSelectedObject()), dynamic_cast<Column *>(column_sel->getSelectedObject()), tab_alias_edt->text().toUtf8(), col_alias_edt->text().toUtf8()); } //Creating a reference to an expression else { ref=Reference(expression_txt->toPlainText(), expr_alias_edt->text().toUtf8()); } /* The reference must have an SQL application (be between SELECT-FROM, FROM-WHERE or after WHERE), if the user do not check some of these attributes raises an error */ if(!select_from_chk->isChecked() && !from_where_chk->isChecked() && !after_where_chk->isChecked()) throw Exception(ERR_SQL_SCOPE_INV_VIEW_REF,__PRETTY_FUNCTION__,__FILE__,__LINE__); showReferenceData(ref, select_from_chk->isChecked(), from_where_chk->isChecked(), after_where_chk->isChecked(), ref_idx); clearReferenceForm(); references_tab->clearSelection(); } catch(Exception &e) { if(references_tab->getCellText(ref_idx, 0).isEmpty()) references_tab->removeRow(ref_idx); throw Exception(e.getErrorMessage(),e.getErrorType(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e); } }
Reference access(boost::type<Reference>,index idx,TPtr base, const size_type* extents, const index* strides, const index* index_bases) const { BOOST_ASSERT(idx - index_bases[0] >= 0); BOOST_ASSERT(size_type(idx - index_bases[0]) < extents[0]); // return a sub_array<T,NDims-1> proxy object TPtr newbase = base + idx * strides[0]; return Reference(newbase,extents+1,strides+1,index_bases+1); }
void TPZMultiphysicsElement::CreateInterfaces() { //nao verifica-se caso o elemento de contorno //eh maior em tamanho que o interface associado //caso AdjustBoundaryElement nao for aplicado //a malha eh criada consistentemente TPZGeoEl *ref = Reference(); int nsides = ref->NSides(); int InterfaceDimension = Mesh()->Dimension() - 1; int side; nsides--;//last face for(side=nsides;side>=0;side--) { if(ref->SideDimension(side) != InterfaceDimension) continue; TPZCompElSide thisside(this,side); if(this->ExistsInterface(side)) { // cout << "TPZCompElDisc::CreateInterface inconsistent: interface already exists\n"; continue; } TPZStack<TPZCompElSide> highlist; thisside.HigherLevelElementList(highlist,0,1); //a interface se cria uma vez so quando existem ambos //elementos esquerdo e direito (compu tacionais) if(!highlist.NElements()) { this->CreateInterface(side);//s�tem iguais ou grande => pode criar a interface } else { int64_t ns = highlist.NElements(); int64_t is; for(is=0; is<ns; is++) {//existem pequenos ligados ao lado atual const int higheldim = highlist[is].Reference().Dimension(); if(higheldim != InterfaceDimension) continue; // TPZCompElDisc *del = dynamic_cast<TPZCompElDisc *> (highlist[is].Element()); // if(!del) continue; TPZCompEl *del = highlist[is].Element(); if(!del) continue; TPZCompElSide delside( del, highlist[is].Side() ); TPZMultiphysicsElement * delSp = dynamic_cast<TPZMultiphysicsElement *>(del); if (!delSp){ PZError << "\nERROR AT " << __PRETTY_FUNCTION__ << " - CASE NOT AVAILABLE\n"; return; } if ( delSp->ExistsInterface(highlist[is].Side()) ) { // cout << "TPZCompElDisc::CreateInterface inconsistent: interface already exists\n"; } else { delSp->CreateInterface(highlist[is].Side()); } } } } }
void Metadata::addReference(const std::shared_ptr<Metadata>& md, const std::string& refName) { if (md == nullptr) VMF_EXCEPTION(NullPointerException, "Metadata is nullptr!" ); if (md->getId() == INVALID_ID) VMF_EXCEPTION(IncorrectParamException, "Metadata has to be added into stream before being referenced!" ); if (m_pStream != nullptr && md->m_pStream != m_pStream) VMF_EXCEPTION(IncorrectParamException, "Referenced metadata is from different metadata stream." ); if (isReference(md, refName)) VMF_EXCEPTION(IncorrectParamException, "This reference already exist."); auto spRefDesc = m_spDesc->getReferenceDesc(refName); if (!spRefDesc) VMF_EXCEPTION(IncorrectParamException, "No such reference description."); if (spRefDesc->isUnique) { auto mdSet = getReferencesByName(refName); auto itemsExist = mdSet.size(); if (itemsExist == 0) { m_vReferences.emplace_back(Reference(spRefDesc, md)); } else VMF_EXCEPTION(IncorrectParamException, "Unique reference with this name already exists"); } else { m_vReferences.emplace_back(Reference(spRefDesc, md)); } return; }
datetime_t SymbianToDateTime(TTime Time) { // reference is 1st January 2001 00:00:00.000 UTC datetime_t Date = INVALID_DATETIME_T; TTime Reference(ToInt64(LL(0x00e05776f452a000))); TTimeIntervalSeconds Diff; if (Time.SecondsFrom(Reference,Diff) == KErrNone) { Date = Diff.Int(); if (Date==INVALID_DATETIME_T) ++Date; } return Date; }
Directory *Directory_MTP::DoNext(Environment &env) { if (_browsePack.mtpfileHead == nullptr) { _browsePack.mtpfileHead = ::LIBMTP_Get_Files_And_Folders(_pDevice->GetMtpDevice(), _storageId, _itemId); _browsePack.mtpfile = _browsePack.mtpfileHead; } else { _browsePack.mtpfile = _browsePack.mtpfile->next; } if (_browsePack.mtpfile == nullptr) return nullptr; Type type = (_browsePack.mtpfile->filetype == LIBMTP_FILETYPE_FOLDER)? TYPE_Container : TYPE_Item; return new Directory_MTP( Reference(), _browsePack.mtpfile->filename, type, _pDevice->Reference(), _storageId, _browsePack.mtpfile->item_id, new Stat(MakePathName(false).c_str(), _browsePack.mtpfile)); }
Reference Repository::head() const { git_reference * head; switch (auto error = git_repository_head(&head, repo_)) { case GIT_EUNBORNBRANCH: throw non_existing_branch_error(); case GIT_ENOTFOUND: throw missing_head_error(); default: if (error == 0) return Reference(head); else throw unknown_get_current_branch_error(); } }