Types SimpleBinaryOperation::allowedTypes(int _index) const { if (_index == FirstOperand || _index == SecondOperand) { if (!m_symbolCache) return Types(); // mDebug() << prototypeOf(FirstOperand)->code() << prototypeOf(SecondOperand)->code() << " " << _index << " " << typeOf(FirstOperand)->code(); if (_index == SecondOperand && prototypeOf(SecondOperand).isUltimatelyNull() && !typeOf(FirstOperand).isNull()) return typeOf(FirstOperand).strippedTo(prototypeOf(SecondOperand)); if (_index == SecondOperand && prototypeOf(SecondOperand).isUltimatelyNull()) return Types(); AssertNR(!prototypeOf(_index).isNull()); return prototypeOf(_index); } return Super::allowedTypes(_index); }
soem_SGDV::soem_SGDV(std::string const& name): soem_slave(name), configmyDC("configmyDC"),useDC(true), SYNC0TIME(1000000),SHIFT(125000),SHIFTMASTER(1000000),PDOerrorsTolerance(9) { this->addProperty("useDC",useDC).doc("To configure the slave to use DC"); this->addProperty("SYNC0TIME",SYNC0TIME).doc("The period of the sync0 events expressed [ns]"); this->addProperty("SHIFT",SHIFT).doc("The shift of the outputs in the slave [ns]"); this->addProperty("SHIFTMASTER",SHIFTMASTER).doc("The shift of the master [ns]"); this->addProperty("PDOerrorsTolerance",PDOerrorsTolerance).doc("Tolerance of not received PDO when DCsync0active"); this->requires()->addOperationCaller(configmyDC); Types()->addType(new PDOportTypeInfo()); target.Speed=0; target.Torque=0; this->getProvider<Marshalling>("marshalling"); this->addPort("actualPDO", actualPDO).doc("The actual values from the drivers"); this->addPort("targetPDO", targetPDO).doc("The targets from platform"); Logger::log(Logger::Info) << soem_SGDV::getName()<<" Constructed" <<endlog(); }
THIS::THIS(XmlElement* h):Element(h){ /* attributes */ createAttribute(attrib_id,"id"); createAttribute(attrib_name,"name"); /** children**/ buildChildren(Types()); /** other **/ Bool_array* bool_array =0; Float_array* float_array =0; IDREF_array* idref_array =0; Int_array* int_array =0; Name_array* name_array =0; SIDREF_array* sidref_array =0; Token_array* token_array =0; if(queryElement(bool_array)){type = BOOL_ARRAY;} if(queryElement(float_array)){type = FLOAT_ARRAY;} if(queryElement(idref_array)){type = IDREF_ARRAY;} if(queryElement(int_array)){type = INT_ARRAY;} if(queryElement(name_array)){type = NAME_ARRAY;} if(queryElement(sidref_array)){type = SIDREF_ARRAY;} if(queryElement(token_array)){type = TOKEN_ARRAY;} }
NS_IMETHODIMP DataTransfer::GetTypes(nsISupports** aTypes) { *aTypes = Types().get(); return NS_OK; }
THIS::THIS(XmlElement* h):Element(h) { /* children */ buildChildren(Types()); /* attributes */ }
NS_IMETHODIMP DataTransfer::GetTypes(nsISupports** aTypes) { nsRefPtr<DOMStringList> types = Types(); types.forget(aTypes); return NS_OK; }
EnumTypeTest() { a = new ValueDataSource<TheEnum>( A ); b = new ValueDataSource<TheEnum>( B ); Types()->addType( new EnumTypeInfo<TheEnum>("TheEnum") ); }
THIS::THIS(XmlElement* h):Element(h){ /* attributes */ createAttribute(attrib_enable,"enable"); createAttribute(attrib_sid,"sid"); createAttribute(attrib_name,"name"); /* children */ buildChildren(Types()); }
THIS::THIS(XmlElement* h):Element(h){ /* attributes */ createAttribute(attrib_count,"count"); /** children**/ buildChildren(Types()); }
THIS::THIS(XmlElement* h):Element(h) { /* attributes */ createAttribute(attrib_id,"id"); createAttribute(attrib_name,"name"); /** children**/ buildChildren(Types()); }
THIS::THIS(XmlElement* h):Element(h){ /* attributes */ createAttribute(attrib_link,"link"); /* children */ buildChildren(Types()); /* data */ }
THIS::THIS(XmlElement* h):Element(h){ /* attributes */ createAttribute(attrib_name ,"name"); createAttribute(attrib_count,"count"); createAttribute(attrib_material,"material"); /* children */ buildChildren(Types()); }
THIS::THIS(XmlElement* h):Element(h) { /* attributes */ createAttribute(attrib_id,"id"); createAttribute(attrib_platform,"platform"); /* children */ buildChildren(Types()); /* data */ }
THIS::THIS(XmlElement* h):Element(h){ /* attributes */ createAttribute(attrib_ref,"ref"); createAttribute(attrib_pass,"pass"); /* children */ buildChildren(Types()); /* data */ }
/** * Implementation that updates result with the matching parts in source * Relies on the fact that getMember returns a C++ reference to each part of \a result, which is then updated * with a property found in source. */ virtual bool composeTypeImpl(const PropertyBag& source, typename internal::AssignableDataSource<T>::reference_t result) const { // The default implementation decomposes result and refreshes it with source. TypeInfoRepository::shared_ptr tir = Types(); internal::ReferenceDataSource<T> rds(result); rds.ref(); // prevent dealloc. PropertyBag decomp; // only try refreshProperties if decomp's type is equal to source type. // update vs refresh: since it is intentional that the decomposition leads to references to parts of result, // only refreshProperties() is meaningful (ie we have a one-to-one mapping). In case of sequences, this would // of course not match, so this is struct specific. return typeDecomposition( &rds, decomp, false) && ( tir->type(decomp.getType()) == tir->type(source.getType()) ) && refreshProperties(decomp, source); }
THIS::THIS(XmlElement* h):Element(h){ /* attributes */ createAttribute(attrib_texture,"texture"); createAttribute(attrib_texcoord,"texcoord"); /* children */ buildChildren(Types()); /* data */ }
THIS::THIS(XmlElement* h):Element(h){ /* attributes */ /* children */ buildChildren(Types()); /* data */ if(handle){ data = handle->getText(); } }
void Declarations() { while(strchr("lctvpf", Look)) { switch(Look) { case 'l': Labels(); case 'c': Constants(); case 't': Types(); case 'v': Variables(); case 'p': DoProcedure(); case 'f': DoFunction(); } } }
THIS::THIS(XmlElement* h):Element(h){ /* attributes */ createAttribute(attrib_source,"source"); createAttribute(attrib_operand,"operand",Enum::SRC_ALPHA); createAttribute(attrib_sampler,"sampler"); /* children */ buildChildren(Types()); /* data */ }
THIS::THIS(XmlElement* h):Element(h){ /* attributes */ createAttribute(attrib_index,"index"); createAttribute(attrib_slice,"slice"); createAttribute(attrib_mip,"mip"); createAttribute(attrib_face,"face"); /* children */ buildChildren(Types()); /* data */ }
THIS::THIS(XmlElement* h):Element(h){ /* attributes */ createAttribute(attrib_sid,"sid"); createAttribute(attrib_name,"name"); createAttribute(attrib_constraint,"constraint"); /* children */ buildChildren(Types()); /* data */ }
THIS::THIS(XmlElement* h):Element(h){ /* attributes */ /* children */ buildChildren(Types()); /* data */ XmlElement* element = handle; if(element){ Utils::fromString(data,element->getText()); } }
void Declarations(){ int other = 0; while(!other){ switch(Look){ case 'l' : Labels(); break; case 'c' : Constants(); break; case 't' : Types(); break; case 'v' : Variables(); break; case 'p' : DoProcedure(); break; case 'f' : DoFunction(); break; default : other = 1; } } }
Interactor* Builder::TypeSizeControls () { Tray* t = new Tray; Interactor* typeLabel = TypeLabel(); Interactor* types = Types(); Interactor* sizeLabel = SizeLabel(); Interactor* sizes = Sizes(); t->HBox(t, typeLabel, hgap(), types, new HGlue, t); t->HBox(t, sizeLabel, hgap(), sizes, new HGlue, t); t->Align(Left, types, sizes); t->VBox(t, typeLabel, vspc(), sizeLabel, t); t->Align(VertCenter, typeLabel, types); t->Align(VertCenter, sizeLabel, sizes); return t; }
THIS::THIS(XmlElement* h):Element(h){ /* attributes */ if(handle){ std::string str; str = handle->getText(); if(str == "true"){ attrib_closed = true; } else{ attrib_closed = false; } } /* children */ buildChildren(Types()); }
Types SubscriptOperation::allowedTypes(int _index) const { if (_index == FirstOperand) { return SubscriptableRegistrar::get()->m_acceptable.values(); } else if (_index == SecondOperand) { Type lt = leftType(); if (Subscriptable* s = lt->tryType<Subscriptable>()) { Types ts = s->subscriptTypes(); ts.replace(Type(), Type(Unsigned|Int)); return ts; } return Types(); } return Super::allowedTypes(_index); }
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - void VariableAnalysis::InsertAggregateCandidates(OperandVariableDict& dict, const VariableList& varList) { auto unit = funct_->ParentUnit(); for(int i = 0; i < varList.Count(); i++) { auto variable = varList[i]; if((variable->IsArray() || variable->IsRecord() || variable->IsPointer()) == false) { continue; } variable->SetIsAddresTaken(false); // Presume it's not. auto variableRefType = unit->Types().GetPointer(variable->GetType()); auto variableRef = unit->References().GetVariableRef(variable, variableRefType); dict.Add(variableRef, OVPair(variableRef, variable)); } }
bool composeTemplateProperty(const PropertyBag& bag, T& result) { TypeInfoRepository::shared_ptr tir = Types(); if ( tir->type( bag.getType()) == tir->getTypeInfo< T >() ) { Property< typename T::value_type>* comp; int dimension = bag.size(); result.resize( dimension ); // Get values int size_correction = 0; for (int i = 0; i < dimension ; i++) { base::PropertyBase* element = bag.getItem( i ); comp = dynamic_cast< Property< typename T::value_type>* >( element ); if ( comp == 0 ) { // detect LEGACY element: if ( element->getName() == "Size" ) { // oops, our result vector will be one smaller. size_correction += 1; continue; } Logger::log() << Logger::Error << "Aborting composition of Property< T > " << ": Exptected data element "<< i << " to be of type " << internal::DataSourceTypeInfo< typename T::value_type>::getTypeName() <<" got type " << element->getType() <<Logger::endl; return false; } result[ i - size_correction ] = comp->get(); } result.resize( dimension - size_correction ); } else { Logger::log() << Logger::Error << "Composing Property< T > :" << " type mismatch, got type '"<< bag.getType() << "', expected 'vector<" << internal::DataSourceTypeInfo< typename T::value_type>::getTypeName() <<">'."<<Logger::endl; return false; } return true; }
THIS::THIS(XmlElement* h):Element(h){ /* attributes */ /* children */ buildChildren(Types()); /* data */ XmlElement* element = handle; if(element){ std::string str = element->getText(); /*remove spaces*/ while(str.find(" ") != std::string::npos) { str.replace(str.find(" "), 1, ""); } /*default*/ data = Enum::LINEAR; if(str == "NEAREST"){ data = Enum::NEAREST; } } }