use std::marker::PhantomData;
struct Engine<'a, C, B>
where C: Canvas<'a>,
B: Backend<'a, C>
{
backend: B,
a_lifetime_marker: PhantomData<&'a mut ()>,
c_marker: PhantomData<C>,
}
impl<'a, C, B> Engine<'a, C, B>
where C: Canvas<'a>,
B: Backend<'a, C>
{
fn new(backend: B) -> Self {
Engine {
backend: backend,
a_lifetime_marker: PhantomData::default(),
c_marker: PhantomData::default(),
}
}
fn run<'b, A>(&'b mut self, app: &mut A)
where A: Application<'b, C, B>
{
loop {
{
let context = UpdateContext {
engine: self,
};
app.update(context);
}
{
let canvas = self.backend.canvas();
}
}
}
}
trait Backend<'a, C>
where C: Canvas<'a>
{
fn canvas(&'a mut self) -> C;
}
struct SimpleBackend<'a> {
a_marker: PhantomData<&'a mut ()>,
}
impl<'a> SimpleBackend<'a> {
fn new() -> Self {
SimpleBackend {
a_marker: PhantomData::default(),
}
}
}
impl<'a> Backend<'a, SimpleCanvas<'a>> for SimpleBackend<'a> {
fn canvas(&'a mut self) -> SimpleCanvas<'a> {
SimpleCanvas {
backend: self,
}
}
}
trait Canvas<'a>: 'a {
}
struct SimpleCanvas<'a> {
backend: &'a mut SimpleBackend<'a>
}
impl<'a> Canvas<'a> for SimpleCanvas<'a> {
}
trait StartableApplication<'a, C, B>
where C: Canvas<'a>,
B: Backend<'a, C>
{
type Application: Application<'a, C, B>;
fn start(self, engine: &mut Engine<'a, C, B>) -> Self::Application;
}
struct SimpleStartableApplication;
impl<'a, C, B> StartableApplication<'a, C, B> for SimpleStartableApplication
where C: Canvas<'a>,
B: Backend<'a, C>
{
type Application = SimpleApplication;
fn start(self, engine: &mut Engine<'a, C, B>) -> Self::Application {
SimpleApplication
}
}
trait Application<'a, C, B>
where C: Canvas<'a>,
B: Backend<'a, C>
{
fn render(&mut self, canvas: &mut C);
fn update<'b>(&mut self, context: UpdateContext<'b, 'a, C, B>);
}
struct UpdateContext<'a, 'b, C, B>
where 'b: 'a,
C: Canvas<'b>,
B: Backend<'b, C> + 'a
{
engine: &'a mut Engine<'b, C, B>,
}
struct SimpleApplication;
impl<'a, C, B> Application<'a, C, B> for SimpleApplication
where C: Canvas<'a>,
B: Backend<'a, C>
{
fn render(&mut self, canvas: &mut C) {
}
fn update<'b>(&mut self, context: UpdateContext<'b, 'a, C, B>) {
}
}
fn main() {
let backend = SimpleBackend::new();
let mut engine = Engine::new(backend);
let app = SimpleStartableApplication;
let mut app: SimpleApplication = app.start(&mut engine);
engine.run(&mut app);
println!("Hello, world!");
}
I am stuck please help me.