Ejemplo n.º 1
0
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("参照が見つかりませんでした");
}
Ejemplo n.º 2
0
bool DeclReferencer::VisitCXXConstructExpr(const clang::CXXConstructExpr *E)
{
    auto ConstructedType = E->getType();
    if (!ConstructedType.isNull())
        Reference(ConstructedType.getTypePtr());
    return Reference(E->getConstructor());
}
Ejemplo n.º 3
0
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;
}
Ejemplo n.º 4
0
TPZIntelGen<TSHAPE>::~TPZIntelGen(){
	if(Reference()) {
		if(Reference()->Reference()) {
			RemoveSideRestraintsII(EDelete);
		}
		Reference()->ResetReference();
	}
}
Ejemplo n.º 5
0
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 );
    }

}
Ejemplo n.º 7
0
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))));
	}
}
Ejemplo n.º 8
0
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;
        }
    }
}
Ejemplo n.º 9
0
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);
 }
Ejemplo n.º 11
0
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();
	}
Ejemplo n.º 12
0
 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);
 }
Ejemplo n.º 13
0
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;
}
Ejemplo n.º 14
0
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);
 }
Ejemplo n.º 16
0
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()));
  }
}
Ejemplo n.º 17
0
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;
}
Ejemplo n.º 18
0
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())));
}
Ejemplo n.º 19
0
ICCItem *CCNil::Clone (CCodeChain *pCC)

//	Clone
//
//	Returns a new item with a single ref-count

	{
	return Reference();
	}
Ejemplo n.º 20
0
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;
}
Ejemplo n.º 21
0
	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;
	}
Ejemplo n.º 22
0
  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);

  }
Ejemplo n.º 23
0
	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() );
	}
Ejemplo n.º 24
0
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);
	}
}
Ejemplo n.º 25
0
  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);

  }
Ejemplo n.º 26
0
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());
                }
            }
        }
    }
}
Ejemplo n.º 27
0
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;
}
Ejemplo n.º 28
0
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;
}
Ejemplo n.º 29
0
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));
}
Ejemplo n.º 30
0
 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();
     }
 }