1
Rust Programming
8386 readers
1 users here now
founded 5 years ago
MODERATORS
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
I was recently furloughed from work, so in between job applications, I decided to polish off Sonarr support in my Managarr TUI. Thus, I'm very proud to announce the beta release of Managarr with Sonarr support!
TL;DR: Managarr is a TUI and CLI for managing your Servarr instances. As of now, it now supports both Radarr and Sonarr and all the features that are available in the UI are also available in the CLI for scripting and additional automation.
The new version has the following features:
- Wider platform support (Windows, Mac, Linux, x86_64 and arm64)
- View your library, downloads, blocklist, episodes
- View details of a specific series, or episode including description, history, downloaded file info, or the credits
- View your host and security configs from the CLI to programmatically fetch the API token, among other settings
- Search your library
- Add series to your library
- Delete series, downloads, indexers, root folders, and episode files
- Trigger automatic searches for series, seasons, or episodes
- Trigger refresh and disk scan for series and downloads
- Manually search for series, seasons, or episodes
- Edit your series and indexers
- Manage your tags
- Manage your root folders
- Manage your blocklist
- View and browse logs, tasks, events queues, and updates
- Manually trigger scheduled tasks
- Manually trigger scheduled tasks
- And more!
Here's some screenshots of the Sonarr tab:
Thanks to everyone's feedback when I first posted the alpha release here, this version sports a handful of additional performance improvements and platform support.
This is now technically in beta, so if anyone encounters any issues, please let me know!
20
21
22
23
24
Hello,
I was playing around with rust and wondered if I could use const generics for toggling debug code on and off to avoid any runtime cost while still being able to toggle the DEBUG flag during runtime. I came up with a nifty solution that requires a single dynamic dispatch which many programs have anyways. It works by rewriting the vtable. It's a zero cost bool!
Is this technique worth it?
Probably not.
It's funny though.
Repo: https://github.com/raldone01/runtime_const_generics_rs/tree/v1.0.0
Full source code below:
use std::mem::transmute;
use std::sync::atomic::AtomicU32;
use std::sync::atomic::Ordering;
use replace_with::replace_with_or_abort;
trait GameObject {
fn run(&mut self);
fn set_debug(&mut self, flag: bool) -> &mut dyn GameObject;
}
trait GameObjectBoxExt {
fn set_debug(self: Box<Self>, flag: bool) -> Box<dyn GameObject>;
}
impl GameObjectBoxExt for dyn GameObject {
fn set_debug(self: Box<Self>, flag: bool) -> Box<dyn GameObject> {
unsafe {
let selv = Box::into_raw(self);
let selv = (&mut *selv).set_debug(flag);
return Box::from_raw(selv);
}
}
}
static ID_CNT: AtomicU32 = AtomicU32::new(0);
struct Node3D<const DEBUG: bool = false> {
id: u32,
cnt: u32,
}
impl Node3D {
const TYPE_NAME: &str = "Node3D";
fn new() -> Self {
let id = ID_CNT.fetch_add(1, Ordering::Relaxed);
let selv = Self { id, cnt: 0 };
return selv;
}
}
impl<const DEBUG: bool> GameObject for Node3D<DEBUG> {
fn run(&mut self) {
println!("Hello {} from {}@{}!", self.cnt, Node3D::TYPE_NAME, self.id);
if DEBUG {
println!("Debug {} from {}@{}!", self.cnt, Node3D::TYPE_NAME, self.id);
}
self.cnt += 1;
}
fn set_debug(&mut self, flag: bool) -> &mut dyn GameObject {
unsafe {
match flag {
true => transmute::<_, &mut Node3D<true>>(self) as &mut dyn GameObject,
false => transmute::<_, &mut Node3D<false>>(self) as &mut dyn GameObject,
}
}
}
}
struct Node2D<const DEBUG: bool = false> {
id: u32,
cnt: u32,
}
impl Node2D {
const TYPE_NAME: &str = "Node2D";
fn new() -> Self {
let id = ID_CNT.fetch_add(1, Ordering::Relaxed);
let selv = Self { id, cnt: 0 };
return selv;
}
}
impl<const DEBUG: bool> GameObject for Node2D<DEBUG> {
fn run(&mut self) {
println!("Hello {} from {}@{}!", self.cnt, Node2D::TYPE_NAME, self.id);
if DEBUG {
println!("Debug {} from {}@{}!", self.cnt, Node2D::TYPE_NAME, self.id);
}
self.cnt += 1;
}
fn set_debug(&mut self, flag: bool) -> &mut dyn GameObject {
unsafe {
match flag {
true => transmute::<_, &mut Node2D<true>>(self) as &mut dyn GameObject,
false => transmute::<_, &mut Node2D<false>>(self) as &mut dyn GameObject,
}
}
}
}
fn main() {
let mut objects = Vec::new();
for _ in 0..10 {
objects.push(Box::new(Node3D::new()) as Box<dyn GameObject>);
objects.push(Box::new(Node2D::new()) as Box<dyn GameObject>);
}
for o in 0..3 {
for (i, object) in objects.iter_mut().enumerate() {
let debug = (o + i) % 2 == 0;
replace_with_or_abort(object, |object| object.set_debug(debug));
object.run();
}
}
}
Note:
If anyone gets the following to work without unsafe, maybe by using the replace_with crate I would be very happy:
impl GameObjectBoxExt for dyn GameObject {
fn set_debug(self: Box<Self>, flag: bool) -> Box<dyn GameObject> {
unsafe {
let selv = Box::into_raw(self);
let selv = (&mut *selv).set_debug(flag);
return Box::from_raw(selv);
}
}
I am curious to hear your thoughts.
25
view more: next ›