int linkedlist::countInType(char *type) { if (getTypeId(type) == -1) return -1; else return objects[getTypeId(type)]; }
//------------------------------------------------------------------------------ // computeHashValue() -- Compute a hash value for this block //------------------------------------------------------------------------------ unsigned int Block::computeHashValue(const unsigned int, const unsigned int rehashCount) const { unsigned int i; unsigned int a = 111; unsigned int b = 222; unsigned int c = 333; for (i = 0; i < rehashCount; i++) { //a *= blockIndex; a *= getTypeId(); b *= x; c *= y; } b *= (x+1); b += x; c *= y; c *= (y+1); c += y; a += x; b += y; c += getTypeId(); a += y; b += getTypeId(); c += x; return a*b*c+a+b+c; }
const bool BiffRecord::read(CFStreamCacheReader& reader, BaseObject* parent, const bool is_mandatory) { parent_ = parent; // Find and read the required record CFRecordPtr record = reader.getNextRecord(getTypeId(), is_mandatory); if(!record) { return false; // Required record hasn't been found } readFollowingContinue(reader); if(storeRecordAndDecideProceeding(record)) { // Read fields data readFields(*record); // defined in derived classes size_t dataSize = record->getDataSize(); size_t rdPtr = record->getRdPtr(); size_t typeId = getTypeId(); if(record->getDataSize() != record->getRdPtr() && getTypeId() != rt_ANY_TYPE) { Log::warning(STR::int2str(record->getDataSize() - record->getRdPtr(), 10) + " unsigned chars were not processed while reading from " + record->getTypeString()); } parent->add_child(this->clone()); } return true; // Record reading OK }
// Called for each instruction that resides in a block. void Builder::postProcess(const Instruction& inst) { // Add capabilities based simply on the opcode. switch (inst.getOpCode()) { case OpExtInst: switch (inst.getImmediateOperand(1)) { case GLSLstd450InterpolateAtCentroid: case GLSLstd450InterpolateAtSample: case GLSLstd450InterpolateAtOffset: addCapability(CapabilityInterpolationFunction); break; default: break; } break; case OpDPdxFine: case OpDPdyFine: case OpFwidthFine: case OpDPdxCoarse: case OpDPdyCoarse: case OpFwidthCoarse: addCapability(CapabilityDerivativeControl); break; case OpImageQueryLod: case OpImageQuerySize: case OpImageQuerySizeLod: case OpImageQuerySamples: case OpImageQueryLevels: addCapability(CapabilityImageQuery); break; #ifdef NV_EXTENSIONS case OpGroupNonUniformPartitionNV: addExtension(E_SPV_NV_shader_subgroup_partitioned); addCapability(CapabilityGroupNonUniformPartitionedNV); break; #endif default: break; } // Checks based on type if (inst.getTypeId() != NoType) postProcessType(inst, inst.getTypeId()); for (int op = 0; op < inst.getNumOperands(); ++op) { if (inst.isIdOperand(op)) { // In blocks, these are always result ids, but we are relying on // getTypeId() to return NoType for things like OpLabel. if (getTypeId(inst.getIdOperand(op)) != NoType) postProcessType(inst, getTypeId(inst.getIdOperand(op))); } } }
/* * Either initialize an input stream for files that exist on disk * or open a handle through the Sleuthkit for file system files that * have not been written to disk. */ void TskFileTsk::open() { if (m_isOpen) return; // Files inside of the file system if (getTypeId() == TskImgDB::IMGDB_FILES_TYPE_FS) { // Otherwise, we open a handle to the file in ImageFile m_handle = TskServices::Instance().getImageFile().openFile(m_id); if (m_handle == -1) { LOGERROR(L"TskFileTsk::open - Error opening file."); throw TskFileException("Error opening file"); } } else if (getTypeId() == TskImgDB::IMGDB_FILES_TYPE_UNUSED) { if (TskServices::Instance().getImgDB().getUnusedSector(getId(), m_unusedSectorsRecord) == -1) { LOGERROR(L"TskFileTsk::open - Error opening file."); throw TskFileException("Error opening file"); } } // CARVED and DERIVED else if ((getTypeId() == TskImgDB::IMGDB_FILES_TYPE_CARVED) || (getTypeId() == TskImgDB::IMGDB_FILES_TYPE_DERIVED)) { if (exists()) { // Open our input stream if not already open if (m_fileInStream == NULL) { m_fileInStream = new Poco::FileInputStream(m_file.path()); } } else { std::wstringstream msg; msg << L"TskFileTsk::open - Open failed because file id (" << m_id << ") does not exist on disk and is carved or derived."; LOGERROR(msg.str()); throw TskFileException("Error opening file"); } } else { std::wstringstream msg; msg << L"TskFileTsk::open - Open failed because file id (" << m_id << ") has unknown type (" << getTypeId() << ")."; LOGERROR(msg.str()); throw TskFileException("Error opening file"); } m_offset = 0; m_isOpen = true; }
int linkedlist::getTotalSamplesOfType(char *sample, char *type) { if (getTypeId(type) == -1) return -1; linkedList *p = mainData; while (p != NULL) { if (strcmp(p->sampleName, sample) == 0) return p->typeCNT[getTypeId(type)]; p = p->next; } return 0; }
void LayerBase::dump(String8& result, char* buffer, size_t SIZE) const { const Layer::State& s(drawingState()); snprintf(buffer, SIZE, "+ %s %p (%s)\n", getTypeId(), this, getName().string()); result.append(buffer); s.transparentRegion.dump(result, "transparentRegion"); visibleRegion.dump(result, "visibleRegion"); snprintf(buffer, SIZE, " " "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), crop=(%4d,%4d,%4d,%4d), " "isOpaque=%1d, needsDithering=%1d, invalidate=%1d, " "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n", s.layerStack, s.z, s.transform.tx(), s.transform.ty(), s.active.w, s.active.h, s.active.crop.left, s.active.crop.top, s.active.crop.right, s.active.crop.bottom, isOpaque(), needsDithering(), contentDirty, s.alpha, s.flags, s.transform[0][0], s.transform[0][1], s.transform[1][0], s.transform[1][1]); result.append(buffer); }
void av::SingleField<uint64_t>::pullValueImpl(av::Field* fromField) { AV_ASSERT(fromField); if (fieldHasType<uint64_t>(fromField)) { setValue(convertFieldValue<uint64_t, uint64_t>(fromField), fromField); } else if (fieldHasType<int64_t>(fromField)) { setValue(convertFieldValue<int64_t, uint64_t>(fromField), fromField); } else if (fieldHasType<int32_t>(fromField)) { setValue(convertFieldValue<int32_t, uint64_t>(fromField), fromField); } else if (fieldHasType<uint32_t>(fromField)) { setValue(convertFieldValue<uint32_t, uint64_t>(fromField), fromField); } else if (fieldHasType<bool>(fromField)) { setValue(convertFieldValue<bool, uint64_t>(fromField), fromField); } else { throw std::invalid_argument("pullValue: type mismatch. " + getTypeId().getName() + " <--> " + fromField->getTypeId().getName()); } }
SbBool SoAction::isOfType(SoType type) const // //////////////////////////////////////////////////////////////////////// { return getTypeId().isDerivedFrom(type); }
void MWMechanics::AiPackage::evadeObstacles(const MWWorld::Ptr& actor, float duration, const ESM::Position& pos) { zTurn(actor, mPathFinder.getZAngleToNext(pos.pos[0], pos.pos[1])); MWMechanics::Movement& movement = actor.getClass().getMovementSettings(actor); // check if stuck due to obstacles if (!mObstacleCheck.check(actor, duration)) return; // first check if obstacle is a door MWWorld::Ptr door = getNearbyDoor(actor); // NOTE: checks interior cells only if (door != MWWorld::Ptr()) { // note: AiWander currently does not open doors if (getTypeId() != TypeIdWander && !door.getCellRef().getTeleport() && door.getCellRef().getTrap().empty() && door.getCellRef().getLockLevel() <= 0 && door.getClass().getDoorState(door) == 0) { MWBase::Environment::get().getWorld()->activateDoor(door, 1); } } else // any other obstacle (NPC, crate, etc.) { mObstacleCheck.takeEvasiveAction(movement); } }
SoElement* SoXipDepthTestElement::copyMatchInfo() const { FUNCID(""); SoXipDepthTestElement *result = (SoXipDepthTestElement*)getTypeId().createInstance(); return result; }
void av::MultiField<float>::pullValueImpl(av::Field* fromField) { if(fieldHasType<float>(fromField)) { setValue(convertFieldValue<float, float>(fromField), fromField); } else if(fieldHasType<double>(fromField)) { setValue(convertFieldValue<double, float>(fromField), fromField); } else if(fieldHasType<int32_t>(fromField)) { setValue(convertFieldValue<int32_t, float>(fromField), fromField); } else if(fieldHasType<int64_t>(fromField)) { setValue(convertFieldValue<int64_t, float>(fromField), fromField); } else if(fieldHasType<uint32_t>(fromField)) { setValue(convertFieldValue<uint32_t, float>(fromField), fromField); } else if(fieldHasType<uint64_t>(fromField)) { setValue(convertFieldValue<uint64_t, float>(fromField), fromField); } else if(fieldHasType<bool>(fromField)) { setValue(convertFieldValue<bool, float>(fromField), fromField); } else { throw std::invalid_argument("pullValue: type mismatch. " + getTypeId().getName() + " <--> " + fromField->getTypeId().getName()); } }
int linkedlist::addCount(char *sample, char *type) { if (getTypeId(type) == -1) { if (typeMax == typeCount) return -1; else { strcpy_s(typeName[typeCount], type); typeCount += 1; } } linkedList *p = mainData; while (p != NULL) { if (strcmp(sample, p->sampleName) == 0) { p->typeCNT[getTypeId(type)] += 1; objects[getTypeId(type)] += 1; return 0; } p = p->next; } objectsUniqueCount += 1; linkedList *tmp = new linkedList; strcpy_s(tmp->sampleName, sample); for (int i = 0; i<typeMax; i++) tmp->typeCNT[i] = 0; tmp->typeCNT[getTypeId(type)] = 1; tmp->next = NULL; objects[getTypeId(type)] += 1; if (mainData == NULL) mainData = tmp; else { p = mainData; while (p->next != NULL) p=p->next; p->next = tmp; } return 0; }
void AiSequence::stopPursuit() { while (getTypeId() == AiPackage::TypeIdPursue) { delete *mPackages.begin(); mPackages.erase (mPackages.begin()); } }
SoElement * SoResetMatrixElement::copyMatchInfo(void) const { SoResetMatrixElement * element = (SoResetMatrixElement *)(getTypeId().createInstance()); element->matrix = this->matrix; return element; }
void AiSequence::stopCombat() { while (getTypeId() == AiPackage::TypeIdCombat) { delete *mPackages.begin(); mPackages.erase (mPackages.begin()); } }
void Tuning::setTuning(int _index, omni::Session* _session) { bool _newTuning = (session_ != _session) || (index_ != _index); index_=_index; session_ = _session; if (_newTuning) { glView_->setSession(session_); glView_->setTuningIndex(index_); fullscreen_->setSession(session_); fullscreen_->setTuningIndex(index_); titleBar_->setColor(tuning()->color()); setParamAsFloat("FOV",tuning()->projector().fov().degrees()); setParamAsFloat("Throw Ratio",tuning()->projector().throwRatio()); auto _projSetup = tuning()->projector().setup(); if (_projSetup->getTypeId() == "FreeSetup") { auto* _p = static_cast<omni::proj::FreeSetup*>(_projSetup); setParamAsFloat("Yaw",_p->yaw().degrees()); setParamAsFloat("Pitch",_p->pitch().degrees()); setParamAsFloat("Roll",_p->roll().degrees()); setParamAsFloat("X",_p->pos().x()); setParamAsFloat("Y",_p->pos().y()); setParamAsFloat("Z",_p->pos().z()); } else if (_projSetup->getTypeId() == "PeripheralSetup") { auto* _p = static_cast<omni::proj::PeripheralSetup*>(_projSetup); setParamAsFloat("Yaw",_p->yaw().degrees()); setParamAsFloat("Pitch",_p->pitch().degrees()); setParamAsFloat("Roll",_p->roll().degrees()); setParamAsFloat("Delta Yaw",_p->deltaYaw().degrees()); setParamAsFloat("Distance",_p->distanceCenter()); setParamAsFloat("Tower Height",_p->towerHeight()); setParamAsFloat("Shift",_p->shift()); } sessionModeChange(); updateParameters(); } }
bool AiSequence::getCombatTarget(MWWorld::Ptr &targetActor) const { if (getTypeId() != AiPackage::TypeIdCombat) return false; targetActor = mPackages.front()->getTarget(); return !targetActor.isEmpty(); }
/*! Returns a deep copy of the given SCXML element. */ ScXMLElt * ScXMLElt::clone(void) const { SoType elementtype(getTypeId()); if (!elementtype.canCreateInstance()) { return NULL; } ScXMLElt * copy = static_cast<ScXMLElt *>(elementtype.createInstance()); copy->copyContents(this); return copy; }
bool AiSequence::getCombatTarget(MWWorld::Ptr &targetActor) const { if (getTypeId() != AiPackage::TypeIdCombat) return false; const AiCombat *combat = static_cast<const AiCombat *>(mPackages.front()); targetActor = combat->getTarget(); return true; }
SoElement * SoGLRenderPassElement::copyMatchInfo() const // //////////////////////////////////////////////////////////////////////// { SoGLRenderPassElement *result = (SoGLRenderPassElement *)getTypeId().createInstance(); result->GLRenderPass = GLRenderPass; return result; }
SoElement * SoViewportRegionElement::copyMatchInfo() const // //////////////////////////////////////////////////////////////////////// { SoViewportRegionElement *result = (SoViewportRegionElement *)getTypeId().createInstance(); result->viewportRegion = viewportRegion; return result; }
SoElement * SoLightAttenuationElement::copyMatchInfo() const // //////////////////////////////////////////////////////////////////////// { SoLightAttenuationElement *result = (SoLightAttenuationElement *)getTypeId().createInstance(); result->attenuation = attenuation; return result; }
SoElement * SoGLCacheContextElement::copyMatchInfo() const // //////////////////////////////////////////////////////////////////////// { SoGLCacheContextElement *result = (SoGLCacheContextElement *)getTypeId().createInstance(); result->context = context; result->is2PassTransp = is2PassTransp; return result; }
SoElement * SoGLUpdateAreaElement::copyMatchInfo() const // //////////////////////////////////////////////////////////////////////// { SoGLUpdateAreaElement *result = (SoGLUpdateAreaElement *)getTypeId().createInstance(); result->origin = origin; result->size = size; return result; }
bool DrawElement::loadTypeId(QIODevice* device) { QDataStream stream(device); int temp_type; stream >> temp_type ; // typeId = static_cast<Element_type>(temp_type); Element_type temp_2 ; temp_2 = (Element_type)(temp_type); setTypeId(temp_2); qDebug() << "DrawElement::load temp_type = " << getTypeId(); }
SoElement* SoXipOverlayManipulatedElement::copyMatchInfo() const { SoXipOverlayManipulatedElement* result = (SoXipOverlayManipulatedElement *) getTypeId().createInstance(); if( result ) { result->mIsManipulated = mIsManipulated; return result; } return NULL; }
cl_int IntelAccelerator::getInfo(cl_accelerator_info_intel paramName, size_t paramValueSize, void *paramValue, size_t *paramValueSizeRet) const { cl_int result = CL_SUCCESS; size_t ret = 0; switch (paramName) { case CL_ACCELERATOR_DESCRIPTOR_INTEL: { ret = getDescriptorSize(); result = ::getInfo(paramValue, paramValueSize, getDescriptor(), ret); } break; case CL_ACCELERATOR_REFERENCE_COUNT_INTEL: { auto v = getReference(); ret = sizeof(cl_uint); result = ::getInfo(paramValue, paramValueSize, &v, ret); } break; case CL_ACCELERATOR_CONTEXT_INTEL: { ret = sizeof(cl_context); cl_context ctx = static_cast<cl_context>(pContext); result = ::getInfo(paramValue, paramValueSize, &ctx, ret); } break; case CL_ACCELERATOR_TYPE_INTEL: { auto v = getTypeId(); ret = sizeof(cl_accelerator_type_intel); result = ::getInfo(paramValue, paramValueSize, &v, ret); } break; default: result = CL_INVALID_VALUE; break; } if (paramValueSizeRet) { *paramValueSizeRet = ret; } return result; }
// // Create a copy of this instance suitable for calling matches() // SoElement * SoXipMprActiveElement::copyMatchInfo() const { SoXipMprActiveElement *result = (SoXipMprActiveElement *)getTypeId().createInstance(); if(result) { result->mprId = mprId; return result; } else return NULL; }
SoElement * SoShapeHintsElement::copyMatchInfo() const // //////////////////////////////////////////////////////////////////////// { SoShapeHintsElement *result = (SoShapeHintsElement *)getTypeId().createInstance(); result->vertexOrdering = vertexOrdering; result->shapeType = shapeType; result->faceType = faceType; return result; }