scope_ptr zookeeper_t::increment(writable_ptr::increment result, const path_t& path, const value_t& value) { if (!value.is_double() && !value.is_int() && !value.is_uint()) { result->abort(cocaine::error::unicorn_errors::invalid_type); return nullptr; } auto scope = std::make_shared<zk_scope_t>(); auto& handler = scope->handler_scope.get_handler<increment_action_t>( context_t({*log, zk}), std::move(result), path, value ); zk.get(handler.path, handler); return scope; }
template<Type::Enum type> value_t raise_cast(value_t obj) { if(obj->type() != type) type_error(obj, "an object of type " + Type::names[type]); return obj; }
value_t Numeric::coerce(value_t obj, value_t other) { if(obj->type() == other->type()) return Array::allocate_pair(other, obj); auto convert = [&](value_t input) -> value_t { if(input->type() == Type::Float) return input; return raise_cast<Float>(call(input, "to_f")); }; OnStack<1> os(obj); value_t left = convert(other); value_t right = convert(obj); return Array::allocate_pair(left, right); }
value_t Hash::rb_delete(Hash *self, value_t key, value_t block) { OnStack<2> os(self, key); value_t value = HashAccess::remove(self, key); if(value != value_undef) return value; else if(block->test()) return yield(block, key); else return self->get_default(key); }
inline void set_radio_index( dom::element& el, const value_t& t ) { selected_cb selected; dom::element r = el.parent(); // ATTN: I assume here that all radios in the group belong to the same parent! r.find_all(&selected, "[type='radio'][name='%S']", el.get_attribute("name")); unsigned int idx = (unsigned int)t.get(0); for( unsigned int n = 0; n < selected.elements.size(); ++n ) { dom::element& e = selected.elements[n]; if ( n == idx) e.set_state(STATE_CHECKED, 0); else e.set_state(0, STATE_CHECKED); } }
value_t Bignum::coerce(Bignum *obj, value_t other) { switch(other->type()) { case Type::Fixnum: { if(obj->number.can_be_fix()) return Array::allocate_pair(other, Fixnum::from_int(obj->number.to_intptr())); else return Array::allocate_pair(Number(Fixnum::to_int(other)).to_bignum(), obj); } case Type::Bignum: return Array::allocate_pair(other, obj); default: coerce_error(other, obj); }; }
/** Set value of the DOM element. Sets value for elements recognized by get_ctl_type() function. * \param[in] el \b const dom::element&, The element. * \param[in] v \b const value_t&, The value. **/ inline void set_value(dom::element& el, const value_t& v ) { switch(get_ctl_type(el)) { case CTL_UNKNOWN: break; case CTL_EDIT: case CTL_DECIMAL: case CTL_CURRENCY: case CTL_PASSWORD: case CTL_NUMERIC: case CTL_PROGRESS: case CTL_SLIDER: case CTL_SELECT_SINGLE: case CTL_SELECT_MULTIPLE: case CTL_DD_SELECT: case CTL_TEXTAREA: case CTL_DATE: case CTL_CALENDAR: case CTL_HIDDEN: default: el.set_value(v); break; // special cases: case CTL_BUTTON: break; case CTL_CHECKBOX: set_checkbox_bits(el,v); break; case CTL_RADIO: set_radio_index(el,v); break; case CTL_HTMLAREA: { utf8::ostream os; os << v.get( L"" ); el.set_html( os.data(), os.length() ); el.update(); } break; case CTL_NO: assert(false); break; } }
value_t FalseClass::rb_xor(value_t value) { return value->test() ? value_true : value_false; }
void resize(size_t size) { value.resize(size); }
size_t size() const { return value.size(); }
void* data() { return reinterpret_cast<void*>(value.data()); }
const void* data() const { return reinterpret_cast<const void*>(value.data()); }
void CheatEngine::keepAddressesWithValue(const value_t& value, value_size_t size) { assert(!m_blocks.empty()); for (auto blockIt = begin(m_blocks); blockIt != end(m_blocks);) { MEMORY_BASIC_INFORMATION info; const auto len = VirtualQueryEx(m_process, blockIt->baseAddress, &info, sizeof(info)); assert(len == sizeof(info)); if (can_modify_page(info)) { chunk_t chunk(blockIt->size); DWORD bytesRead; ReadProcessMemory(m_process, blockIt->baseAddress, chunk.data(), blockIt->size, &bytesRead); chunk.resize(bytesRead); blockIt->size = bytesRead; // from the offsets that matched before within that page, only keep the ones that still match offsets_t stillMatches; for (auto offsetIt = blockIt->matches.cbegin(); offsetIt != blockIt->matches.cend(); ++offsetIt) { assert(*offsetIt + size <= chunk.size()); if (std::equal(chunk.cbegin() + *offsetIt, chunk.cbegin() + *offsetIt + size, value.cbegin())) { stillMatches.push_back(*offsetIt); } } blockIt->matches = stillMatches; // memory page no longer has matching addresses: drop it if (blockIt->matches.empty()) { blockIt = m_blocks.erase(blockIt); } else { ++blockIt; } } else { ++blockIt; } } }
UncertainVector<1> UncertainVector<D>::dot(const value_t & rhs) const { return UncertainVector<1>( _v.dot(rhs), rhs.dot( _E * rhs ) ); }