/** Get value of the DOM element. Returns value for elements recognized by get_ctl_type() function. * \param[in] el \b const dom::element&, The element. * \return \b value_t, value of the element. **/ inline value_t get_value(dom::element& el ) { switch(get_ctl_type(el)) { 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: default: return el.get_value(); // special cases: case CTL_UNKNOWN: if( !aux::wcseq(el.get_attribute("type"),L"hidden")) break; //else fall below if it is hidden case CTL_BUTTON: return value_t(el.get_attribute("value")); case CTL_CHECKBOX: return get_checkbox_bits(el); case CTL_RADIO: return get_radio_index(el); case CTL_HTMLAREA: return value_t(el.get_html(false/*inner*/)); } return value_t(); }
// returns bit mask - checkboxes set inline value_t get_checkbox_bits(dom::element& el ) { selected_cb selected; dom::element r = el.parent(); // ATTN: I assume here that all checkboxes in the group belong to the same parent! r.find_all(&selected, "[type='checkbox'][name='%S']", el.get_attribute("name")); int m = 1, v = 0; for( unsigned int n = 0; n < selected.elements.size(); ++n, m <<= 1 ) if ( selected.elements[n].get_state(STATE_CHECKED) ) v |= m; return selected.elements.size()==1?value_t(v==1):value_t(v); // for alone checkbox we return true/false }
inline value_t get_radio_index( dom::element& el ) { 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")); for( unsigned int n = 0; n < selected.elements.size(); ++n ) if ( selected.elements[n].get_state(STATE_CHECKED) ) return value_t(int(n)); return value_t(); }
BOOST_FORCEINLINE static void matrix_compute(const size_t & n, const size_t & k, A1 & a1) { typedef typename boost::proto::result_of::child_c<A1&,0>::type a_t; a_t & a = boost::proto::child_c<0>(a1); BOOST_AUTO_TPL(c, nt2::cumprod(nt2::_(value_t(2), value_t(n+1)))); BOOST_AUTO_TPL(d, nt2::cumprod(nt2::_(value_t(n+1), value_t(2*n)))*c(n-1)); a = nt2::hankel(c, d); if (k) a = nt2::rec(a); }
void com_obj_test() { com_object_t c; c.create("AutoItX.Control"); c["argc"] = 2; c["callsig"] = "ii"; c.insert_attribute("0", value_t("20")); c.insert_attribute("1", value_t("20")); c.invoke("MouseMove"); //ct.invoke_fmt("MouseMove", "ii", "0", "0", 0); }
void setup_random(SCtx& ctx) { srand(0); ctx.sum = 0; ctx.keys.clear(); ctx.keys.resize(ctx.num_elements); ctx.randomkeys.clear(); ctx.randomkeys.resize(ctx.num_elements); ctx.exists.clear(); ctx.exists.resize(ctx.num_elements); for( size_t i = 0; i < ctx.num_elements; ++i ) { keey_t key = rand(); while( Exists(ctx.ht, key ) ) { key = rand(); } Put(ctx.ht, key, value_t(i+1) ); ctx.keys[i] = key; ctx.randomkeys[i] = key; ctx.exists[i] = true; ctx.sum += key * (i+1); } }
void create_insert(SCtx& ctx) { Init(ctx.ht, ctx.num_elements); for( size_t i = 0; i < ctx.num_elements; ++i ) Put(ctx.ht, keey_t( i ), value_t( i ) ); }
uint64_t insert_sequential(SCtx& ctx) { for( size_t i = 0; i < ctx.num_elements; ++i ) Put(ctx.ht, keey_t( i ), value_t( i ) ); ASSERT( Size(ctx.ht) == ctx.num_elements ); return 0; }
static inline value_t get_value(const void *address) { if (sizeof(align_t) > sizeof(value_t)) return value_t(*(align_t*)address); else return *(value_t*)address; }
value_t convert2(const container_t& c) { try { return c.operator value_t(); } catch(const std::exception& e) { OH_FAIL("Unable to convert type '" << c.type().name() << "' to type '" << typeid(value_t).name() << "' - " << e.what()); } }
uint64_t insert_random(SCtx& ctx) { srand(0); for( size_t i = 0; i < ctx.num_elements; ++i ) Put(ctx.ht, ctx.randomkeys[i], value_t( i ) ); ASSERT( Size(ctx.ht) == ctx.num_elements ); return 0; }
BOOST_FORCEINLINE static void det_compute(const size_t & n, const size_t & k, A1 & a1) { value_t d = One<value_t>(); if (!k) { for(size_t i=1; i <= n-1; ++i) d *= nt2::prod(nt2::_(value_t(1), value_t(i+1)))*nt2::prod(_(value_t(1), value_t(n-i))); d *= nt2::prod(nt2::_(value_t(1), value_t(n+1))); } else { for(size_t i=0; i <= n-1; ++i) d = d*nt2::prod(nt2::_(value_t(1), value_t(i)))/nt2::prod(nt2::_(value_t(1), value_t(n+1+i))); if (nt2::is_odd(n*(n-1)/2)) d = -d; } boost::proto::child_c<1>(a1) = d; }
void obj_test() { object_t obj1; object_t obj2; value_t *v1; std::string s; v1 = obj1.insert_attribute("v1", value_t(123)); obj2 = obj1; obj2.to_string(s); printf("%s\n", s.c_str()); }
scope_ptr zookeeper_t::lock(writable_ptr::lock result, const path_t& folder) { path_t path = folder + "/lock"; auto lock_state = std::make_shared<lock_state_t>(context_t({*log, zk})); auto& handler = lock_state->handler_scope.get_handler<lock_action_t>( context_t({*log, zk}), lock_state, path, std::move(folder), value_t(time(nullptr)), result ); zk.create(path, handler.encoded_value, handler.ephemeral, handler.sequence, handler); return lock_state; }
static value_t custom_tagged_ordering_compare(value_t a, value_t b) { CHECK_DOMAIN(vdCustomTagged, a); CHECK_DOMAIN(vdCustomTagged, b); custom_tagged_phylum_t a_phylum = get_custom_tagged_phylum(a); custom_tagged_phylum_t b_phylum = get_custom_tagged_phylum(b); if (a_phylum != b_phylum) return compare_signed_integers(a_phylum, b_phylum); phylum_behavior_t *behavior = get_custom_tagged_phylum_behavior(a_phylum); value_t (*ordering_compare)(value_t a, value_t b) = behavior->ordering_compare; if (ordering_compare == NULL) { return unordered(); } else { return ordering_compare(a, b); } }
void Integer<T>::SetValue(value_t val) { const T theValue = T(val); if (value_t(theValue) < val) { std::stringstream s; s << __PRETTY_FUNCTION__ << " " << Name(); s << " : value(" << val << ") bigger than the maximum allowed value(" << MaxValue() << ")"; throw std::invalid_argument(s.str()); } const T newVal = SwapBytes<T>(theValue); const unsigned char* buf = reinterpret_cast<const unsigned char*>(&newVal); memcpy(&data_[0], buf, sizeof(newVal)); }
uint64_t adds_and_removes(SCtx& ctx) { uint32_t percent = 30; uint32_t percent_lower = 50; uint32_t num_to_keep = (ctx.num_elements * percent_lower) / 100; uint32_t num_to_addremove = (ctx.num_elements * percent) / 100; if( num_to_addremove == 0 ) num_to_addremove = 1; if( num_to_keep + num_to_addremove > ctx.num_elements ) num_to_keep = ctx.num_elements - num_to_addremove; for(uint32_t i = 0; i < 100; ++i ) { if( i & 1 ) { // add uint32_t num_to_add = rand() % num_to_addremove; if( Size(ctx.ht) + num_to_add > ctx.num_elements ) num_to_add = ctx.num_elements - Size(ctx.ht); for( size_t i = 0; i < num_to_add; ++i ) { keey_t index = rand() % ctx.num_elements; Put(ctx.ht, ctx.randomkeys[ index ], value_t(i) ); ctx.exists[index] = true; } } else { // remove uint32_t num_to_remove = rand() % num_to_addremove; if( Size(ctx.ht) - num_to_remove < num_to_keep ) num_to_remove = Size(ctx.ht) - num_to_keep; for( size_t i = 0; i < num_to_remove; ++i ) { keey_t index = rand() % ctx.num_elements; if( ctx.exists[index] ) { Erase(ctx.ht, ctx.randomkeys[ index ] ); ctx.exists[index] = false; } } } } return 0; }
static value_t object_ordering_compare(value_t a, value_t b) { CHECK_DOMAIN(vdHeapObject, a); CHECK_DOMAIN(vdHeapObject, b); heap_object_family_t a_family = get_heap_object_family(a); heap_object_family_t b_family = get_heap_object_family(b); if (a_family != b_family) // This may cause us to return a valid result even when a and b are not // comparable. return compare_signed_integers(a_family, b_family); family_behavior_t *behavior = get_heap_object_family_behavior(a); value_t (*ordering_compare)(value_t a, value_t b) = behavior->ordering_compare; if (ordering_compare == NULL) { return unordered(); } else { return ordering_compare(a, b); } }
uint64_t create_insert_and_sum(SCtx& ctx) { hashtable_t ht; Init(ht, ctx.num_elements); for( size_t i = 0; i < ctx.num_elements; ++i ) Put(ht, keey_t( i ), value_t( i ) ); uint64_t sum = 0; #if defined(IMPL_DM_HASHTABLE) ht.Iterate(sum_callback, &sum); #else auto it = IteratorBegin(ht); auto itend = IteratorEnd(ht); for( ; it != itend; IteratorNext(ht, it) ) sum += IteratorGetValue(ht, it); #endif return sum; }
void subscribe_action_t::data_event(int rc, std::string value, const zookeeper::node_stat& stat) { if(rc == ZNONODE) { if(last_version != min_version && last_version != not_existing_version) { auto code = cocaine::error::make_error_code(static_cast<cocaine::error::zookeeper_errors>(rc)); result->abort(code); } else { // Write that node is not exist to client only first time. // After that set a watch to see when it will appear if(last_version == min_version) { std::lock_guard<std::mutex> guard(write_lock); if (not_existing_version > last_version) { result->write(versioned_value_t(value_t(), not_existing_version)); } } try { ctx.zk.exists(path, *this, *this); } catch(const std::system_error& e) { COCAINE_LOG_WARNING(ctx.log, "failure during subscription(get): {}", e.what()); result->abort(e.code()); } } } else if (rc != 0) { auto code = cocaine::error::make_error_code(static_cast<cocaine::error::zookeeper_errors>(rc)); result->abort(code); } else if (stat.numChildren != 0) { result->abort(cocaine::error::child_not_allowed); } else { version_t new_version(stat.version); std::lock_guard<std::mutex> guard(write_lock); if (new_version > last_version) { last_version = new_version; value_t val; try { result->write(versioned_value_t(unserialize(value), new_version)); } catch(const std::system_error& e) { result->abort(e.code()); } } } }
void create_sequential_table(SCtx& ctx) { Init( ctx.ht, ctx.num_elements ); ctx.sum = 0; ctx.keys.clear(); ctx.keys.resize(ctx.num_elements); ctx.randomkeys.clear(); ctx.randomkeys.resize(ctx.num_elements); ctx.exists.clear(); ctx.exists.resize(ctx.num_elements); for( size_t i = 0; i < ctx.num_elements; ++i ) { keey_t key = i; Put(ctx.ht, key, value_t( i+1 ) ); ctx.keys[i] = key; ctx.randomkeys[i] = key; ctx.exists[i] = true; ctx.sum += key * (i+1); } ASSERT( Size(ctx.ht) == ctx.num_elements ); }
void spawner_new_c::json_report(runner *runner_instance, rapidjson::PrettyWriter<rapidjson::StringBuffer, rapidjson::UTF16<> > &writer) { writer.StartObject(); //for { report_class runner_report = runner_instance->get_report(); options_class runner_options = runner_instance->get_options(); //temporary #define rapidjson_write(x) (writer.String(a2w(x))) rapidjson_write("Application"); rapidjson_write(runner_report.application_name.c_str()); rapidjson_write("Arguments"); writer.StartArray(); for (size_t i = 0; i < runner_options.get_arguments_count(); ++i) { rapidjson_write(runner_options.get_argument(i).c_str()); } writer.EndArray(); rapidjson_write("Limit"); writer.StartObject(); restrictions_class runner_restrictions = ((secure_runner*)runner_instance)->get_restrictions(); struct { const char *field; unit_t unit; degrees_enum degree; restriction_kind_t restriction; } restriction_items[] = { { "Time", unit_time_second, degree_micro, restriction_processor_time_limit }, { "WallClockTime", unit_time_second, degree_micro, restriction_user_time_limit }, { "Memory", unit_memory_byte, degree_default, restriction_memory_limit }, { "SecurityLevel", unit_no_unit, degree_default, restriction_security_limit }, { "IOBytes", unit_memory_byte, degree_default, restriction_write_limit }, { "IdlenessTime", unit_time_second, degree_micro, restriction_idle_time_limit }, { "IdlenessProcessorLoad", unit_no_unit, degree_centi, restriction_load_ratio }, { nullptr, unit_no_unit, degree_default, restriction_max }, }; for (int i = 0; restriction_items[i].field; ++i) { if (!runner_restrictions.check_restriction(restriction_items[i].restriction)) { continue; } rapidjson_write(restriction_items[i].field); if (restriction_items[i].degree == degree_default) { writer.Uint64(runner_restrictions[restriction_items[i].restriction]); } else { writer.Double((double)convert( value_t(restriction_items[i].unit, restriction_items[i].degree), value_t(restriction_items[i].unit), (long double)runner_restrictions[restriction_items[i].restriction] )); } } writer.EndObject(); rapidjson_write("Options"); writer.StartObject(); rapidjson_write("SearchInPath"); writer.Bool(runner_options.use_cmd); writer.EndObject(); rapidjson_write("Result"); writer.StartObject(); struct { const char *field; uint64_t value; unit_t unit; degrees_enum degree; } result_items[] = { { "Time", runner_report.processor_time, unit_time_second, degree_micro }, { "WallClockTime", runner_report.user_time, unit_time_second, degree_micro }, { "Memory", runner_report.peak_memory_used, unit_memory_byte, degree_default }, { "BytesWritten", runner_report.write_transfer_count, unit_memory_byte, degree_default }, { "KernelTime", runner_report.kernel_time, unit_time_second, degree_micro }, { "ProcessorLoad", (uint64_t)(runner_report.load_ratio * 100), unit_no_unit, degree_micro }, { nullptr, 0, unit_no_unit, degree_default }, }; for (int i = 0; result_items[i].field; ++i) { rapidjson_write(result_items[i].field); if (result_items[i].degree == degree_default) { writer.Uint64(result_items[i].value); } else { writer.Double((double)convert( value_t(result_items[i].unit, result_items[i].degree), value_t(result_items[i].unit), (long double)result_items[i].value )); } } rapidjson_write("WorkingDirectory"); rapidjson_write(runner_report.working_directory.c_str()); writer.EndObject(); rapidjson_write("StdOut"); writer.StartArray(); for (const auto& i : runner_options.stdoutput) { rapidjson_write(i.original.c_str()); } writer.EndArray(); rapidjson_write("StdErr"); writer.StartArray(); for (const auto& i : runner_options.stderror) { rapidjson_write(i.original.c_str()); } writer.EndArray(); rapidjson_write("StdIn"); writer.StartArray(); for (const auto& i : runner_options.stdinput) { rapidjson_write(i.original.c_str()); } writer.EndArray(); rapidjson_write("CreateProcessMethod"); rapidjson_write(options.login.empty() ? "CreateProcess" : "WithLogon"); rapidjson_write("UserName"); writer.String(runner_report.login.c_str()); rapidjson_write("TerminateReason"); rapidjson_write(get_terminate_reason(runner_report.terminate_reason).c_str()); rapidjson_write("ExitCode"); writer.Uint(runner_report.exit_code); rapidjson_write("ExitStatus"); rapidjson_write(ExtractExitStatus(runner_report).c_str()); rapidjson_write("SpawnerError"); writer.StartArray(); std::vector<std::string> errors; errors.push_back(get_error_text()); for (const auto& error : errors) { rapidjson_write(error.c_str()); } writer.EndArray(); writer.EndObject(); }
void MsdFile::AddValue() /* (no extra charge) */ { values.push_back(value_t()); values.back().params.reserve( 32 ); }
constexpr int mult_ops() const { return value_t().mult_ops(); }
//solution exercice 1 constexpr int sum_ops() const { return value_t().sum_ops(); }
constexpr auto operator() (T t_) const{ return value_t()(t_); }
bool operator == (const value_t& v, const cons_ptr_t& ptr) { return v == value_t(ptr); }
BOOST_FORCEINLINE void solve(solve_qr_t const& f, A1 & a1, boost::mpl::long_<2> const&) const { boost::proto::child_c<0>(a1) = f.x(); boost::proto::child_c<1>(a1) = value_t(f.rank()); }
static std::vector<uint8_t> from_pv(const void *pv, size_t size) { auto p = reinterpret_cast<const value_t::value_type*>(pv); if (!p) return value_t(); return value_t(p, p + size); }
int obb_disjoint(matrix<value_t, 3, 3> const& B, point<value_t, 3> const& T, point<value_t, 3> const& a, point<value_t, 3> const& b) { register value_t t, s; register int r; value_t Bf[3][3]; const value_t reps = value_t(1e-6); // Bf = fabs(B) Bf[0][0] = fabs(B[0][0]); Bf[0][0] += reps; Bf[0][1] = fabs(B[0][1]); Bf[0][1] += reps; Bf[0][2] = fabs(B[0][2]); Bf[0][2] += reps; Bf[1][0] = fabs(B[1][0]); Bf[1][0] += reps; Bf[1][1] = fabs(B[1][1]); Bf[1][1] += reps; Bf[1][2] = fabs(B[1][2]); Bf[1][2] += reps; Bf[2][0] = fabs(B[2][0]); Bf[2][0] += reps; Bf[2][1] = fabs(B[2][1]); Bf[2][1] += reps; Bf[2][2] = fabs(B[2][2]); Bf[2][2] += reps; // if any of these tests are one-sided, then the polyhedra are disjoint r = 1; // A1 x A2 = A0 t = fabs(T[0]); r &= (t <= (a[0] + b[0] * Bf[0][0] + b[1] * Bf[0][1] + b[2] * Bf[0][2])); if (!r) return 1; // B1 x B2 = B0 s = T[0] * B[0][0] + T[1] * B[1][0] + T[2] * B[2][0]; t = fabs(s); r &= (t <= (b[0] + a[0] * Bf[0][0] + a[1] * Bf[1][0] + a[2] * Bf[2][0])); if (!r) return 2; // A2 x A0 = A1 t = fabs(T[1]); r &= (t <= (a[1] + b[0] * Bf[1][0] + b[1] * Bf[1][1] + b[2] * Bf[1][2])); if (!r) return 3; // A0 x A1 = A2 t = fabs(T[2]); r &= (t <= (a[2] + b[0] * Bf[2][0] + b[1] * Bf[2][1] + b[2] * Bf[2][2])); if (!r) return 4; // B2 x B0 = B1 s = T[0] * B[0][1] + T[1] * B[1][1] + T[2] * B[2][1]; t = fabs(s); r &= (t <= (b[1] + a[0] * Bf[0][1] + a[1] * Bf[1][1] + a[2] * Bf[2][1])); if (!r) return 5; // B0 x B1 = B2 s = T[0] * B[0][2] + T[1] * B[1][2] + T[2] * B[2][2]; t = fabs(s); r &= (t <= (b[2] + a[0] * Bf[0][2] + a[1] * Bf[1][2] + a[2] * Bf[2][2])); if (!r) return 6; // A0 x B0 s = T[2] * B[1][0] - T[1] * B[2][0]; t = fabs(s); r &= (t <= (a[1] * Bf[2][0] + a[2] * Bf[1][0] + b[1] * Bf[0][2] + b[2] * Bf[0][1])); if (!r) return 7; // A0 x B1 s = T[2] * B[1][1] - T[1] * B[2][1]; t = fabs(s); r &= (t <= (a[1] * Bf[2][1] + a[2] * Bf[1][1] + b[0] * Bf[0][2] + b[2] * Bf[0][0])); if (!r) return 8; // A0 x B2 s = T[2] * B[1][2] - T[1] * B[2][2]; t = fabs(s); r &= (t <= (a[1] * Bf[2][2] + a[2] * Bf[1][2] + b[0] * Bf[0][1] + b[1] * Bf[0][0])); if (!r) return 9; // A1 x B0 s = T[0] * B[2][0] - T[2] * B[0][0]; t = fabs(s); r &= (t <= (a[0] * Bf[2][0] + a[2] * Bf[0][0] + b[1] * Bf[1][2] + b[2] * Bf[1][1])); if (!r) return 10; // A1 x B1 s = T[0] * B[2][1] - T[2] * B[0][1]; t = fabs(s); r &= (t <= (a[0] * Bf[2][1] + a[2] * Bf[0][1] + b[0] * Bf[1][2] + b[2] * Bf[1][0])); if (!r) return 11; // A1 x B2 s = T[0] * B[2][2] - T[2] * B[0][2]; t = fabs(s); r &= (t <= (a[0] * Bf[2][2] + a[2] * Bf[0][2] + b[0] * Bf[1][1] + b[1] * Bf[1][0])); if (!r) return 12; // A2 x B0 s = T[1] * B[0][0] - T[0] * B[1][0]; t = fabs(s); r &= (t <= (a[0] * Bf[1][0] + a[1] * Bf[0][0] + b[1] * Bf[2][2] + b[2] * Bf[2][1])); if (!r) return 13; // A2 x B1 s = T[1] * B[0][1] - T[0] * B[1][1]; t = fabs(s); r &= (t <= (a[0] * Bf[1][1] + a[1] * Bf[0][1] + b[0] * Bf[2][2] + b[2] * Bf[2][0])); if (!r) return 14; // A2 x B2 s = T[1] * B[0][2] - T[0] * B[1][2]; t = fabs(s); r &= (t <= (a[0] * Bf[1][2] + a[1] * Bf[0][2] + b[0] * Bf[2][1] + b[1] * Bf[2][0])); if (!r) return 15; return 0; // should equal 0 }