const CResourceDescription* CResourceHandler::GetResource(int resourceId) const { if (IsValidId(resourceId)) return &resources[resourceId]; return NULL; }
const CResource* CResourceHandler::GetResource(int resourceId) const { if (IsValidId(resourceId)) { return &resources[resourceId]; } else { return NULL; } }
FunctionInfo * JavascriptBuiltInFunction::GetFunctionInfo(Js::LocalFunctionId builtinId) { if (IsValidId(builtinId)) { return builtInFunctionInfo[builtinId]; } return nullptr; }
const CResourceMapAnalyzer* CResourceHandler::GetResourceMapAnalyzer(int resourceId) { if (!IsValidId(resourceId)) return NULL; CResourceMapAnalyzer* rma = resourceMapAnalyzers[resourceId]; if (rma == NULL) { rma = new CResourceMapAnalyzer(resourceId); resourceMapAnalyzers[resourceId] = rma; } return rma; }
bool LocalAssetProvider::RequestAsset(const std::string& asset_id, const std::string& asset_type, request_tag_t tag) { if (!IsValidId(asset_id, asset_type)) return false; Foundation::ServiceManagerPtr service_manager = framework_->GetServiceManager(); boost::shared_ptr<Foundation::AssetServiceInterface> asset_service = service_manager->GetService<Foundation::AssetServiceInterface>(Foundation::Service::ST_Asset).lock(); if (!asset_service) return false; AssetModule::LogDebug("New local asset request: " + asset_id); // Strip file: std::string filepath = asset_dir_ + asset_id.substr(7); boost::filesystem::path file_path(filepath); std::ifstream filestr(file_path.native_directory_string().c_str(), std::ios::in | std::ios::binary); if (filestr.good()) { filestr.seekg(0, std::ios::end); uint length = filestr.tellg(); filestr.seekg(0, std::ios::beg); if (length > 0) { RexAsset* new_asset = new RexAsset(asset_id, asset_type); Foundation::AssetPtr asset_ptr(new_asset); RexAsset::AssetDataVector& data = new_asset->GetDataInternal(); data.resize(length); filestr.read((char *)&data[0], length); filestr.close(); // Store to cache asset_service->StoreAsset(asset_ptr); // Send asset_ready event as delayed Events::AssetReady* event_data = new Events::AssetReady(asset_ptr->GetId(), asset_ptr->GetType(), asset_ptr, tag); framework_->GetEventManager()->SendDelayedEvent(event_category_, Events::ASSET_READY, Foundation::EventDataPtr(event_data)); return true; } else filestr.close(); } AssetModule::LogInfo("Failed to load local asset " + asset_id.substr(7)); return false; }
bool UDPAssetProvider::RequestAsset(const std::string& asset_id, const std::string& asset_type, request_tag_t tag) { if (!IsValidId(asset_id, asset_type)) return false; RexUUID uuid(asset_id); if (uuid.IsNull()) return false; // The UDP asset provider only understands the fixed set of asset types used in OpenSim. If the string type is something // else, we can't satisfy the request. asset_type_t asset_type_int = GetAssetTypeFromTypeName(asset_type); if (asset_type_int < 0) return false; AssetRequest new_request; new_request.asset_id_ = asset_id; new_request.asset_type_ = asset_type_int; new_request.tags_.push_back(tag); pending_requests_.push_back(new_request); return true; }
static OtherLineInfoPtr s_ParseOtherLine (CharPtr lineStr) { Char ch; CharPtr otherStr; Int4 otherPosition; Int4 position; Int2 state; Int4 wordCount; OtherLineInfoPtr otherLinePtr; /* Parse the line character by character */ otherStr = (CharPtr) MemNew (StringLen(lineStr)+1); otherPosition = 0; state = OTHER_PRE_DATA; wordCount = 0; for (position = 0; lineStr[position] != '\0'; position++) { ch = lineStr[position]; switch (state) { case OTHER_PRE_DATA : if (IS_WHITESP(ch)) continue; else { wordCount = 1; state = OTHER_DATA; otherStr[otherPosition] = ch; otherPosition++; } break; case OTHER_DATA : if (IS_WHITESP(ch)) wordCount++; otherStr[otherPosition] = ch; otherPosition++; break; default: break; } } /* Check for blank line */ if (state == OTHER_PRE_DATA) { MemFree(otherStr); return NULL; } /* If we made it to here, then */ /* it's a valid definition line. */ otherStr[otherPosition] = '\0'; otherLinePtr = (OtherLineInfoPtr) MemNew (sizeof (OtherLineInfo)); if ((wordCount == 1) && IsValidId(otherStr)) { otherLinePtr->id = otherStr; otherLinePtr->other = NULL; } else { otherLinePtr->id = NULL; otherLinePtr->other = otherStr; } /* Return successfully */ return otherLinePtr; }
static SeqLineInfoPtr s_ParseSequenceLine (CharPtr lineStr, AliConfigInfoPtr configPtr) { CharPtr seqStr; Int4 seqPosition = 0; CharPtr idStr; Int4 idPosition = 0; Int4 firstWordLen = 0; Char ch; Int2 state = PRE_DATA; Int4 position; Boolean firstWordNotSequence = FALSE; Boolean sequenceFound = FALSE; CharPtr tempStr; Boolean corruptSequence = FALSE; SeqLineInfoPtr seqLinePtr; if (StringLen(lineStr) == 0) return NULL; seqStr = (CharPtr) MemNew (StringLen(lineStr)+1); idStr = (CharPtr) MemNew (StringLen(lineStr)+1); for (position = 0; lineStr[position] != '\0'; position++) { ch = lineStr[position]; switch (state) { case PRE_DATA : /* If it's the first non-whitespace char */ /* then we've found our first word. */ if (!IS_WHITESP(ch)) { state = FIRST_WORD; if (!IsSequenceChar(ch, configPtr->gapChar, configPtr->missingChar, configPtr->unalignedChar)) firstWordNotSequence = TRUE; idStr[idPosition] = ch; idPosition++; firstWordLen++; } break; case FIRST_WORD : if (IS_WHITESP(ch)) { state = SEQUENCE_DATA; if ((idPosition > 0) && (firstWordNotSequence == FALSE)) { tempStr = seqStr; seqStr = idStr; idStr = tempStr; seqPosition = idPosition; idPosition = 0; sequenceFound = TRUE; } } else { /* If we find a non-sequence char in the */ /* first word then it might be an ID, */ /* with the sequence following. */ if (!IsSequenceChar(ch, configPtr->gapChar, configPtr->missingChar, configPtr->unalignedChar)) firstWordNotSequence = TRUE; idStr[idPosition] = ch; idPosition++; firstWordLen++; } break; case SEQUENCE_DATA : if (IS_WHITESP(ch)) continue; /* If we're in a sequence, then a non-sequence */ /* char invalidates it, although we do allow */ /* 'junk' at the end. */ if (!IsSequenceChar(ch, configPtr->gapChar, configPtr->missingChar, configPtr->unalignedChar)) { if ((lineStr[position - 1] == ' ') && sequenceFound) state = EOL_JUNK; else if ((corruptSequence == TRUE) || (s_MightBeCorruptSequence (seqPosition, &(lineStr[position]), configPtr))) { seqStr[seqPosition] = ch; seqPosition++; sequenceFound = TRUE; corruptSequence = TRUE; } else { MemFree(seqStr); MemFree(idStr); return NULL; } } else { seqStr[seqPosition] = ch; seqPosition++; sequenceFound = TRUE; } break; case EOL_JUNK : if (IS_WHITESP(ch)) state = POST_JUNK; break; case POST_JUNK : /* Only one 'word' of junk allowed */ if (!IS_WHITESP(ch)) { MemFree(seqStr); MemFree(idStr); return NULL; } break; } } /* Check for blank line */ if (state == PRE_DATA) { MemFree(seqStr); MemFree(idStr); return NULL; } if (state == FIRST_WORD) { /* If there was just one word, and it isn't */ /* a sequence string, then this isn't a */ /* sequence line. */ if (firstWordNotSequence == TRUE) { MemFree(seqStr); MemFree(idStr); return NULL; } /* If there was just one word, and it IS a sequence */ /* then the idStr is actually the seqStr. */ else { tempStr = seqStr; seqStr = idStr; idStr = tempStr; seqPosition = idPosition; idPosition = 0; } } /* If still no sequence string, */ /* then not a sequence line. */ if (StringLen(seqStr) == 0) { MemFree(seqStr); MemFree(idStr); return NULL; } /* Check to see if the ID is a valid one */ idStr[idPosition] = '\0'; seqStr[seqPosition] = '\0'; if ((idPosition > 0) && (IsValidId (idStr) == FALSE) && (IsNumString (idStr) == FALSE)) { MemFree(idStr); MemFree(seqStr); return NULL; } /* If we made it to here, then */ /* it's a valid sequence line. */ seqLinePtr = (SeqLineInfoPtr) MemNew (sizeof (SeqLineInfo)); seqLinePtr->firstWordLen = firstWordLen; if (StringLen (seqStr) != 0) seqLinePtr->sequence = seqStr; else { seqLinePtr->sequence = NULL; MemFree (seqStr); } if (StringLen (idStr) != 0) seqLinePtr->id = idStr; else { seqLinePtr->id = NULL; MemFree (idStr); } if (corruptSequence) seqLinePtr->maybe = TRUE; else seqLinePtr->maybe = FALSE; return seqLinePtr; }
void Ali_ChangeRowToOther (ValNodePtr rowPtr) { DefLineInfoPtr defLinePtr; SeqLineInfoPtr seqLinePtr; OtherLineInfoPtr otherLinePtr; /* Sequence line to Other Line */ if (rowPtr->choice == ALI_SEQLINE) { otherLinePtr = (OtherLineInfoPtr) MemNew (sizeof(OtherLineInfo)); seqLinePtr = (SeqLineInfoPtr) rowPtr->data.ptrvalue; if (seqLinePtr->junk != NULL) sprintf(seqLinePtr->sequence,"%s%s",seqLinePtr->sequence, seqLinePtr->junk); if ((seqLinePtr->sequence != NULL) && (seqLinePtr->id == NULL)) { if (IsValidId(seqLinePtr->sequence)) { otherLinePtr->id = seqLinePtr->sequence; otherLinePtr->other = NULL; } else { otherLinePtr->id = NULL; otherLinePtr->other = seqLinePtr->sequence; } } else { otherLinePtr->other = seqLinePtr->sequence; otherLinePtr->id = seqLinePtr->id; } otherLinePtr->rowNum = seqLinePtr->rowNum; MemFree(seqLinePtr); rowPtr->data.ptrvalue = otherLinePtr; rowPtr->choice = ALI_OTHERLINE; } /* Definition line to Other line */ else if (rowPtr->choice == ALI_DEFLINE) { otherLinePtr = (OtherLineInfoPtr) MemNew (sizeof(OtherLineInfo)); defLinePtr = (DefLineInfoPtr) rowPtr->data.ptrvalue; otherLinePtr->other = defLinePtr->definitions; otherLinePtr->id = defLinePtr->id; otherLinePtr->rowNum = defLinePtr->rowNum; MemFree(defLinePtr); rowPtr->data.ptrvalue = otherLinePtr; rowPtr->choice = ALI_OTHERLINE; } /* Return successfully */ return; }
bool JavascriptBuiltInFunction::CanChangeEntryPoint(Js::LocalFunctionId builtInId) { return IsValidId(builtInId); }