Generating unique IDs for types at compile time

Question

I want to generate a unique id for every type at compile time. Is this possible in Rust?

So far, I have the following code

//Pseudo code
struct ClassTypeId{
    id: &'static uint
}
impl ClassTypeId{
    fn get_type<T>(&mut self) -> &'static uint {
        let _id :&'static uint = self.id + 1;
        self.id = _id;
        _id
    }
}

let c = ClassTypeId{id:0};
c.get_type::<i32>();  // returns 1
c.get_type::<f32>();  // returns 2
c.get_type::<i32>();  // returns 1
c.get_type::<uint>(); // returns 3

I stole this idea from a C++ library, which looks like this

typedef std::size_t TypeId;

        template <typename TBase>
        class ClassTypeId
        {
        public:

            template <typename T>
            static TypeId GetTypeId()
            {
                static const TypeId id = m_nextTypeId++;
                return id;
            }

        private:

            static TypeId m_nextTypeId;
        };

        template <typename TBase>
        TypeId ClassTypeId<TBase>::m_nextTypeId = 0;
    }

What about simply using [`typeid()`](http://en.cppreference.com/w/cpp/language/typeid)? — πάντα ῥεῖ, Aug 18 '14 at 21:44
@ChrisMorgan Short answer: Entity Component System. I want to create a bitmask for every component, so that I can easily filter components at runtime.`for(entity: world.filter(Position,Velocity)){}` — Maik Klein, Aug 18 '14 at 23:04

score 15 · Accepted Answer · edited Dec 08 '15 at 15:38

15

std::any::TypeId does something like that:

use std::any::TypeId;

fn main() {
    let type_id = TypeId::of::<isize>();
    println!("{:?}", type_id);
}

outputs:

TypeId { t: 4150853580804116396 }

edited Dec 08 '15 at 15:38

Shepmaster

388,571
95
1,107
1,366

answered Aug 18 '14 at 22:10

Paige Ruten

172,675
36
177
197

score 8 · Answer 2 · edited Mar 25 '15 at 16:05

8

This sounds like a job for the bitflags! macro:

#[macro_use] extern crate rustc_bitflags;

bitflags!(
    #[derive(Debug)]
    flags ComponentMask: u8 {
        const Render     = 0b00000001,
        const Position   = 0b00000010,
        const Physics    = 0b00000100
    }
);

// the set of components owned by an entity:
let owned_components:  = Render | Position;

// check whether an entity has a certain component:
if owned_components.contains(Physics) { ... }

http://doc.rust-lang.org/rustc_bitflags/macro.bitflags!.html

edited Mar 25 '15 at 16:05

ArtemGr

11,684
3
52
85

answered Aug 19 '14 at 06:33

A.B.

15,364
3
61
64

Yes that's exactly what I want to do, just that I want to achieve this automatically at compile time. – Maik Klein Aug 19 '14 at 11:03
Maybe I can create this with a macro `add_flag!(Position)` – Maik Klein Aug 19 '14 at 11:10

score 0 · Answer 3 · edited Jan 17 '20 at 14:21

If you want to manage type ids manually, you can use my unique-type-id crate. It allows you to specify what ids a type has in a special file. It will generate them at compile time. Currently it can be used in this way:

use unique_type_id::UniqueTypeId;
#[derive(UniqueTypeId)]
struct Test1;
#[derive(UniqueTypeId)]
struct Test2;

assert_eq!(Test1::id().0, 1u64);
assert_eq!(Test2::id().0, 2u64);

It can both generate types using incremental number and use the id from a file.

Generating unique IDs for types at compile time

3 Answers3

Linked

Related