列挙型の値を取得するマクロを作成するにはどうすればよいですか？

Question

私の列挙型は、次のようになります。

#[derive(Clone, Debug)] 
pub enum Type { 
    GLnull, 
    GLenum(GLenum), 
    GLboolean(GLboolean), 
    GLint(GLint), 
    GLbyte(GLbyte), 
    GLshort(GLshort), 
    GLclampx(GLclampx), 
    GLubyte(GLubyte), 
    GLushort(GLushort), 
    GLuint(GLuint), 
    GLsizei(GLsizei), 
    GLclampf(GLclampf), 
    GLdouble(GLdouble), 
    GLclampd(GLclampd), 
    GLfloat_4fv((GLfloat, GLfloat, GLfloat, GLfloat)), 
    GLfloat(GLfloat), 
    GLintptr(GLintptr), 
    GLsizeiptr(GLsizeiptr), 
    GLbitfield(GLbitfield), 
    GLchar_ptr(String), 
} 

macro_rules! get{ 
    ($e:expr) => { 
     match $e { 
      Type::GLsizei(x) => { x } 
      Type::GLbitfield(x) => { x } 
      _ => { 0 } 
     } 
    } 
} 

今どのように私は、列挙型の値を取得するマクロを作成するのですか？

Answer 1

@aochagaviaのように、enumで特定のものを実行する必要がある場合は、マクロを作成する必要はありません。

次のマクロが役に立ちます。その目的は、列挙型を作成して何らかのメソッドを生成するマクロを作成することです。これは、すべてのバリアントが1つのタイプを持つ場合にのみ機能します。

macro_rules! foo { 
    ($($(#[$meta:meta])* foo $name:ident($ty:ty),)*) => { 
     #[derive(Debug, Clone)] 
     pub enum Foo { 
      $($(#[$meta])* $name($ty),)* 
     } 
     impl Foo { 
      pub fn display(&self) { 
       match *self { 
        $(Foo::$name(x) => println!("{}", x),)* 
       } 
      } 
     } 
    } 
} 

foo! { 
    foo A(i32), 
    foo B(i64), 
} 

fn main() { 
    let a = Foo::A(32); 
    let b = Foo::B(64); 

    a.display(); 
    b.display(); 
} 

originalマクロは、私はあなたの場合の例と変形例としてそれを取る、@の高化EL-キウイからです。

Answer 2

次のメソッドを使用すると、これが働くことを期待する方法も

pub enum Type<T> { 
    gli32(T), 
    gli64(T), 
    glfloat4fv(T), 
    glString(T), 
    glVec(T), 
} 

impl<T> Type<T> { 
    pub fn unwarp(&self) -> &T { 
     match *self { 
      Type::gli32(ref x) => x, 
      Type::gli64(ref x) => x, 
      Type::glfloat4fv(ref x) => x, 
      Type::glString(ref x) => x, 
      Type::glVec(ref x) => x, 
     } 
    } 
} 

fn main() { 
    println!("Hello, world!"); 
    let f = Type::gli32(32 as i32); 
    let ff64 = Type::gli64((64, 32)); 
    let f4fv = Type::glfloat4fv((0.1, 0.2, 0.0)); 
    let cstr = Type::glString(CString::new("glstring").unwrap()); 
    let ve = [1, 2, 3, 5]; 
    let glve = Type::glVec(ve); 

    println!("f ={} {:?} {:?} {:?}", 
      f.unwarp(), 
      f4fv.unwarp(), 
      cstr.unwarp(), 
      glve.unwarp()); 
}