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;
}
