Wie importiere ich von einem Geschwistermodul?

Question

In src/lib.rs ich habe folgendes

extern crate opal_core; 

mod functions; 
mod context; 
mod shader; 

Dann in src/context.rs Ich habe so etwas wie dieses, die Symbole von src/shader.rs zu importieren versucht:

use opal_core::shader::Stage; 
use opal_core::shader::Shader as ShaderTrait; 
use opal_core::GraphicsContext as GraphicsContextTrait; 

use functions::*; // this import works fine 
use shader::*; // this one doesn't 

pub struct GraphicsContext { 
    functions: Gl 
} 

fn shader_stage_to_int(stage: &Stage) -> u32 { 
    match stage { 
     &Stage::Vertex => VERTEX_SHADER, 
     &Stage::Geometry => GEOMETRY_SHADER, 
     &Stage::Fragment => FRAGMENT_SHADER, 
    } 
} 

impl GraphicsContextTrait for GraphicsContext { 

    /// Creates a shader object 
    fn create_shader(&self, stage: Stage, source: &str) -> Box<ShaderTrait> { 
     let id; 

     unsafe { 
      id = self.functions.CreateShader(shader_stage_to_int(&stage)); 
     } 

     let shader = Shader { 
      id: id, 
      stage: stage, 
      context: self 
     }; 

     Box::new(shader) 
    } 
} 

Das Problem, dass die Aussage use shader::*; den Fehler verursacht wird ungelöster Import.

ich die Dokumentation lese und sie sagten, dass use Aussagen von der Wurzel der aktuellen Kiste gehen immer (opal_driver_gl), so dachte ich shader::*opal_driver_gl::shader::* importieren werden soll, aber es scheint nicht so zu tun. Muss ich hier die Schlüsselwörter self oder super verwenden?

Danke, wenn Sie helfen können.

Answer 1

Um ein Modul auf der gleichen Ebene zu importieren, gehen Sie wie folgt vor:

random_file_0.rs:

// Note how this is a public function. It has to be in order to be 
// usable from other files (in this case `random_file_1.rs`) 
pub fn do_something() -> bool { 
    true 
} 

random_file_1.rs:

use super::random_file_0; 

#[test] 
fn do_something_else() { 
    assert!(random_file_0::do_something()); 
} 

oder alternative random_file_1.rs:

// This can be a public function, but does not have to be unless you 
// are using it somewhere else 
use ::random_file_0; 

#[test] 
fn do_something_else() { 
    assert!(random_file_0::do_something()); 
} 

lib.rs:

mod random_file_0; 
mod random_file_1; 

Siehe diesen Link: Rust By Example für weitere Informationen und Beispiele. Wenn das nicht, hier funktioniert der Code es zeigt:

fn function() { 
    println!("called `function()`"); 
} 

mod my { 
    pub fn indirect_call() { 
     // Let's access all the functions named `function` from this scope 
     print!("called `my::indirect_call()`, that\n> "); 

     // `my::function` can be called directly 
     function(); 

     { 
      // This will bind to the `cool::function` in the *crate* scope 
      // In this case the crate scope is the outermost scope 
      use cool::function as root_cool_function; 

      print!("> "); 
      root_cool_function(); 
     } 

     { 
      // `self` refers to the current module scope, in this case: `my` 
      use self::cool::function as my_cool_function; 

      print!("> "); 
      my_cool_function(); 
     } 

     { 
      // `super` refers to the parent scope, i.e. outside of the `my` 
      // module 
      use super::function as root_function; 

      print!("> "); 
      root_function(); 
     } 
    } 

    fn function() { 
     println!("called `my::function()`"); 
    } 

    mod cool { 
     pub fn function() { 
      println!("called `my::cool::function()`"); 
     } 
    } 
} 

mod cool { 
    pub fn function() { 
     println!("called `cool::function()`"); 
    } 
} 

fn main() { 
    my::indirect_call(); 
}