Handle-based resource manager

Bonjour à tous :)

En cherchant des articles sur la gestion de ressources (principalement orienté jeux vidéos) je suis tombé sur celui-ci

Generic handle-based resource manager

C'est un article qui a été publié dans le livre Game Programming Gems 1.

Cependant il y a une partie du code que je ne comprend pas, précisemment la class Handle dont voici le code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
    template <typename TAG>
    class Handle
    {
        union
        {
            enum
            {
                // Sizes to use for bit fields
                MAX_BITS_INDEX = 16,
                MAX_BITS_MAGIC = 16,
 
                // Sizes to compare against for asserting dereferences
                MAX_INDEX = ( 1 << MAX_BITS_INDEX) - 1,
                MAX_MAGIC = ( 1 << MAX_BITS_MAGIC) - 1
            };
 
            struct
            {
                unsigned m_Index : MAX_BITS_INDEX;  // Index into resource array
                unsigned m_Magic : MAX_BITS_MAGIC;  // Magic number to check
            };
 
            unsigned int m_uiHandle;
        };
 
    public:
 
        // Lifetime.
 
        Handle():
            m_uiHandle( 0 )
        {}
 
        void Init(unsigned int _Index);
 
        // Query.
 
        unsigned int GetIndex ( void ) const  {  return (  m_Index  );  }
        unsigned int GetMagic ( void ) const  {  return (  m_Magic  );  }
        unsigned int GetHandle( void ) const  {  return (  m_uiHandle );  }
        bool         IsNull   ( void ) const  {  return ( !m_uiHandle );  }
 
        operator unsigned int ( void ) const  {  return (  m_uiHandle );  }
    };
 
    //-------------------------------------------------------------------
    template <typename TAG>
    void Handle<TAG>::Init(unsigned int _Index)
    {
        assert( IsNull() );             // don't allow reassignment
        assert( _Index <= MAX_INDEX );   // verify range
 
        static unsigned int s_uiAutoMagic = 0;
        if ( ++s_uiAutoMagic > MAX_MAGIC )
        {
            qDebug() << "restart";
            s_uiAutoMagic = 1;    // 0 is used for "null handle"
        }
 
        //qDebug() << MAX_MAGIC;
 
        m_Index = _Index;
        m_Magic = s_uiAutoMagic;
    }
 
    //-------------------------------------------------------------------
    template <typename TAG>
    inline bool operator != ( Handle <TAG> l, Handle <TAG> r )
    {
        return ( l.GetHandle() != r.GetHandle() );
    }
 
    //-------------------------------------------------------------------
    template <typename TAG>
    inline bool operator == ( Handle <TAG> l, Handle <TAG> r )
    {
        return ( l.GetHandle() == r.GetHandle() );
    }

Tout d'abord comment doit-on interpréter cette ligne de code

Code:

1
2
 
unsigned m_Index : MAX_BITS_INDEX;

Deuxièmement comment la propriété m_uiHandle peut elle avoir une valeur différentes à chaque instantiation d'un objet Handle alors que celle-ci n'est jamais écrite ?

Kromagg