| {\n option(i, fws, Bytes::empty()).bind(|i, ws3| {\n dquote(i).then(|i| {\n option(i, cfws, Bytes::empty()).bind(|i, ws4| {\n let bs = rs.into_iter().fold(ws1, |acc, r| acc.concat(&r));\n\n i.ret(bs.concat(&ws3).concat(&ws4))\n })\n })\n })\n })\n })\n })\n}\n\n#[test]\nfn test_quoted_string() {\n let i = b\"\\\"Giant; \\\\\\\"Big\\\\\\\" Box\\\"\";\n let msg = parse_only(quoted_string, i);\n assert!(msg.is_ok());\n assert_eq!(msg.unwrap(), Bytes::from_slice(b\"Giant; \\\"Big\\\" Box\"));\n}\n\npub fn quoted_string_not(i: Input, mut p: P) -> U8Result where\nP: FnMut(u8) -> bool,\n{\n option(i, cfws, Bytes::empty()).bind(|i, ws1| {\n dquote(i).then(|i| {\n many1(i, |i| {\n option(i, fws, Bytes::empty()).bind(|i, ws2| {\n matched_by(i, |i| {\n peek_next(i).bind(|i, next| {\n if p(next) {\n i.err(Error::Unexpected)\n } else {\n qcontent(i)\n }\n })\n\n }).bind(|i, (v, _)| {\n i.ret(ws2.concat(&Bytes::from_slice(v)))\n })\n })\n }).bind(|i, rs: Vec| {\n option(i, fws, Bytes::empty()).bind(|i, ws3| {\n dquote(i).then(|i| {\n option(i, cfws, Bytes::empty()).bind(|i, ws4| {\n let bs = rs.into_iter().fold(ws1, |acc, r| acc.concat(&r));\n\n i.ret(bs.concat(&ws3).concat(&ws4))\n })\n })\n })\n })\n })\n })\n}\n\n\n#[test]\nfn test_quoted_string_not() {\n let i = b\"\\\"jdoe\\\"\";\n let msg = parse_only(|i| quoted_string_not(i, |c| c == b'@'), i);\n assert_eq!(msg, Ok(Bytes::from_slice(b\"jdoe\")));\n\n let i = b\"\\\"jdoe\\\"@example.com\";\n let msg = parse_only(|i| quoted_string_not(i, |c| c == b'@'), i);\n assert_eq!(msg, Ok(Bytes::from_slice(b\"jdoe\")));\n}\n"},"download_success":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":2968,"cells":{"blob_id":{"kind":"string","value":"50a892d11aded402f16b56046793a5e33e989d75"},"language":{"kind":"string","value":"Rust"},"repo_name":{"kind":"string","value":"iCodeIN/rust-advent"},"path":{"kind":"string","value":"/y2020/ex04/src/validators.rs"},"src_encoding":{"kind":"string","value":"UTF-8"},"length_bytes":{"kind":"number","value":2842,"string":"2,842"},"score":{"kind":"number","value":3.34375,"string":"3.34375"},"int_score":{"kind":"number","value":3,"string":"3"},"detected_licenses":{"kind":"list like","value":["MIT"],"string":"[\n \"MIT\"\n]"},"license_type":{"kind":"string","value":"permissive"},"text":{"kind":"string","value":"use regex::Regex;\nuse std::ops::RangeInclusive;\n\npub trait Validator {\n fn validate(&self, value: &str) -> bool;\n}\n\npub struct U16RangeValidator {\n range: RangeInclusive,\n}\n\nimpl U16RangeValidator {\n pub fn new(range: RangeInclusive) -> Self {\n U16RangeValidator { range }\n }\n}\n\nimpl Validator for U16RangeValidator {\n fn validate(&self, value: &str) -> bool {\n if let Ok(year) = value.parse::() {\n return self.range.contains(&year);\n }\n false\n }\n}\n\npub struct RegexValidator {\n regex: Regex,\n}\n\nimpl RegexValidator {\n pub fn new(regex: Regex) -> Self {\n RegexValidator { regex }\n }\n}\n\nimpl Validator for RegexValidator {\n fn validate(&self, value: &str) -> bool {\n self.regex.is_match(value)\n }\n}\n\n// byr (Birth Year) - four digits; at least 1920 and at most 2002.\npub fn create_byr_validator() -> U16RangeValidator {\n U16RangeValidator::new(1920..=2002)\n}\n\n// iyr (Issue Year) - four digits; at least 2010 and at most 2020.\npub fn create_iyr_validator() -> U16RangeValidator {\n U16RangeValidator::new(2010..=2020)\n}\n\n// eyr (Expiration Year) - four digits; at least 2020 and at most 2030.\npub fn create_eyr_validator() -> U16RangeValidator {\n U16RangeValidator::new(2020..=2030)\n}\n\n// hgt (Height) - a number followed by either cm or in.\n// If cm, the number must be at least 150 and at most 193.\n// If in, the number must be at least 59 and at most 76.\npub struct HgtValidator {\n regex: Regex,\n}\n\nimpl HgtValidator {\n pub fn new() -> Self {\n let regex = Regex::new(r\"^(\\d+)(in|cm)$\").unwrap();\n HgtValidator { regex }\n }\n}\n\nimpl Validator for HgtValidator {\n fn validate(&self, value: &str) -> bool {\n if let Some(captures) = self.regex.captures(value) {\n let unit = captures.get(2).unwrap().as_str();\n\n if let Ok(num) = captures.get(1).unwrap().as_str().parse::() {\n return (unit == \"in\" && (59..=76).contains(&num))\n || (unit == \"cm\" && (150..=193).contains(&num));\n }\n }\n false\n }\n}\n\npub fn create_hgt_validator() -> HgtValidator {\n HgtValidator::new()\n}\n\n// hcl (Hair Color) - a # followed by exactly six characters 0-9 or a-f.\npub fn create_hcl_validator() -> RegexValidator {\n let regex = Regex::new(r\"^#[0-9a-fA-F]{6}$\").unwrap();\n RegexValidator::new(regex)\n}\n\n// ecl (Eye Color) - exactly one of: amb blu brn gry grn hzl oth.\npub fn create_ecl_validator() -> RegexValidator {\n let regex = Regex::new(r\"^(amb|blu|brn|gry|grn|hzl|oth)$\").unwrap();\n RegexValidator::new(regex)\n}\n\n// pid (Passport ID) - a nine-digit number, including leading zeroes.\npub fn create_pid_validator() -> RegexValidator {\n let regex = Regex::new(r\"^\\d{9}$\").unwrap();\n RegexValidator::new(regex)\n}\n"},"download_success":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":2969,"cells":{"blob_id":{"kind":"string","value":"158bc4f31dcdf8670799376e3b8855835b601485"},"language":{"kind":"string","value":"Rust"},"repo_name":{"kind":"string","value":"open-telemetry/opentelemetry-rust"},"path":{"kind":"string","value":"/opentelemetry-sdk/src/testing/trace/in_memory_exporter.rs"},"src_encoding":{"kind":"string","value":"UTF-8"},"length_bytes":{"kind":"number","value":4403,"string":"4,403"},"score":{"kind":"number","value":2.734375,"string":"2.734375"},"int_score":{"kind":"number","value":3,"string":"3"},"detected_licenses":{"kind":"list like","value":["Apache-2.0"],"string":"[\n \"Apache-2.0\"\n]"},"license_type":{"kind":"string","value":"permissive"},"text":{"kind":"string","value":"use crate::export::trace::{ExportResult, SpanData, SpanExporter};\nuse futures_util::future::BoxFuture;\nuse opentelemetry::trace::{TraceError, TraceResult};\nuse std::sync::{Arc, Mutex};\n\n/// An in-memory span exporter that stores span data in memory.\n///\n/// This exporter is useful for testing and debugging purposes. It stores\n/// metric data in a `Vec`. Metrics can be retrieved\n/// using the `get_finished_spans` method.\n/// # Example\n/// ```\n///# use opentelemetry::trace::{SpanKind, TraceContextExt};\n///# use opentelemetry::{global, trace::Tracer, Context};\n///# use opentelemetry_sdk::propagation::TraceContextPropagator;\n///# use opentelemetry_sdk::runtime;\n///# use opentelemetry_sdk::testing::trace::InMemorySpanExporterBuilder;\n///# use opentelemetry_sdk::trace::{BatchSpanProcessor, TracerProvider};\n///\n///# #[tokio::main]\n///# async fn main() {\n/// let exporter = InMemorySpanExporterBuilder::new().build();\n/// let provider = TracerProvider::builder()\n/// .with_span_processor(BatchSpanProcessor::builder(exporter.clone(), runtime::Tokio).build())\n/// .build();\n///\n/// global::set_tracer_provider(provider.clone());\n///\n/// let tracer = global::tracer(\"example/in_memory_exporter\");\n/// let span = tracer\n/// .span_builder(\"say hello\")\n/// .with_kind(SpanKind::Server)\n/// .start(&tracer);\n///\n/// let cx = Context::current_with_span(span);\n/// cx.span().add_event(\"handling this...\", Vec::new());\n/// cx.span().end();\n///\n/// let results = provider.force_flush();\n/// for result in results {\n/// if let Err(e) = result {\n/// println!(\"{:?}\", e)\n/// }\n/// }\n/// let spans = exporter.get_finished_spans().unwrap();\n/// for span in spans {\n/// println!(\"{:?}\", span)\n/// }\n///# }\n/// ```\n#[derive(Clone, Debug)]\npub struct InMemorySpanExporter {\n spans: Arc>>,\n}\n\nimpl Default for InMemorySpanExporter {\n fn default() -> Self {\n InMemorySpanExporterBuilder::new().build()\n }\n}\n\n/// Builder for [`InMemorySpanExporter`].\n/// # Example\n/// ```\n///# use opentelemetry_sdk::testing::trace::InMemorySpanExporterBuilder;\n///\n/// let exporter = InMemorySpanExporterBuilder::new().build();\n/// ```\n#[derive(Clone, Debug)]\npub struct InMemorySpanExporterBuilder {}\n\nimpl Default for InMemorySpanExporterBuilder {\n fn default() -> Self {\n Self::new()\n }\n}\n\nimpl InMemorySpanExporterBuilder {\n /// Creates a new instance of the `InMemorySpanExporterBuilder`.\n pub fn new() -> Self {\n Self {}\n }\n\n /// Creates a new instance of the `InMemorySpanExporter`.\n pub fn build(&self) -> InMemorySpanExporter {\n InMemorySpanExporter {\n spans: Arc::new(Mutex::new(Vec::new())),\n }\n }\n}\n\nimpl InMemorySpanExporter {\n /// Returns the finished span as a vector of `SpanData`.\n ///\n /// # Errors\n ///\n /// Returns a `TraceError` if the internal lock cannot be acquired.\n ///\n /// # Example\n ///\n /// ```\n /// # use opentelemetry_sdk::testing::trace::InMemorySpanExporter;\n ///\n /// let exporter = InMemorySpanExporter::default();\n /// let finished_spans = exporter.get_finished_spans().unwrap();\n /// ```\n pub fn get_finished_spans(&self) -> TraceResult> {\n self.spans\n .lock()\n .map(|spans_guard| spans_guard.iter().cloned().collect())\n .map_err(TraceError::from)\n }\n\n /// Clears the internal storage of finished spans.\n ///\n /// # Example\n ///\n /// ```\n /// # use opentelemetry_sdk::testing::trace::InMemorySpanExporter;\n ///\n /// let exporter = InMemorySpanExporter::default();\n /// exporter.reset();\n /// ```\n pub fn reset(&self) {\n let _ = self.spans.lock().map(|mut spans_guard| spans_guard.clear());\n }\n}\n\nimpl SpanExporter for InMemorySpanExporter {\n fn export(&mut self, batch: Vec) -> BoxFuture<'static, ExportResult> {\n if let Err(err) = self\n .spans\n .lock()\n .map(|mut spans_guard| spans_guard.append(&mut batch.clone()))\n .map_err(TraceError::from)\n {\n return Box::pin(std::future::ready(Err(Into::into(err))));\n }\n Box::pin(std::future::ready(Ok(())))\n }\n\n fn shutdown(&mut self) {\n self.reset()\n }\n}\n"},"download_success":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":2970,"cells":{"blob_id":{"kind":"string","value":"2006d078ad47d36d15c36ed32964ca4e48ba983a"},"language":{"kind":"string","value":"Rust"},"repo_name":{"kind":"string","value":"Jackywathy/mipsy"},"path":{"kind":"string","value":"/crates/mipsy_web/src/components/pagebackground.rs"},"src_encoding":{"kind":"string","value":"UTF-8"},"length_bytes":{"kind":"number","value":800,"string":"800"},"score":{"kind":"number","value":2.640625,"string":"2.640625"},"int_score":{"kind":"number","value":3,"string":"3"},"detected_licenses":{"kind":"list like","value":[],"string":"[]"},"license_type":{"kind":"string","value":"no_license"},"text":{"kind":"string","value":"use yew::prelude::*;\nuse yew::{Children, Properties};\n\n#[derive(Properties, Clone)]\npub struct Props {\n #[prop_or_default]\n pub children: Children,\n}\n\npub struct PageBackground {\n pub props: Props,\n}\n\nimpl Component for PageBackground {\n type Message = ();\n type Properties = Props;\n\n fn create(props: Self::Properties, _: ComponentLink) -> Self {\n PageBackground { props }\n }\n\n fn change(&mut self, props: Self::Properties) -> ShouldRender {\n self.props = props;\n true\n }\n\n fn update(&mut self, _: Self::Message) -> ShouldRender {\n true\n }\n\n fn view(&self) -> Html {\n html! {\n \n { for self.props.children.iter() }\n
\n }\n }\n}\n"},"download_success":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":2971,"cells":{"blob_id":{"kind":"string","value":"6f26f1b91aa0aa6fbc61955934f49b2b711a4f1e"},"language":{"kind":"string","value":"Rust"},"repo_name":{"kind":"string","value":"cjoh88/Zombie"},"path":{"kind":"string","value":"/src/editor/input.rs"},"src_encoding":{"kind":"string","value":"UTF-8"},"length_bytes":{"kind":"number","value":2246,"string":"2,246"},"score":{"kind":"number","value":2.921875,"string":"2.921875"},"int_score":{"kind":"number","value":3,"string":"3"},"detected_licenses":{"kind":"list like","value":[],"string":"[]"},"license_type":{"kind":"string","value":"no_license"},"text":{"kind":"string","value":"use sfml::window::{Key};\r\nuse sfml::window::{event};\r\nuse sfml::window::MouseButton;\r\nuse sfml::graphics::{RenderWindow};\r\nuse sfml::system::{Vector2i, Vector2f};\r\nuse sfml::graphics::RenderTarget;\r\n\r\nuse editor::world::World;\r\n\r\npub struct EditorInputHandler {\r\n\tdummy: i32\r\n}\r\n\r\nimpl EditorInputHandler {\r\n\tpub fn new() -> Self {\r\n\t\tEditorInputHandler {\r\n\t\t\tdummy: 0,\r\n\t\t}\r\n\t}\r\n\r\n\tpub fn handle_input(&mut self, world: &mut World, window: &mut RenderWindow) {\r\n\t\tfor event in window.events() {\r\n\t\t\tmatch event {\r\n\t\t\t\tevent::Closed => window.close(),\r\n\t\t\t\tevent::KeyPressed{code, ..} => self.handle_key_pressed(world, window, code),\t//world, window, code\r\n\t\t\t\tevent::KeyReleased{code, ..} => self.handle_key_released(world, window, code),\t//world, window, code\r\n\t\t\t\tevent::MouseButtonPressed{button, x, y} => self.handle_mouse_pressed(world, window, button, x, y), //world, window, button, x, y\r\n\t\t\t\t_ => (),\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tfn handle_key_pressed(&mut self, world: &mut World, window: &mut RenderWindow, code: Key) {\r\n\t\tmatch code {\r\n Key::Escape => window.close(),\r\n Key::Right | Key::D => world.get_mut_camera().move_right(),\r\n Key::Left | Key::A => world.get_mut_camera().move_left(),\r\n Key::Up | Key::W => world.get_mut_camera().move_up(),\r\n Key::Down | Key::S => world.get_mut_camera().move_down(),\r\n _ => ()\r\n }\r\n\t}\r\n\tfn handle_key_released(&mut self, world: &mut World, window: &mut RenderWindow, code: Key) {\r\n match code {\r\n Key::Right | Key::Left | Key::D | Key::A => world.get_mut_camera().stop_horizontal(),\r\n Key::Up | Key::Down | Key::W | Key::S => world.get_mut_camera().stop_vertical(),\r\n Key::Add => world.get_mut_camera().zoom(0.5),\r\n Key::Subtract => world.get_mut_camera().zoom(2.0),\r\n _ => ()\r\n }\r\n }\r\n\r\n fn handle_mouse_pressed(&mut self, editor: &mut World, window: &mut RenderWindow, code: MouseButton, x: i32, y: i32) {\r\n /*let v = Vector2i::new(x,y);\r\n let v2: Vector2f = window.map_pixel_to_coords(&v, &editor.get_view());\r\n let v3 = screen_to_map(v2);\r\n println!(\"Mouse({}, {})\", v3.x, v3.y);*/\r\n\r\n }\r\n}"},"download_success":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":2972,"cells":{"blob_id":{"kind":"string","value":"9cfe05532aedfe26141eba73dd1bd0d2ee01e656"},"language":{"kind":"string","value":"Rust"},"repo_name":{"kind":"string","value":"rust-lang/rust-analyzer"},"path":{"kind":"string","value":"/crates/ide-diagnostics/src/handlers/unresolved_macro_call.rs"},"src_encoding":{"kind":"string","value":"UTF-8"},"length_bytes":{"kind":"number","value":1607,"string":"1,607"},"score":{"kind":"number","value":2.796875,"string":"2.796875"},"int_score":{"kind":"number","value":3,"string":"3"},"detected_licenses":{"kind":"list like","value":["Apache-2.0","MIT"],"string":"[\n \"Apache-2.0\",\n \"MIT\"\n]"},"license_type":{"kind":"string","value":"permissive"},"text":{"kind":"string","value":"use crate::{Diagnostic, DiagnosticCode, DiagnosticsContext};\n\n// Diagnostic: unresolved-macro-call\n//\n// This diagnostic is triggered if rust-analyzer is unable to resolve the path\n// to a macro in a macro invocation.\npub(crate) fn unresolved_macro_call(\n ctx: &DiagnosticsContext<'_>,\n d: &hir::UnresolvedMacroCall,\n) -> Diagnostic {\n // Use more accurate position if available.\n let display_range = ctx.resolve_precise_location(&d.macro_call, d.precise_location);\n let bang = if d.is_bang { \"!\" } else { \"\" };\n Diagnostic::new(\n DiagnosticCode::RustcHardError(\"unresolved-macro-call\"),\n format!(\"unresolved macro `{}{bang}`\", d.path.display(ctx.sema.db)),\n display_range,\n )\n .experimental()\n}\n\n#[cfg(test)]\nmod tests {\n use crate::tests::check_diagnostics;\n\n #[test]\n fn unresolved_macro_diag() {\n check_diagnostics(\n r#\"\nfn f() {\n m!();\n} //^ error: unresolved macro `m!`\n\n\"#,\n );\n }\n\n #[test]\n fn test_unresolved_macro_range() {\n check_diagnostics(\n r#\"\nfoo::bar!(92);\n //^^^ error: unresolved macro `foo::bar!`\n\"#,\n );\n }\n\n #[test]\n fn unresolved_legacy_scope_macro() {\n check_diagnostics(\n r#\"\nmacro_rules! m { () => {} }\n\nm!(); m2!();\n //^^ error: unresolved macro `m2!`\n\"#,\n );\n }\n\n #[test]\n fn unresolved_module_scope_macro() {\n check_diagnostics(\n r#\"\nmod mac {\n#[macro_export]\nmacro_rules! m { () => {} } }\n\nself::m!(); self::m2!();\n //^^ error: unresolved macro `self::m2!`\n\"#,\n );\n }\n}\n"},"download_success":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":2973,"cells":{"blob_id":{"kind":"string","value":"2d3c47f93338cb47dfcdef8c16ab9c8fa0fea7bf"},"language":{"kind":"string","value":"Rust"},"repo_name":{"kind":"string","value":"zmbush/cargo"},"path":{"kind":"string","value":"/src/cargo/core/resolver/mod.rs"},"src_encoding":{"kind":"string","value":"UTF-8"},"length_bytes":{"kind":"number","value":22960,"string":"22,960"},"score":{"kind":"number","value":2.546875,"string":"2.546875"},"int_score":{"kind":"number","value":3,"string":"3"},"detected_licenses":{"kind":"list like","value":["GCC-exception-2.0","BSD-3-Clause","LGPL-2.0-or-later","OpenSSL","Zlib","MIT","curl","GPL-2.0-only","LicenseRef-scancode-openssl","LicenseRef-scancode-ssleay-windows","Unlicense","LGPL-2.1-only","Apache-2.0"],"string":"[\n \"GCC-exception-2.0\",\n \"BSD-3-Clause\",\n \"LGPL-2.0-or-later\",\n \"OpenSSL\",\n \"Zlib\",\n \"MIT\",\n \"curl\",\n \"GPL-2.0-only\",\n \"LicenseRef-scancode-openssl\",\n \"LicenseRef-scancode-ssleay-windows\",\n \"Unlicense\",\n \"LGPL-2.1-only\",\n \"Apache-2.0\"\n]"},"license_type":{"kind":"string","value":"permissive"},"text":{"kind":"string","value":"use std::cell::RefCell;\nuse std::collections::HashSet;\nuse std::collections::hash_map::HashMap;\nuse std::fmt;\nuse std::rc::Rc;\nuse semver;\n\nuse core::{PackageId, Registry, SourceId, Summary, Dependency};\nuse core::PackageIdSpec;\nuse util::{CargoResult, Graph, human, ChainError, CargoError};\nuse util::profile;\nuse util::graph::{Nodes, Edges};\n\npub use self::encode::{EncodableResolve, EncodableDependency, EncodablePackageId};\npub use self::encode::Metadata;\n\nmod encode;\n\n/// Represents a fully resolved package dependency graph. Each node in the graph\n/// is a package and edges represent dependencies between packages.\n///\n/// Each instance of `Resolve` also understands the full set of features used\n/// for each package as well as what the root package is.\n#[derive(PartialEq, Eq, Clone)]\npub struct Resolve {\n graph: Graph,\n features: HashMap>,\n root: PackageId,\n metadata: Option,\n}\n\n#[derive(Clone, Copy)]\npub enum Method<'a> {\n Everything,\n Required{ dev_deps: bool,\n features: &'a [String],\n uses_default_features: bool,\n target_platform: Option<&'a str>},\n}\n\nimpl Resolve {\n fn new(root: PackageId) -> Resolve {\n let mut g = Graph::new();\n g.add(root.clone(), &[]);\n Resolve { graph: g, root: root, features: HashMap::new(), metadata: None }\n }\n\n pub fn copy_metadata(&mut self, other: &Resolve) {\n self.metadata = other.metadata.clone();\n }\n\n pub fn iter(&self) -> Nodes {\n self.graph.iter()\n }\n\n pub fn root(&self) -> &PackageId { &self.root }\n\n pub fn deps(&self, pkg: &PackageId) -> Option> {\n self.graph.edges(pkg)\n }\n\n pub fn query(&self, spec: &str) -> CargoResult<&PackageId> {\n let spec = try!(PackageIdSpec::parse(spec).chain_error(|| {\n human(format!(\"invalid package id specification: `{}`\", spec))\n }));\n let mut ids = self.iter().filter(|p| spec.matches(*p));\n let ret = match ids.next() {\n Some(id) => id,\n None => return Err(human(format!(\"package id specification `{}` \\\n matched no packages\", spec))),\n };\n return match ids.next() {\n Some(other) => {\n let mut msg = format!(\"There are multiple `{}` packages in \\\n your project, and the specification \\\n `{}` is ambiguous.\\n\\\n Please re-run this command \\\n with `-p ` where `` is one \\\n of the following:\",\n spec.name(), spec);\n let mut vec = vec![ret, other];\n vec.extend(ids);\n minimize(&mut msg, vec, &spec);\n Err(human(msg))\n }\n None => Ok(ret)\n };\n\n fn minimize(msg: &mut String,\n ids: Vec<&PackageId>,\n spec: &PackageIdSpec) {\n let mut version_cnt = HashMap::new();\n for id in ids.iter() {\n *version_cnt.entry(id.version()).or_insert(0) += 1;\n }\n for id in ids.iter() {\n if version_cnt[id.version()] == 1 {\n msg.push_str(&format!(\"\\n {}:{}\", spec.name(),\n id.version()));\n } else {\n msg.push_str(&format!(\"\\n {}\",\n PackageIdSpec::from_package_id(*id)));\n }\n }\n }\n }\n\n pub fn features(&self, pkg: &PackageId) -> Option<&HashSet> {\n self.features.get(pkg)\n }\n}\n\nimpl fmt::Debug for Resolve {\n fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n try!(write!(fmt, \"graph: {:?}\\n\", self.graph));\n try!(write!(fmt, \"\\nfeatures: {{\\n\"));\n for (pkg, features) in &self.features {\n try!(write!(fmt, \" {}: {:?}\\n\", pkg, features));\n }\n write!(fmt, \"}}\")\n }\n}\n\n#[derive(Clone)]\nstruct Context {\n activations: HashMap<(String, SourceId), Vec>>,\n resolve: Resolve,\n visited: Rc>>,\n}\n\n/// Builds the list of all packages required to build the first argument.\npub fn resolve(summary: &Summary, method: Method,\n registry: &mut Registry) -> CargoResult {\n trace!(\"resolve; summary={}\", summary.package_id());\n let summary = Rc::new(summary.clone());\n\n let cx = Box::new(Context {\n resolve: Resolve::new(summary.package_id().clone()),\n activations: HashMap::new(),\n visited: Rc::new(RefCell::new(HashSet::new())),\n });\n let _p = profile::start(format!(\"resolving: {}\", summary.package_id()));\n match try!(activate(cx, registry, &summary, method)) {\n Ok(cx) => {\n debug!(\"resolved: {:?}\", cx.resolve);\n Ok(cx.resolve)\n }\n Err(e) => Err(e),\n }\n}\n\nfn activate(mut cx: Box,\n registry: &mut Registry,\n parent: &Rc,\n method: Method)\n -> CargoResult>> {\n // Dependency graphs are required to be a DAG, so we keep a set of\n // packages we're visiting and bail if we hit a dupe.\n let id = parent.package_id();\n if !cx.visited.borrow_mut().insert(id.clone()) {\n return Err(human(format!(\"cyclic package dependency: package `{}` \\\n depends on itself\", id)))\n }\n\n // If we're already activated, then that was easy!\n if flag_activated(&mut *cx, parent, &method) {\n cx.visited.borrow_mut().remove(id);\n return Ok(Ok(cx))\n }\n debug!(\"activating {}\", parent.package_id());\n\n // Extracting the platform request.\n let platform = match method {\n Method::Required{target_platform: platform, ..} => platform,\n Method::Everything => None,\n };\n\n // First, figure out our set of dependencies based on the requsted set of\n // features. This also calculates what features we're going to enable for\n // our own dependencies.\n let deps = try!(resolve_features(&mut cx, parent, method));\n\n // Next, transform all dependencies into a list of possible candidates which\n // can satisfy that dependency.\n let mut deps = try!(deps.into_iter().map(|(_dep_name, (dep, features))| {\n let mut candidates = try!(registry.query(dep));\n // When we attempt versions for a package, we'll want to start at the\n // maximum version and work our way down.\n candidates.sort_by(|a, b| {\n b.version().cmp(a.version())\n });\n let candidates = candidates.into_iter().map(Rc::new).collect::>();\n Ok((dep, candidates, features))\n }).collect::>>());\n\n // When we recurse, attempt to resolve dependencies with fewer candidates\n // before recursing on dependencies with more candidates. This way if the\n // dependency with only one candidate can't be resolved we don't have to do\n // a bunch of work before we figure that out.\n deps.sort_by(|&(_, ref a, _), &(_, ref b, _)| {\n a.len().cmp(&b.len())\n });\n\n // Workaround compilation error: `deps` does not live long enough\n let platform = platform.map(|s| &*s);\n\n Ok(match try!(activate_deps(cx, registry, parent, platform, &deps, 0)) {\n Ok(cx) => {\n cx.visited.borrow_mut().remove(parent.package_id());\n Ok(cx)\n }\n Err(e) => Err(e),\n })\n}\n\n// Activate this summary by inserting it into our list of known activations.\n//\n// Returns if this summary with the given method is already activated.\nfn flag_activated(cx: &mut Context,\n summary: &Rc,\n method: &Method) -> bool {\n let id = summary.package_id();\n let key = (id.name().to_string(), id.source_id().clone());\n let prev = cx.activations.entry(key).or_insert(Vec::new());\n if !prev.iter().any(|c| c == summary) {\n cx.resolve.graph.add(id.clone(), &[]);\n prev.push(summary.clone());\n return false\n }\n debug!(\"checking if {} is already activated\", summary.package_id());\n let (features, use_default) = match *method {\n Method::Required { features, uses_default_features, .. } => {\n (features, uses_default_features)\n }\n Method::Everything => return false,\n };\n\n let has_default_feature = summary.features().contains_key(\"default\");\n match cx.resolve.features(id) {\n Some(prev) => {\n features.iter().all(|f| prev.contains(f)) &&\n (!use_default || prev.contains(\"default\") || !has_default_feature)\n }\n None => features.len() == 0 && (!use_default || !has_default_feature)\n }\n}\n\nfn activate_deps<'a>(cx: Box,\n registry: &mut Registry,\n parent: &Summary,\n platform: Option<&'a str>,\n deps: &'a [(&Dependency, Vec>, Vec)],\n cur: usize) -> CargoResult>> {\n if cur == deps.len() { return Ok(Ok(cx)) }\n let (dep, ref candidates, ref features) = deps[cur];\n\n let method = Method::Required{\n dev_deps: false,\n features: &features,\n uses_default_features: dep.uses_default_features(),\n target_platform: platform};\n\n let key = (dep.name().to_string(), dep.source_id().clone());\n let prev_active = cx.activations.get(&key)\n .map(|v| &v[..]).unwrap_or(&[]);\n trace!(\"{}[{}]>{} {} candidates\", parent.name(), cur, dep.name(),\n candidates.len());\n trace!(\"{}[{}]>{} {} prev activations\", parent.name(), cur,\n dep.name(), prev_active.len());\n\n // Filter the set of candidates based on the previously activated\n // versions for this dependency. We can actually use a version if it\n // precisely matches an activated version or if it is otherwise\n // incompatible with all other activated versions. Note that we define\n // \"compatible\" here in terms of the semver sense where if the left-most\n // nonzero digit is the same they're considered compatible.\n let my_candidates = candidates.iter().filter(|&b| {\n prev_active.iter().any(|a| a == b) ||\n prev_active.iter().all(|a| {\n !compatible(a.version(), b.version())\n })\n });\n\n // Alright, for each candidate that's gotten this far, it meets the\n // following requirements:\n //\n // 1. The version matches the dependency requirement listed for this\n // package\n // 2. There are no activated versions for this package which are\n // semver-compatible, or there's an activated version which is\n // precisely equal to `candidate`.\n //\n // This means that we're going to attempt to activate each candidate in\n // turn. We could possibly fail to activate each candidate, so we try\n // each one in turn.\n let mut last_err = None;\n for candidate in my_candidates {\n trace!(\"{}[{}]>{} trying {}\", parent.name(), cur, dep.name(),\n candidate.version());\n let mut my_cx = cx.clone();\n my_cx.resolve.graph.link(parent.package_id().clone(),\n candidate.package_id().clone());\n\n // If we hit an intransitive dependency then clear out the visitation\n // list as we can't induce a cycle through transitive dependencies.\n if !dep.is_transitive() {\n my_cx.visited.borrow_mut().clear();\n }\n let my_cx = match try!(activate(my_cx, registry, candidate, method)) {\n Ok(cx) => cx,\n Err(e) => { last_err = Some(e); continue }\n };\n match try!(activate_deps(my_cx, registry, parent, platform, deps,\n cur + 1)) {\n Ok(cx) => return Ok(Ok(cx)),\n Err(e) => { last_err = Some(e); }\n }\n }\n trace!(\"{}[{}]>{} -- {:?}\", parent.name(), cur, dep.name(),\n last_err);\n\n // Oh well, we couldn't activate any of the candidates, so we just can't\n // activate this dependency at all\n Ok(activation_error(&cx, registry, last_err, parent, dep, prev_active,\n &candidates))\n}\n\nfn activation_error(cx: &Context,\n registry: &mut Registry,\n err: Option>,\n parent: &Summary,\n dep: &Dependency,\n prev_active: &[Rc],\n candidates: &[Rc]) -> CargoResult> {\n match err {\n Some(e) => return Err(e),\n None => {}\n }\n if candidates.len() > 0 {\n let mut msg = format!(\"failed to select a version for `{}` \\\n (required by `{}`):\\n\\\n all possible versions conflict with \\\n previously selected versions of `{}`\",\n dep.name(), parent.name(),\n dep.name());\n 'outer: for v in prev_active.iter() {\n for node in cx.resolve.graph.iter() {\n let edges = match cx.resolve.graph.edges(node) {\n Some(edges) => edges,\n None => continue,\n };\n for edge in edges {\n if edge != v.package_id() { continue }\n\n msg.push_str(&format!(\"\\n version {} in use by {}\",\n v.version(), edge));\n continue 'outer;\n }\n }\n msg.push_str(&format!(\"\\n version {} in use by ??\",\n v.version()));\n }\n\n msg.push_str(&format!(\"\\n possible versions to select: {}\",\n candidates.iter()\n .map(|v| v.version())\n .map(|v| v.to_string())\n .collect::>()\n .connect(\", \")));\n\n return Err(human(msg))\n }\n // Once we're all the way down here, we're definitely lost in the\n // weeds! We didn't actually use any candidates above, so we need to\n // give an error message that nothing was found.\n //\n // Note that we re-query the registry with a new dependency that\n // allows any version so we can give some nicer error reporting\n // which indicates a few versions that were actually found.\n let msg = format!(\"no matching package named `{}` found \\\n (required by `{}`)\\n\\\n location searched: {}\\n\\\n version required: {}\",\n dep.name(), parent.name(),\n dep.source_id(),\n dep.version_req());\n let mut msg = msg;\n let all_req = semver::VersionReq::parse(\"*\").unwrap();\n let new_dep = dep.clone().set_version_req(all_req);\n let mut candidates = try!(registry.query(&new_dep));\n candidates.sort_by(|a, b| {\n b.version().cmp(a.version())\n });\n if candidates.len() > 0 {\n msg.push_str(\"\\nversions found: \");\n for (i, c) in candidates.iter().take(3).enumerate() {\n if i != 0 { msg.push_str(\", \"); }\n msg.push_str(&c.version().to_string());\n }\n if candidates.len() > 3 {\n msg.push_str(\", ...\");\n }\n }\n\n // If we have a path dependency with a locked version, then this may\n // indicate that we updated a sub-package and forgot to run `cargo\n // update`. In this case try to print a helpful error!\n if dep.source_id().is_path() &&\n dep.version_req().to_string().starts_with(\"=\") &&\n candidates.len() > 0 {\n msg.push_str(\"\\nconsider running `cargo update` to update \\\n a path dependency's locked version\");\n\n }\n Err(human(msg))\n}\n\n// Returns if `a` and `b` are compatible in the semver sense. This is a\n// commutative operation.\n//\n// Versions `a` and `b` are compatible if their left-most nonzero digit is the\n// same.\nfn compatible(a: &semver::Version, b: &semver::Version) -> bool {\n if a.major != b.major { return false }\n if a.major != 0 { return true }\n if a.minor != b.minor { return false }\n if a.minor != 0 { return true }\n a.patch == b.patch\n}\n\nfn resolve_features<'a>(cx: &mut Context, parent: &'a Summary,\n method: Method)\n -> CargoResult)>> {\n let dev_deps = match method {\n Method::Everything => true,\n Method::Required { dev_deps, .. } => dev_deps,\n };\n\n // First, filter by dev-dependencies\n let deps = parent.dependencies();\n let deps = deps.iter().filter(|d| d.is_transitive() || dev_deps);\n\n // Second, ignoring dependencies that should not be compiled for this platform\n let deps = deps.filter(|d| {\n match method {\n Method::Required{target_platform: Some(ref platform), ..} => {\n d.is_active_for_platform(platform)\n },\n _ => true\n }\n });\n\n let (mut feature_deps, used_features) = try!(build_features(parent, method));\n let mut ret = HashMap::new();\n\n // Next, sanitize all requested features by whitelisting all the requested\n // features that correspond to optional dependencies\n for dep in deps {\n // weed out optional dependencies, but not those required\n if dep.is_optional() && !feature_deps.contains_key(dep.name()) {\n continue\n }\n let mut base = feature_deps.remove(dep.name()).unwrap_or(vec![]);\n for feature in dep.features().iter() {\n base.push(feature.clone());\n if feature.contains(\"/\") {\n return Err(human(format!(\"features in dependencies \\\n cannot enable features in \\\n other dependencies: `{}`\",\n feature)));\n }\n }\n ret.insert(dep.name(), (dep, base));\n }\n\n // All features can only point to optional dependencies, in which case they\n // should have all been weeded out by the above iteration. Any remaining\n // features are bugs in that the package does not actually have those\n // features.\n if feature_deps.len() > 0 {\n let unknown = feature_deps.keys().map(|s| &s[..])\n .collect::>();\n if unknown.len() > 0 {\n let features = unknown.connect(\", \");\n return Err(human(format!(\"Package `{}` does not have these features: \\\n `{}`\", parent.package_id(), features)))\n }\n }\n\n // Record what list of features is active for this package.\n if used_features.len() > 0 {\n let pkgid = parent.package_id();\n cx.resolve.features.entry(pkgid.clone())\n .or_insert(HashSet::new())\n .extend(used_features);\n }\n\n Ok(ret)\n}\n\n// Returns a pair of (feature dependencies, all used features)\n//\n// The feature dependencies map is a mapping of package name to list of features\n// enabled. Each package should be enabled, and each package should have the\n// specified set of features enabled.\n//\n// The all used features set is the set of features which this local package had\n// enabled, which is later used when compiling to instruct the code what\n// features were enabled.\nfn build_features(s: &Summary, method: Method)\n -> CargoResult<(HashMap>, HashSet)> {\n let mut deps = HashMap::new();\n let mut used = HashSet::new();\n let mut visited = HashSet::new();\n match method {\n Method::Everything => {\n for key in s.features().keys() {\n try!(add_feature(s, key, &mut deps, &mut used, &mut visited));\n }\n for dep in s.dependencies().iter().filter(|d| d.is_optional()) {\n try!(add_feature(s, dep.name(), &mut deps, &mut used,\n &mut visited));\n }\n }\n Method::Required{features: requested_features, ..} => {\n for feat in requested_features.iter() {\n try!(add_feature(s, feat, &mut deps, &mut used, &mut visited));\n }\n }\n }\n match method {\n Method::Everything |\n Method::Required { uses_default_features: true, .. } => {\n if s.features().get(\"default\").is_some() {\n try!(add_feature(s, \"default\", &mut deps, &mut used,\n &mut visited));\n }\n }\n Method::Required { uses_default_features: false, .. } => {}\n }\n return Ok((deps, used));\n\n fn add_feature(s: &Summary, feat: &str,\n deps: &mut HashMap>,\n used: &mut HashSet,\n visited: &mut HashSet) -> CargoResult<()> {\n if feat.is_empty() { return Ok(()) }\n\n // If this feature is of the form `foo/bar`, then we just lookup package\n // `foo` and enable its feature `bar`. Otherwise this feature is of the\n // form `foo` and we need to recurse to enable the feature `foo` for our\n // own package, which may end up enabling more features or just enabling\n // a dependency.\n let mut parts = feat.splitn(2, '/');\n let feat_or_package = parts.next().unwrap();\n match parts.next() {\n Some(feat) => {\n let package = feat_or_package;\n deps.entry(package.to_string())\n .or_insert(Vec::new())\n .push(feat.to_string());\n }\n None => {\n let feat = feat_or_package;\n if !visited.insert(feat.to_string()) {\n return Err(human(format!(\"Cyclic feature dependency: \\\n feature `{}` depends on itself\",\n feat)))\n }\n used.insert(feat.to_string());\n match s.features().get(feat) {\n Some(recursive) => {\n for f in recursive {\n try!(add_feature(s, f, deps, used, visited));\n }\n }\n None => {\n deps.entry(feat.to_string()).or_insert(Vec::new());\n }\n }\n visited.remove(&feat.to_string());\n }\n }\n Ok(())\n }\n}\n"},"download_success":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":2974,"cells":{"blob_id":{"kind":"string","value":"1b4b1f4dd67bdc635d7c5d9cf5b1e7eb4b3d0c49"},"language":{"kind":"string","value":"Rust"},"repo_name":{"kind":"string","value":"superhawk610/too-many-lists"},"path":{"kind":"string","value":"/src/first_improved.rs"},"src_encoding":{"kind":"string","value":"UTF-8"},"length_bytes":{"kind":"number","value":1590,"string":"1,590"},"score":{"kind":"number","value":3.984375,"string":"3.984375"},"int_score":{"kind":"number","value":4,"string":"4"},"detected_licenses":{"kind":"list like","value":[],"string":"[]"},"license_type":{"kind":"string","value":"no_license"},"text":{"kind":"string","value":"/// some easy improvements over `first`\n///\n/// 1) change `Link` to simply alias `Option>`\n/// 2) substitute `std::mem::replace(x, None)` with `x.take()` (yay, options!)\n/// 3) substitute `match option { None => None, Some(x) => Some(y) }` with `option.map(|x| y)`\n\npub struct List {\n head: Link,\n}\n\nstruct Node {\n elem: i32,\n next: Link,\n}\n\ntype Link = Option>;\n\nimpl List {\n pub fn new() -> Self {\n List { head: None }\n }\n\n pub fn push(&mut self, elem: i32) {\n let new_node = Box::new(Node {\n elem: elem,\n next: self.head.take(),\n });\n\n self.head = Some(new_node);\n }\n\n pub fn pop(&mut self) -> Option {\n self.pop_node().map(|node| node.elem)\n }\n\n fn pop_node(&mut self) -> Link {\n self.head.take().map(|mut node| {\n self.head = node.next.take();\n node\n })\n }\n}\n\nimpl Drop for List {\n fn drop(&mut self) {\n while let Some(_) = self.pop_node() {}\n }\n}\n\n#[cfg(test)]\nmod test {\n use super::*;\n\n #[test]\n fn basics() {\n let mut list = List::new();\n\n list.push(1);\n list.push(2);\n list.push(3);\n\n // normal removal...\n assert_eq!(list.pop(), Some(3));\n assert_eq!(list.pop(), Some(2));\n\n list.push(4);\n list.push(5);\n\n // some more normal removal...\n assert_eq!(list.pop(), Some(5));\n assert_eq!(list.pop(), Some(4));\n\n // and exhaustion...\n assert_eq!(list.pop(), Some(1));\n assert_eq!(list.pop(), None);\n }\n}\n"},"download_success":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":2975,"cells":{"blob_id":{"kind":"string","value":"c5dcb378d3f65c5222879e2c91b862b6baf218aa"},"language":{"kind":"string","value":"Rust"},"repo_name":{"kind":"string","value":"steveklabnik/clog"},"path":{"kind":"string","value":"/src/main.rs"},"src_encoding":{"kind":"string","value":"UTF-8"},"length_bytes":{"kind":"number","value":2413,"string":"2,413"},"score":{"kind":"number","value":2.59375,"string":"2.59375"},"int_score":{"kind":"number","value":3,"string":"3"},"detected_licenses":{"kind":"list like","value":["MIT"],"string":"[\n \"MIT\"\n]"},"license_type":{"kind":"string","value":"permissive"},"text":{"kind":"string","value":"#![crate_name = \"clog\"]\n#![comment = \"A conventional changelog generator\"]\n#![license = \"MIT\"]\n#![feature(macro_rules, phase)]\n\nextern crate regex;\n#[phase(plugin)]\nextern crate regex_macros;\nextern crate serialize;\n#[phase(plugin)] extern crate docopt_macros;\nextern crate docopt;\nextern crate time;\n\nuse git::{ LogReaderConfig };\nuse log_writer::{ LogWriter, LogWriterOptions };\nuse std::io::{File, Open, Write};\nuse docopt::FlagParser;\n\nmod common;\nmod git;\nmod log_writer;\nmod section_builder;\n\ndocopt!(Args, \"clog\n\nUsage:\n clog [--repository= --setversion= --subtitle= \n --from= --to= --from-latest-tag]\n\nOptions:\n -h --help Show this screen.\n --version Show version\n -r --repository= e.g https://github.com/thoughtram/clog\n --setversion= e.g. 0.1.0\n --subtitle= e.g. crazy-release-name\n --from= e.g. 12a8546\n --to= e.g. 8057684\n --from-latest-tag uses the latest tag as starting point. Ignores other --from parameter\")\n\nfn main () {\n\n let start_nsec = ::time::get_time().nsec;\n let args: Args = FlagParser::parse().unwrap_or_else(|e| e.exit());\n\n let log_reader_config = LogReaderConfig {\n grep: \"^feat|^fix|BREAKING'\".to_string(),\n format: \"%H%n%s%n%b%n==END==\".to_string(),\n from: if args.flag_from_latest_tag { ::git::get_latest_tag() } else { args.flag_from },\n to: args.flag_to\n };\n\n let commits = ::git::get_log_entries(log_reader_config);\n\n let sections = ::section_builder::build_sections(commits.clone());\n\n let contents = match File::open(&Path::new(\"changelog.md\")).read_to_string() {\n Ok(content) => content,\n Err(_) => \"\".to_string()\n };\n\n let mut file = File::open_mode(&Path::new(\"changelog.md\"), Open, Write).ok().unwrap();\n let mut writer = LogWriter::new(&mut file, LogWriterOptions { \n repository_link: args.flag_repository,\n version: args.flag_setversion,\n subtitle: args.flag_subtitle\n });\n\n writer.write_header();\n writer.write_section(\"Bug Fixes\", §ions.fixes);\n writer.write_section(\"Features\", §ions.features);\n writer.write(contents.as_slice());\n\n let end_nsec = ::time::get_time().nsec;\n let elapsed_mssec = (end_nsec - start_nsec) / 1000000;\n println!(\"changelog updated. (took {} ms)\", elapsed_mssec);\n}\n"},"download_success":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":2976,"cells":{"blob_id":{"kind":"string","value":"62aae4363ffd1c7035a96dc556dd050825538727"},"language":{"kind":"string","value":"Rust"},"repo_name":{"kind":"string","value":"geoffjay/codility-rs"},"path":{"kind":"string","value":"/src/binary-gap/lib.rs"},"src_encoding":{"kind":"string","value":"UTF-8"},"length_bytes":{"kind":"number","value":1401,"string":"1,401"},"score":{"kind":"number","value":3.375,"string":"3.375"},"int_score":{"kind":"number","value":3,"string":"3"},"detected_licenses":{"kind":"list like","value":[],"string":"[]"},"license_type":{"kind":"string","value":"no_license"},"text":{"kind":"string","value":"#![feature(test)]\n\nextern crate test;\n\npub fn solution(n: i32) -> i32 {\n let mut gap = 0;\n let mut largest = 0;\n let mut num = n;\n let mut init = false;\n loop {\n // increase gap size when number is zero, and count has been initialized\n if num & 1 == 0 {\n if init {\n gap += 1;\n }\n } else {\n if gap > largest {\n largest = gap;\n }\n gap = 0;\n // start the count once a 1 has been seen\n init = true;\n }\n num >>= 1;\n if num == 0 {\n break;\n }\n }\n largest\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n use test::Bencher;\n\n #[test]\n fn it_works() {\n assert_eq!(solution(9), 2);\n assert_eq!(solution(529), 4);\n assert_eq!(solution(20), 1);\n assert_eq!(solution(15), 0);\n assert_eq!(solution(1041), 5);\n assert_eq!(solution(32), 0);\n assert_eq!(solution(0b0000), 0);\n assert_eq!(solution(0b10000), 0);\n assert_eq!(solution(0b10000000), 0);\n assert_eq!(solution(0b10000001), 6);\n }\n\n #[bench]\n #[ignore]\n fn bench_solution(b: &mut Bencher) {\n b.iter(|| solution(204913));\n }\n\n #[bench]\n #[ignore]\n fn bench_solution_many(b: &mut Bencher) {\n b.iter(|| (0..10000).map(solution).collect::>())\n }\n}\n"},"download_success":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":2977,"cells":{"blob_id":{"kind":"string","value":"7ead7a9fcd57b7a557255d3c2f5a347291de7637"},"language":{"kind":"string","value":"Rust"},"repo_name":{"kind":"string","value":"rust-embedded/embedded-hal"},"path":{"kind":"string","value":"/embedded-hal-nb/src/serial.rs"},"src_encoding":{"kind":"string","value":"UTF-8"},"length_bytes":{"kind":"number","value":3970,"string":"3,970"},"score":{"kind":"number","value":3.421875,"string":"3.421875"},"int_score":{"kind":"number","value":3,"string":"3"},"detected_licenses":{"kind":"list like","value":["MIT","Apache-2.0","LicenseRef-scancode-unknown-license-reference"],"string":"[\n \"MIT\",\n \"Apache-2.0\",\n \"LicenseRef-scancode-unknown-license-reference\"\n]"},"license_type":{"kind":"string","value":"permissive"},"text":{"kind":"string","value":"//! Serial interface.\n\n/// Serial error.\npub trait Error: core::fmt::Debug {\n /// Convert error to a generic serial error kind\n ///\n /// By using this method, serial errors freely defined by HAL implementations\n /// can be converted to a set of generic serial errors upon which generic\n /// code can act.\n fn kind(&self) -> ErrorKind;\n}\n\nimpl Error for core::convert::Infallible {\n #[inline]\n fn kind(&self) -> ErrorKind {\n match *self {}\n }\n}\n\n/// Serial error kind.\n///\n/// This represents a common set of serial operation errors. HAL implementations are\n/// free to define more specific or additional error types. However, by providing\n/// a mapping to these common serial errors, generic code can still react to them.\n#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]\n#[non_exhaustive]\npub enum ErrorKind {\n /// The peripheral receive buffer was overrun.\n Overrun,\n /// Received data does not conform to the peripheral configuration.\n /// Can be caused by a misconfigured device on either end of the serial line.\n FrameFormat,\n /// Parity check failed.\n Parity,\n /// Serial line is too noisy to read valid data.\n Noise,\n /// A different error occurred. The original error may contain more information.\n Other,\n}\n\nimpl Error for ErrorKind {\n #[inline]\n fn kind(&self) -> ErrorKind {\n *self\n }\n}\n\nimpl core::fmt::Display for ErrorKind {\n #[inline]\n fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {\n match self {\n Self::Overrun => write!(f, \"The peripheral receive buffer was overrun\"),\n Self::Parity => write!(f, \"Parity check failed\"),\n Self::Noise => write!(f, \"Serial line is too noisy to read valid data\"),\n Self::FrameFormat => write!(\n f,\n \"Received data does not conform to the peripheral configuration\"\n ),\n Self::Other => write!(\n f,\n \"A different error occurred. The original error may contain more information\"\n ),\n }\n }\n}\n\n/// Serial error type trait.\n///\n/// This just defines the error type, to be used by the other traits.\npub trait ErrorType {\n /// Error type\n type Error: Error;\n}\n\nimpl ErrorType for &mut T {\n type Error = T::Error;\n}\n\n/// Read half of a serial interface.\n///\n/// Some serial interfaces support different data sizes (8 bits, 9 bits, etc.);\n/// This can be encoded in this trait via the `Word` type parameter.\npub trait Read: ErrorType {\n /// Reads a single word from the serial interface\n fn read(&mut self) -> nb::Result;\n}\n\nimpl + ?Sized, Word: Copy> Read for &mut T {\n #[inline]\n fn read(&mut self) -> nb::Result {\n T::read(self)\n }\n}\n\n/// Write half of a serial interface.\npub trait Write: ErrorType {\n /// Writes a single word to the serial interface.\n fn write(&mut self, word: Word) -> nb::Result<(), Self::Error>;\n\n /// Ensures that none of the previously written words are still buffered.\n fn flush(&mut self) -> nb::Result<(), Self::Error>;\n}\n\nimpl + ?Sized, Word: Copy> Write for &mut T {\n #[inline]\n fn write(&mut self, word: Word) -> nb::Result<(), Self::Error> {\n T::write(self, word)\n }\n\n #[inline]\n fn flush(&mut self) -> nb::Result<(), Self::Error> {\n T::flush(self)\n }\n}\n\n/// Implementation of `core::fmt::Write` for the HAL's `serial::Write`.\n///\n/// TODO write example of usage\n\nimpl core::fmt::Write for dyn Write + '_\nwhere\n Word: Copy + From,\n{\n #[inline]\n fn write_str(&mut self, s: &str) -> core::fmt::Result {\n let _ = s\n .bytes()\n .map(|c| nb::block!(self.write(Word::from(c))))\n .last();\n Ok(())\n }\n}\n"},"download_success":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":2978,"cells":{"blob_id":{"kind":"string","value":"963697e7187c6fc18e4ed1c62c6b6aff79afb9cb"},"language":{"kind":"string","value":"Rust"},"repo_name":{"kind":"string","value":"MiyamonY/atcoder"},"path":{"kind":"string","value":"/abc/036/d/01/src/main.rs"},"src_encoding":{"kind":"string","value":"UTF-8"},"length_bytes":{"kind":"number","value":2655,"string":"2,655"},"score":{"kind":"number","value":2.859375,"string":"2.859375"},"int_score":{"kind":"number","value":3,"string":"3"},"detected_licenses":{"kind":"list like","value":[],"string":"[]"},"license_type":{"kind":"string","value":"no_license"},"text":{"kind":"string","value":"#[allow(unused_macros)]\nmacro_rules! scan {\n () => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n line.trim().to_string()\n }\n };\n (;;) => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n line.trim().split_whitespace().map(|s| s.to_string()).collect::>()\n }\n };\n (;;$n:expr) => {\n {\n (0..$n).map(|_| scan!()).collect::>()\n }\n };\n ($t:ty) => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n line.trim().parse::<$t>().unwrap()\n }\n };\n ($($t:ty),*) => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n let mut iter = line.split_whitespace();\n (\n $(iter.next().unwrap().parse::<$t>().unwrap(),)*\n )\n }\n };\n ($t:ty;;) => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n line.split_whitespace()\n .map(|t| t.parse::<$t>().unwrap())\n .collect::>()\n }\n };\n ($t:ty;;$n:expr) => {\n (0..$n).map(|_| scan!($t;;)).collect::>()\n };\n ($t:ty; $n:expr) => {\n (0..$n).map(|_|\n scan!($t)\n ).collect::>()\n };\n ($($t:ty),*; $n:expr) => {\n (0..$n).map(|_|\n scan!($($t),*)\n ).collect::>()\n };\n}\n\nconst MOD: i64 = 1_000_000_007;\n\nfn dfs_w(graph: &[Vec], p: usize, n: usize, dp: &mut [Option]) -> i64 {\n let mut whites = 1;\n for &g in &graph[n] {\n if g != p {\n whites *= dfs(graph, n, g, dp);\n whites %= MOD;\n }\n }\n whites\n}\n\nfn dfs(graph: &[Vec], p: usize, n: usize, dp: &mut [Option]) -> i64 {\n if let Some(v) = dp[n] {\n return v;\n }\n\n let mut whites = 1;\n for &g in &graph[n] {\n if g != p {\n whites *= dfs_w(graph, n, g, dp);\n whites %= MOD;\n }\n }\n let v = (dfs_w(graph, p, n, dp) + whites) % MOD;\n dp[n] = Some(v);\n v\n}\n\nfn main() {\n let n = scan!(usize);\n\n let mut graph = vec![vec![]; n + 1];\n for _ in 0..n - 1 {\n let (a, b) = scan!(usize, usize);\n graph[a].push(b);\n graph[b].push(a);\n }\n\n let mut dp = vec![None; n + 1];\n println!(\"{}\", dfs(&graph, 0, 1, &mut dp));\n}\n"},"download_success":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":2979,"cells":{"blob_id":{"kind":"string","value":"c476bad1aefaa05cf003fa16b01a4248b0e75bc9"},"language":{"kind":"string","value":"Rust"},"repo_name":{"kind":"string","value":"liu-hz18/rCore-v2"},"path":{"kind":"string","value":"/src/process/kernel_stack.rs"},"src_encoding":{"kind":"string","value":"UTF-8"},"length_bytes":{"kind":"number","value":3748,"string":"3,748"},"score":{"kind":"number","value":3.5,"string":"3.5"},"int_score":{"kind":"number","value":4,"string":"4"},"detected_licenses":{"kind":"list like","value":[],"string":"[]"},"license_type":{"kind":"string","value":"no_license"},"text":{"kind":"string","value":"//! 内核栈 [`KernelStack`]\r\n//!\r\n//! 用户态的线程出现中断时，因为用户栈无法保证可用性，中断处理流程必须在内核栈上进行。\r\n//! 所以我们创建一个公用的内核栈，即当发生中断时，会将 Context 写到内核栈顶。\r\n//!\r\n//! ### 线程 [`Context`] 的存放\r\n//! > 1. 线程初始化时，一个 `Context` 放置在内核栈顶，`sp` 指向 `Context` 的位置\r\n//! > （即 栈顶 - `size_of::()`）\r\n//! > 2. 切换到线程，执行 `__restore` 时，将 `Context` 的数据恢复到寄存器中后，\r\n//! > 会将 `Context` 出栈（即 `sp += size_of::()`），\r\n//! > 然后保存 `sp` 至 `sscratch`（此时 `sscratch` 即为内核栈顶）\r\n//! > 3. 发生中断时，将 `sscratch` 和 `sp` 互换，入栈一个 `Context` 并保存数据\r\n//!\r\n//! 容易发现，线程的 `Context` 一定保存在内核栈顶。因此，当线程需要运行(切换到)时，\r\n//! 从 [`Thread`] 中取出 `Context` 然后置于内核栈顶即可\r\n\r\n// 做法:\r\n// 1. 预留一段空间作为内核栈\r\n// 2. 运行线程时，在 sscratch 寄存器中保存内核栈顶指针\r\n// 3. 如果线程遇到中断，则将 Context 压入 sscratch 指向的栈中（Context 的地址为 sscratch - size_of::()），同时用新的栈地址来替换 sp（此时 sp 也会被复制到 a0 作为 handle_interrupt 的参数）\r\n// 4. 从中断中返回时（__restore 时），a0 应指向被压在内核栈中的 Context。此时出栈 Context 并且将栈顶保存到 sscratch 中\r\n\r\nuse super::*;\r\nuse core::mem::size_of;\r\n\r\n/// 内核栈\r\n#[repr(align(16))]\r\n#[repr(C)]\r\npub struct KernelStack([u8; KERNEL_STACK_SIZE]);\r\n\r\n/// 公用的内核栈\r\npub static mut KERNEL_STACK: KernelStack = KernelStack([0; KERNEL_STACK_SIZE]);\r\n\r\n// 创建线程时，需要使用的操作就是在内核栈顶压入一个初始状态 Context\r\nimpl KernelStack {\r\n /// 在栈顶加入 Context 并且返回新的栈顶指针\r\n pub fn push_context(&mut self, context: Context) -> *mut Context {\r\n // 栈顶sp\r\n let stack_top = &self.0 as *const _ as usize + size_of::();\r\n // Context 的位置\r\n let push_address = (stack_top - size_of::()) as *mut Context; // 编译器负责解析这个指针\r\n // Context 压入栈顶\r\n unsafe {\r\n *push_address = context; // 编译器负责对内存对应位置依次赋值\r\n }\r\n push_address\r\n }\r\n}\r\n\r\n// 关于内核栈(和sscratch)的作用的探讨:\r\n/*\r\n 如果不使用 sscratch 提供内核栈，而是像原来一样，遇到中断就直接将上下文压栈, 会有什么问题?\r\n 1. 一种情况不会出现问题： 只运行一个非常善意的线程，比如 loop {}\r\n 2. 一种情况导致异常无法处理（指无法进入 handle_interrupt）:\r\n 线程把自己的 sp 搞丢了，比如 mv sp, x0。此时无法保存寄存器，也没有能够支持操作系统正常运行的栈\r\n 3. 一种情况导致产生嵌套异常（指第二个异常能够进行到调用 handle_interrupt 时，不考虑后续执行情况）\r\n 运行两个线程。在两个线程切换的时候，会需要切换页表。但是此时操作系统运行在前一个线程的栈上，一旦切换，再访问栈就会导致缺页，因为每个线程的栈只在自己的页表中\r\n 4. 一种情况导致一个用户进程（先不考虑是怎么来的）可以将自己变为内核进程，或以内核态执行自己的代码\r\n 用户进程巧妙地设计 sp，使得它恰好落在内核的某些变量附近，于是在保存寄存器时就修改了变量的值。这相当于任意修改操作系统的控制信息\r\n*/\r\n"},"download_success":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":2980,"cells":{"blob_id":{"kind":"string","value":"c35f2531daf6327618f829e4d7e15ea4dc61309f"},"language":{"kind":"string","value":"Rust"},"repo_name":{"kind":"string","value":"gdoct/rustvm"},"path":{"kind":"string","value":"/src/instructions/asl.rs"},"src_encoding":{"kind":"string","value":"UTF-8"},"length_bytes":{"kind":"number","value":2522,"string":"2,522"},"score":{"kind":"number","value":3.140625,"string":"3.140625"},"int_score":{"kind":"number","value":3,"string":"3"},"detected_licenses":{"kind":"list like","value":["BSD-3-Clause"],"string":"[\n \"BSD-3-Clause\"\n]"},"license_type":{"kind":"string","value":"permissive"},"text":{"kind":"string","value":"use crate::traits::{ Instruction, VirtualCpu };\nuse crate::types::{ Byte };\nuse crate::instructions::generic::*;\n\nfn asl(cpu: &mut dyn VirtualCpu, num: Byte, with: Byte) {\n let asl = num << with;\n cpu.set_a(asl);\n}\n\n/// AslZp: ASL zeropage\n/// Arithmetic Shift Left (ASL) operation between \n/// the content of Accumulator and the content of \n/// the zero page address\npub struct AslZp { }\nimpl Instruction for AslZp {\n fn opcode (&self) -> &'static str { \"ASL\"}\n fn hexcode(&self) -> Byte { 0x06 }\n fn execute(&self, cpu: &mut dyn VirtualCpu) -> std::io::Result<()> {\n let zp = fetch_zp_val(cpu)?;\n let a = cpu.get_a();\n asl(cpu, a, zp);\n Ok(())\n }\n}\n\n/// Asl: ASL \n/// Arithmetic Shift Left (ASL) operation between immediate val\n/// and the content of the Accumulator\npub struct Asl { }\nimpl Instruction for Asl {\n fn opcode (&self) -> &'static str { \"ASL\"}\n fn hexcode(&self) -> Byte { 0x0A }\n fn execute(&self, cpu: &mut dyn VirtualCpu) -> std::io::Result<()> {\n let imm = fetch_imm_val(cpu)?;\n let a = cpu.get_a();\n asl(cpu, imm, a);\n Ok(())\n }\n}\n\n/// AslAbs: ASL absolute\n/// Arithmetic Shift Left (ASL) operation between the content of \n/// Accumulator and the content located at address $1234\npub struct AslAbs { }\nimpl Instruction for AslAbs {\n fn opcode (&self) -> &'static str { \"ASL\"}\n fn hexcode(&self) -> Byte { 0x0E }\n fn execute(&self, cpu: &mut dyn VirtualCpu) -> std::io::Result<()> {\n let val = fetch_abs_val(cpu)?;\n let a = cpu.get_a();\n asl(cpu, a, val);\n Ok(())\n }\n}\n\n/// AslZpX: ASL absolute, indexed by X\npub struct AslZpX { }\nimpl Instruction for AslZpX {\n fn opcode (&self) -> &'static str { \"ASL\"}\n fn hexcode(&self) -> Byte { 0x16 }\n fn execute(&self, cpu: &mut dyn VirtualCpu) -> std::io::Result<()> {\n let val = fetch_absx_val(cpu)?;\n let a = cpu.get_a();\n asl(cpu, a, val);\n Ok(())\n }\n}\n\n/// AslAbsX: ASL absolute, indexed by X\n/// Arithmetic Shift Left (ASL) operation between the content of Accumulator and the content \n/// located at address calculated from $1234 adding content of X\npub struct AslAbsX { }\nimpl Instruction for AslAbsX {\n fn opcode (&self) -> &'static str { \"ASL\"}\n fn hexcode(&self) -> Byte { 0x1E }\n fn execute(&self, cpu: &mut dyn VirtualCpu) -> std::io::Result<()> {\n let val = fetch_absx_val(cpu)?;\n let a = cpu.get_a();\n asl(cpu, a, val);\n Ok(())\n }\n}\n"},"download_success":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":2981,"cells":{"blob_id":{"kind":"string","value":"f7d335dc73bf00f15287442fb8a40d2d3abe1ccc"},"language":{"kind":"string","value":"Rust"},"repo_name":{"kind":"string","value":"jamestthompson3/subtxt-rs"},"path":{"kind":"string","value":"/src/lib.rs"},"src_encoding":{"kind":"string","value":"UTF-8"},"length_bytes":{"kind":"number","value":2535,"string":"2,535"},"score":{"kind":"number","value":3.75,"string":"3.75"},"int_score":{"kind":"number","value":4,"string":"4"},"detected_licenses":{"kind":"list like","value":[],"string":"[]"},"license_type":{"kind":"string","value":"no_license"},"text":{"kind":"string","value":"pub struct Parser<'a> {\n input: std::str::Lines<'a>,\n}\n\nimpl<'a> Parser<'a> {\n pub fn new(text: &'a str) -> Self {\n Self {\n input: text.lines(),\n }\n }\n}\n\nimpl<'a> Iterator for Parser<'a> {\n type Item = Event<'a>;\n fn next(&mut self) -> Option {\n match self.input.next() {\n Some(line) => {\n if line.is_empty() {\n return Some(Event::Empty);\n }\n let mut chars = line.chars();\n match (chars.next().unwrap(), chars.next().unwrap()) {\n ('#', ' ') => Some(Event::Heading(line.split_at(2).1)),\n ('-', ' ') => Some(Event::List(line.split_at(2).1)),\n ('&', ' ') => Some(Event::Link(line.split_at(2).1)),\n ('>', ' ') => Some(Event::Quote(line.split_at(2).1)),\n _ => Some(Event::Text(line)),\n }\n }\n None => None,\n }\n }\n}\n\n#[derive(Debug, PartialEq)]\npub enum Event<'a> {\n Heading(&'a str),\n Text(&'a str),\n List(&'a str),\n Quote(&'a str),\n Link(&'a str),\n Empty,\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n #[test]\n fn parse_normal_input() {\n let test_string = \"# Heading\\n- List1\";\n let parser = Parser::new(test_string);\n let events = parser.collect::>();\n\n assert_eq!(events[0], Event::Heading(\"Heading\"));\n assert_eq!(events[1], Event::List(\"List1\"));\n }\n\n #[test]\n fn parse_malformed_input() {\n let test_string = \"# \";\n let parser = Parser::new(test_string);\n let events = parser.collect::>();\n\n assert_eq!(events[0], Event::Heading(\"\"));\n }\n\n #[test]\n fn parse_malformed_and_normal_input() {\n let test_string = \"# \\n- List1\";\n let parser = Parser::new(test_string);\n let events = parser.collect::>();\n\n assert_eq!(events[0], Event::Heading(\"\"));\n assert_eq!(events[1], Event::List(\"List1\"));\n }\n\n #[test]\n fn parse_typo_input() {\n let test_string = \"-List1\";\n let parser = Parser::new(test_string);\n let events = parser.collect::>();\n\n assert_eq!(events[0], Event::Text(\"-List1\"));\n }\n\n #[test]\n fn parse_empty_lines() {\n let test_string = \"asdf\\n\\nasdf\";\n let parser = Parser::new(test_string);\n let events = parser.collect::>();\n\n assert_eq!(events[1], Event::Empty);\n }\n}\n"},"download_success":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":2982,"cells":{"blob_id":{"kind":"string","value":"31e738f9fca604d1584626d02ea022781ef862b6"},"language":{"kind":"string","value":"Rust"},"repo_name":{"kind":"string","value":"SymmetricChaos/project_euler_rust"},"path":{"kind":"string","value":"/src/worked_problems/euler_76.rs"},"src_encoding":{"kind":"string","value":"UTF-8"},"length_bytes":{"kind":"number","value":2993,"string":"2,993"},"score":{"kind":"number","value":3.5625,"string":"3.5625"},"int_score":{"kind":"number","value":4,"string":"4"},"detected_licenses":{"kind":"list like","value":[],"string":"[]"},"license_type":{"kind":"string","value":"no_license"},"text":{"kind":"string","value":"// Problem: How many different ways can one hundred be written as a sum of at least two positive integers?\n/*\n*/\n\nstruct AllIntegers {\n ctr: i64,\n parity: u8,\n} \n\nimpl Iterator for AllIntegers {\n type Item = i64;\n\n fn next(&mut self) -> Option {\n if self.parity == 0 {\n self.parity = 1;\n return Some(self.ctr)\n } else {\n self.parity = 0;\n self.ctr += 1;\n return Some(-(self.ctr-1))\n }\n }\n}\n\nfn gen_pentagonal(n: i64) -> i64 {\n (3*n*n-n)/2\n}\n\npub fn euler76() -> u64 {\n let mut known_partitions = [0i64;101];\n known_partitions[0] = 1;\n known_partitions[1] = 1;\n\n for n in 2..=100 {\n let mut ctr = AllIntegers{ctr: 1, parity: 0};\n let mut p = gen_pentagonal(ctr.next().unwrap());\n let mut sum = 0;\n let mut sign = [1,1,-1,-1].iter().cycle();\n while p <= n {\n sum += known_partitions[(n-p) as usize]*sign.next().unwrap();\n p = gen_pentagonal(ctr.next().unwrap());\n }\n known_partitions[n as usize] = sum\n }\n\n // We need to subtract 1 because the partitions we calculated include the number itself as a partition\n (known_partitions[100]-1) as u64\n}\n\n\npub fn euler76_example() {\n println!(\"\\nProblem: How many different ways can one hundred be written as a sum of at least two positive integers?\");\n println!(\"\\n\\nThis could possibly be done using brute force to calculate partitions of each integer and then memoizing the results. However Euler's Pentagonal Number Theorem gives us a much more efficient option where we don't need to brute force calculate any partitions except for 0 and 1, which both have a single partition.\");\n let s = \"\nstruct AllIntegers {\n ctr: i64,\n parity: u8,\n} \n\nimpl Iterator for AllIntegers {\n type Item = i64;\n\n fn next(&mut self) -> Option {\n if self.parity == 0 {\n self.parity = 1;\n return Some(self.ctr)\n } else {\n self.parity = 0;\n self.ctr += 1;\n return Some(-(self.ctr-1))\n }\n }\n}\n\nfn gen_pentagonal(n: i64) -> i64 {\n (3*n*n-n)/2\n}\n\npub fn euler76() -> u64 {\n let mut known_partitions = [0i64;101];\n known_partitions[0] = 1;\n known_partitions[1] = 1;\n\n for n in 2..=100 {\n let mut ctr = AllIntegers{ctr: 1, parity: 0};\n let mut p = gen_pentagonal(ctr.next().unwrap());\n let mut sum = 0;\n let mut sign = [1,1,-1,-1].iter().cycle();\n while p <= n {\n sum += known_partitions[(n-p) as usize]*sign.next().unwrap();\n p = gen_pentagonal(ctr.next().unwrap());\n }\n known_partitions[n as usize] = sum\n }\n\n // We need to subtract 1 because the partitions we calculated include the number itself as a partition\n (known_partitions[100]-1) as u64\n}\";\n println!(\"\\n{}\\n\",s);\n println!(\"The answer is: {}\",euler76());\n}\n\n\n#[test]\nfn test76() {\n assert_eq!(euler76(),190569291)\n}"},"download_success":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":2983,"cells":{"blob_id":{"kind":"string","value":"6d6eb9ccc92b1b7c0c047bbda5e8f96466302ad9"},"language":{"kind":"string","value":"Rust"},"repo_name":{"kind":"string","value":"mandx/harplay"},"path":{"kind":"string","value":"/src/har/mod.rs"},"src_encoding":{"kind":"string","value":"UTF-8"},"length_bytes":{"kind":"number","value":1559,"string":"1,559"},"score":{"kind":"number","value":2.9375,"string":"2.9375"},"int_score":{"kind":"number","value":3,"string":"3"},"detected_licenses":{"kind":"list like","value":["MIT"],"string":"[\n \"MIT\"\n]"},"license_type":{"kind":"string","value":"permissive"},"text":{"kind":"string","value":"pub mod errors;\npub mod generic;\n\nuse std::fs::File;\nuse std::io::{BufReader, Read};\nuse std::path::Path;\n\nuse serde::{Deserialize, Serialize};\n\npub use errors::HarError;\nuse errors::*;\npub use generic::*;\n\n#[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]\npub struct Har {\n pub log: Log,\n}\n\n/// Deserialize a HAR from a path\n#[cfg_attr(tarpaulin, skip)]\npub fn from_path>(path: P) -> Result {\n from_reader(BufReader::new(File::open(path).context(Opening)?))\n}\n\n/// Deserialize a HAR from type which implements Read\npub fn from_reader(read: R) -> Result {\n Ok(serde_json::from_reader::(read).context(Reading)?)\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n use assert_matches::assert_matches;\n\n #[test]\n fn load_from_not_json_or_har() {\n let json = br#\"{\"some\": \"json\"}\"#;\n assert_matches!(from_reader(&json[..]), Err(_));\n let json = br#\"{\"log\": {}}\"#;\n assert_matches!(from_reader(&json[..]), Err(_));\n let json = br#\"{\"log\":{\"version\":\"1.2\",\"pages\":[],\"entries\":[]}}\"#;\n assert_matches!(from_reader(&json[..]), Err(_));\n }\n\n #[test]\n fn load_from_har() {\n let json =\n br#\"{\"log\":{\"creator\":{\"name\":\"Creator?\",\"version\":\"0.1\"},\"pages\":[],\"entries\":[]}}\"#;\n assert_matches!(from_reader(&json[..]), Ok(_));\n let json = br#\"{\"log\":{\"version\":\"1.2\",\"creator\":{\"name\":\"Creator?\",\"version\":\"0.1\"},\"pages\":[],\"entries\":[]}}\"#;\n assert_matches!(from_reader(&json[..]), Ok(_));\n }\n}\n"},"download_success":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":2984,"cells":{"blob_id":{"kind":"string","value":"4f1f7675a2b1b60a4e4a2ee34b4bc0918db7bf77"},"language":{"kind":"string","value":"Rust"},"repo_name":{"kind":"string","value":"arielb1/rustc-perf-collector"},"path":{"kind":"string","value":"/src/execute.rs"},"src_encoding":{"kind":"string","value":"UTF-8"},"length_bytes":{"kind":"number","value":3855,"string":"3,855"},"score":{"kind":"number","value":2.609375,"string":"2.609375"},"int_score":{"kind":"number","value":3,"string":"3"},"detected_licenses":{"kind":"list like","value":["MIT"],"string":"[\n \"MIT\"\n]"},"license_type":{"kind":"string","value":"permissive"},"text":{"kind":"string","value":"//! Execute benchmarks in a sysroot.\n\nuse std::str;\nuse std::path::{Path, PathBuf};\nuse std::process::Command;\n\nuse tempdir::TempDir;\n\nuse rustc_perf_collector::{Patch, Run};\n\nuse errors::{Result, ResultExt};\nuse rust_sysroot::sysroot::Sysroot;\nuse time_passes::{PassAverager, process_output};\n\npub struct Benchmark {\n pub name: String,\n pub path: PathBuf\n}\n\nimpl Benchmark {\n pub fn command>(&self, sysroot: &Sysroot, path: P) -> Command {\n let mut command = sysroot.command(path);\n command.current_dir(&self.path);\n command\n }\n\n /// Run a specific benchmark on a specific commit\n pub fn run(&self, sysroot: &Sysroot) -> Result> {\n info!(\"processing {}\", self.name);\n\n let mut patch_runs: Vec = Vec::new();\n for _ in 0..3 {\n let tmp_dir = TempDir::new(&format!(\"rustc-benchmark-{}\", self.name))?;\n info!(\"temporary directory is {}\", tmp_dir.path().display());\n\n info!(\"copying files to temporary directory\");\n let output = self.command(sysroot, \"cp\").arg(\"-r\").arg(\"-T\").arg(\"--\")\n .arg(\".\").arg(tmp_dir.path()).output()?;\n\n if !output.status.success() {\n bail!(\"copy failed: {}\", String::from_utf8_lossy(&output.stderr));\n }\n let make = || {\n let mut command = sysroot.command(\"make\");\n command.current_dir(tmp_dir.path());\n command\n };\n\n let output = make().arg(\"patches\").output()?;\n let mut patches = str::from_utf8(&output.stdout)\n .chain_err(|| format!(\"make patches in {} returned non UTF-8 output\", self.path.display()))?\n .split_whitespace()\n .collect::>();\n if patches.is_empty() {\n patches.push(\"\");\n }\n\n for patch in &patches {\n info!(\"running `make all{}`\", patch);\n let output = make().arg(&format!(\"all{}\", patch))\n .env(\"CARGO_OPTS\", \"\")\n .env(\"CARGO_RUSTC_OPTS\", \"-Z time-passes\")\n .output()?;\n\n if !output.status.success() {\n bail!(\"stderr non empty: {},\\n\\n stdout={}\",\n String::from_utf8_lossy(&output.stderr),\n String::from_utf8_lossy(&output.stdout)\n );\n }\n\n let patch_index = if let Some(p) = patch_runs.iter().position(|p_run| p_run.patch == *patch) {\n p\n } else {\n patch_runs.push(Patch {\n patch: patch.to_string(),\n name: self.name.clone(),\n runs: Vec::new(),\n });\n patch_runs.len() - 1\n };\n\n let combined_name = format!(\"{}{}\", self.name, patch);\n patch_runs[patch_index].runs.push(Run {\n passes: process_output(&combined_name, output.stdout)?,\n name: combined_name,\n });\n }\n }\n\n let mut patches = Vec::new();\n for patch_run in patch_runs {\n let mut runs = patch_run.runs.into_iter();\n let mut pa = PassAverager::new(runs.next().unwrap().passes);\n for run in runs {\n pa.average_with(run.passes)?;\n }\n patches.push(Patch {\n name: patch_run.name.clone(),\n patch: patch_run.patch.clone(),\n runs: vec![\n Run {\n name: patch_run.name + &patch_run.patch,\n passes: pa.state,\n }\n ],\n });\n }\n\n Ok(patches)\n }\n}\n"},"download_success":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":2985,"cells":{"blob_id":{"kind":"string","value":"9dbba9ca63b7899339ef99ae88d923535b42df89"},"language":{"kind":"string","value":"Rust"},"repo_name":{"kind":"string","value":"matthew86707/PDESimulator"},"path":{"kind":"string","value":"/PDESimulator/src/simulation.rs"},"src_encoding":{"kind":"string","value":"UTF-8"},"length_bytes":{"kind":"number","value":3612,"string":"3,612"},"score":{"kind":"number","value":2.890625,"string":"2.890625"},"int_score":{"kind":"number","value":3,"string":"3"},"detected_licenses":{"kind":"list like","value":[],"string":"[]"},"license_type":{"kind":"string","value":"no_license"},"text":{"kind":"string","value":"use std::sync::{Arc, Mutex};\nuse std::time::{Duration, Instant};\nuse std::{thread, time};\n\npub fn simulation_loop(display_values_mutex : Arc>, GRID_SIZE_X : usize, GRID_SIZE_Y : usize){\n let TIME_SAMPLES_PER_PRINTOUT : u32 = 100;\n let mut time_samples : u32 = 0;\n let mut time_acc : u32 = 0;\n let mut tick_number : u32 = 0;\n\n loop {\n let start = Instant::now();\n\n {\n let mut old_values = display_values_mutex.lock().unwrap();\n let new_values = heat_simulation_loop(block_array(*old_values), tick_number);\n tick_number += 1;\n *old_values = serialize_array(new_values);\n }\n\n time_acc += Instant::now().duration_since(start).subsec_millis();\n if (time_samples == TIME_SAMPLES_PER_PRINTOUT){\n println!(\"Delay : {}ms\", time_acc as f32 / TIME_SAMPLES_PER_PRINTOUT as f32);\n time_samples = 0;\n time_acc = 0;\n }\n time_samples += 1;\n \n let ten_millis = time::Duration::from_millis(5);\n thread::sleep(ten_millis);\n\n }\n }\n\n\nfn heat_simulation_loop(data : [[f32; 100];150], tick_number : u32) -> [[f32; 100];150] {\n let mut next_data : [[f32; 100];150] = data;\n //Actual simulation code\n {\n /*\n Heat equation : du/dt - (du/dx)^2, where u = temperature, t = time, and x = our spacial domain\n which, solved for du/dt : du/dt = (du/dx)^2\n expanding spacial domain and therefor it's derivitive into two dimensions : du/dt = (du/dx)^2 + (du/dy)^2\n\n From this PDE we can use the central difference method to approximate the 2nd spacial derivitives...\n \n From the difference quotient of the first derivitive...\n f(x - h) - f(x + h) / 2h\n We then derive the difference quotient of the 2nd derivitive...\n f(x - h) - 2 * f(x) + f(x + h) / h^2\n In code, this recurrence equation implies...\n next_data[i][j] += ((data[i + 1][j] - (2.0 * data[i][j]) + data[i - 1][j]) + (data[i][j + 1] - (2.0 * data[i][j]) + data[i][j - 1])) / h ^ 2; \n Which is seen implemented below.\n\n A note on boundry conditions : \n First derivitive boundry conditions set du/dx on all walls to be 0.5\n\n */\n for i in 0..150 - 1{\n for j in 0..100 - 1{\n if i == 0 || i == 150 || j == 0 || j == 100{\n //next_data[i][j] = 0.5;\n }else{\n next_data[i][j] += ((data[i + 1][j] - (2.0 * data[i][j]) + data[i - 1][j]) + (data[i][j + 1] - (2.0 * data[i][j]) + data[i][j - 1])) / 4.00; \n }\n }\n }\n if(tick_number < 200){\n next_data[75][20] = 1.0;\n next_data[75][40] = 1.0;\n next_data[75][60] = 1.0;\n next_data[75][80] = 1.0;\n\n next_data[95][20] = 1.0;\n next_data[95][40] = 1.0;\n next_data[95][60] = 1.0;\n next_data[95][80] = 1.0;\n }\n }\n return next_data;\n}\n\n\nfn serialize_array(array : [[f32; 100];150]) -> [f32; 15000]{\n let mut to_return : [f32; 15000] = [0.0; 15000];\n for i in 0..to_return.len() {\n to_return[i] = array[i % 150][i / 150];\n }\n return to_return;\n}\n\nfn block_array(array : [f32; 15000]) -> [[f32; 100];150]{\n let mut to_return : [[f32; 100];150] = [[0.0; 100]; 150];\n for i in 0..150{\n for j in 0..100{\n to_return[i][j] = array[j * 150 + i];\n }\n }\n return to_return;\n}"},"download_success":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":2986,"cells":{"blob_id":{"kind":"string","value":"1f4d83c360620fae73a2f35780e132c22c51605e"},"language":{"kind":"string","value":"Rust"},"repo_name":{"kind":"string","value":"kroeckx/ruma"},"path":{"kind":"string","value":"/crates/ruma-events/src/room/redaction.rs"},"src_encoding":{"kind":"string","value":"UTF-8"},"length_bytes":{"kind":"number","value":2461,"string":"2,461"},"score":{"kind":"number","value":2.796875,"string":"2.796875"},"int_score":{"kind":"number","value":3,"string":"3"},"detected_licenses":{"kind":"list like","value":["MIT"],"string":"[\n \"MIT\"\n]"},"license_type":{"kind":"string","value":"permissive"},"text":{"kind":"string","value":"//! Types for the *m.room.redaction* event.\n\nuse ruma_common::MilliSecondsSinceUnixEpoch;\nuse ruma_events_macros::{Event, EventContent};\nuse ruma_identifiers::{EventId, RoomId, UserId};\nuse serde::{Deserialize, Serialize};\n\nuse crate::Unsigned;\n\n/// Redaction event.\n#[derive(Clone, Debug, Event)]\n#[allow(clippy::exhaustive_structs)]\npub struct RedactionEvent {\n /// Data specific to the event type.\n pub content: RedactionEventContent,\n\n /// The ID of the event that was redacted.\n pub redacts: EventId,\n\n /// The globally unique event identifier for the user who sent the event.\n pub event_id: EventId,\n\n /// The fully-qualified ID of the user who sent this event.\n pub sender: UserId,\n\n /// Timestamp in milliseconds on originating homeserver when this event was sent.\n pub origin_server_ts: MilliSecondsSinceUnixEpoch,\n\n /// The ID of the room associated with this event.\n pub room_id: RoomId,\n\n /// Additional key-value pairs not signed by the homeserver.\n pub unsigned: Unsigned,\n}\n\n/// Redaction event without a `room_id`.\n#[derive(Clone, Debug, Event)]\n#[allow(clippy::exhaustive_structs)]\npub struct SyncRedactionEvent {\n /// Data specific to the event type.\n pub content: RedactionEventContent,\n\n /// The ID of the event that was redacted.\n pub redacts: EventId,\n\n /// The globally unique event identifier for the user who sent the event.\n pub event_id: EventId,\n\n /// The fully-qualified ID of the user who sent this event.\n pub sender: UserId,\n\n /// Timestamp in milliseconds on originating homeserver when this event was sent.\n pub origin_server_ts: MilliSecondsSinceUnixEpoch,\n\n /// Additional key-value pairs not signed by the homeserver.\n pub unsigned: Unsigned,\n}\n\n/// A redaction of an event.\n#[derive(Clone, Debug, Default, Deserialize, Serialize, EventContent)]\n#[cfg_attr(not(feature = \"unstable-exhaustive-types\"), non_exhaustive)]\n#[ruma_event(type = \"m.room.redaction\", kind = Message)]\npub struct RedactionEventContent {\n /// The reason for the redaction, if any.\n #[serde(skip_serializing_if = \"Option::is_none\")]\n pub reason: Option,\n}\n\nimpl RedactionEventContent {\n /// Creates an empty `RedactionEventContent`.\n pub fn new() -> Self {\n Self::default()\n }\n\n /// Creates a new `RedactionEventContent` with the given reason.\n pub fn with_reason(reason: String) -> Self {\n Self { reason: Some(reason) }\n }\n}\n"},"download_success":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":2987,"cells":{"blob_id":{"kind":"string","value":"072a8fb46341d51bd070b776ebd1071a560ab6dc"},"language":{"kind":"string","value":"Rust"},"repo_name":{"kind":"string","value":"KrutNA/huffman-coding"},"path":{"kind":"string","value":"/src/queue.rs"},"src_encoding":{"kind":"string","value":"UTF-8"},"length_bytes":{"kind":"number","value":462,"string":"462"},"score":{"kind":"number","value":2.640625,"string":"2.640625"},"int_score":{"kind":"number","value":3,"string":"3"},"detected_licenses":{"kind":"list like","value":[],"string":"[]"},"license_type":{"kind":"string","value":"no_license"},"text":{"kind":"string","value":"use crate::types::node::*;\n\nuse std::collections::BinaryHeap;\n\npub fn update_with_data(heap_buffer: &mut [u32], data: &[u8]) {\n for &byte in data.iter() {\n\theap_buffer[byte as usize] += 1;\n }\n}\n\npub fn convert_to_heap(\n heap_buffer: &mut [u32]\n)\n -> BinaryHeap