const Injection* InjectionCache::getInjectionImpl(const StringData* code, const StringData* desc) { Unit* unit = getUnit(getStringData(code)); if (unit == NULL) { return NULL; } Injection injection(unit, getStringData(desc)); const Injection* inj = getInjection(&injection); return inj; }
ssize_t APCArray::indexOf(const StringData* key) const { strhash_t h = key->hash(); Bucket* b = buckets(); for (ssize_t bucket = hash()[h & m.m_capacity_mask]; bucket != -1; bucket = b[bucket].next) { auto kind = b[bucket].key->kind(); if (kind == APCKind::StaticString || kind == APCKind::UncountedString) { auto const k = APCTypedValue::fromHandle(b[bucket].key); if (key->same(k->getStringData())) { return bucket; } } else if (kind == APCKind::SharedString) { auto const k = APCString::fromHandle(b[bucket].key); if (key->same(k->getStringData())) { return bucket; } } } return -1; }
UserInfo OperationContext::getUserInfo() const { try { return UserInfo(getStringData(USER_NAME)); } catch (ContextDataNotFoundException& e) { return UserInfo(); } }
ssize_t APCArray::indexOf(const StringData* key) const { strhash_t h = key->hash(); ssize_t bucket = hash()[h & m.m_capacity_mask]; Bucket* b = buckets(); while (bucket != -1) { if (!isRefcountedType(b[bucket].key->type())) { auto const k = APCTypedValue::fromHandle(b[bucket].key); if (b[bucket].key->type() != KindOfInt64 && key->same(k->getStringData())) { return bucket; } } else { assert(b[bucket].key->type() == KindOfString); auto const k = APCString::fromHandle(b[bucket].key); if (key->same(k->getStringData())) { return bucket; } } bucket = b[bucket].next; } return -1; }
void APCArray::add(APCHandle *key, APCHandle *val) { int pos = m.m_num; // NOTE: no check on duplication because we assume the original array has no // duplication Bucket* bucket = buckets() + pos; bucket->key = key; bucket->val = val; m.m_num++; int hash_pos; if (!isRefcountedType(key->type())) { auto const k = APCTypedValue::fromHandle(key); hash_pos = (key->type() == KindOfInt64 ? k->getInt64() : k->getStringData()->hash()) & m.m_capacity_mask; } else { assert(key->type() == KindOfString); auto const k = APCString::fromHandle(key); hash_pos = k->getStringData()->hash() & m.m_capacity_mask; } int& hp = hash()[hash_pos]; bucket->next = hp; hp = pos; }
inline DataType Variant::convertToNumeric(int64_t *lval, double *dval) const { StringData *s = getStringData(); assert(s); return s->isNumericWithVal(*lval, *dval, 1); }
inline void toRxstring(CONSTRXSTRING &r) { r.strptr = getStringData(); r.strlength = size_v(getBLength()); } // no encoding support, so better to use blength
RexxString *extractC(sizeC_t offset, sizeC_t sublength) // Extract characters { return newString(getStringData() + size_v(offset), size_v(sublength), sublength); // todo m17n }
RexxString *extractB(sizeB_t offset, sizeB_t sublength) // Extract bytes { return newString(getStringData() + offset, sublength); }
RexxString *extract(size_t offset, size_t sublength) { return newString(getStringData() + offset, sublength); }
// in behaviour RexxInteger *RexxString::caselessWordPos(RexxString *phrase, RexxInteger *pstart) { return StringUtil::caselessWordPos(getStringData(), getBLength(), phrase, pstart); }
// in behaviour RexxInteger *RexxString::wordLength(RexxInteger *position) { return StringUtil::wordLength(getStringData(), getBLength(), position); }
/** * Returns an array of all words contained in the given range * of the string, using the same extraction rules used * for subWord() and word(). * * @param position The optional starting position. If not provided, extraction * starts with the first word. * @param plength The number of words to extract. If omitted, will extract * from the starting postion to the end of the string. * * @return An array containing the extracted words. If no words are * available within the given range, this returns an empty * array. */ RexxArray *RexxString::subWords(RexxInteger *position, RexxInteger *plength) { return StringUtil::subWords(getStringData(), getBLength(), position, plength); }