aboutsummaryrefslogtreecommitdiff
path: root/include/lldb/Core/UserID.h
blob: ea6af74759bf8f042136dbbb65dd3304b354b286 (plain) (blame)
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
//===-- UserID.h ------------------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//


#ifndef liblldb_UserID_h_
#define liblldb_UserID_h_

#include "lldb/lldb-private.h"

namespace lldb_private {

//----------------------------------------------------------------------
/// @class UserID UserID.h "lldb/Core/UserID.h"
/// @brief A mix in class that contains a generic user ID.
///
/// UserID is desinged as a mix in class that can contain an integer
/// based unique identifier for a varietly of objects in lldb.
///
/// The value for this identifier is chosen by each parser plug-in. A
/// value should be chosen that makes sense for each kind of object
/// should and allows quick access to further and more in depth parsing.
///
/// Symbol table entries can use this to store the original symbol table
/// index, functions can use it to store the symbol table index or the
/// DWARF offset.
//----------------------------------------------------------------------
struct UserID
{
    //------------------------------------------------------------------
    /// Construct with optional user ID.
    //------------------------------------------------------------------
    UserID (lldb::user_id_t uid = LLDB_INVALID_UID) : m_uid(uid) {}

    //------------------------------------------------------------------
    /// Destructor.
    //------------------------------------------------------------------
    ~UserID ()
    {
    }

    //------------------------------------------------------------------
    /// Clears the object state.
    ///
    /// Clears the object contents back to a default invalid state.
    //------------------------------------------------------------------
    void
    Clear () { m_uid = LLDB_INVALID_UID; }

    //------------------------------------------------------------------
    /// Get accessor for the user ID.
    ///
    /// @return
    ///     The user ID.
    //------------------------------------------------------------------
    lldb::user_id_t
    GetID () const { return m_uid; }

    //------------------------------------------------------------------
    /// Set accessor for the user ID.
    ///
    /// @param[in] uid
    ///     The new user ID.
    //------------------------------------------------------------------
    void
    SetID (lldb::user_id_t uid) { m_uid = uid; }

    //------------------------------------------------------------------
    /// Unary predicate function object that can search for a matching
    /// user ID.
    ///
    /// Function object that can be used on any class that inherits
    /// from UserID:
    /// \code
    /// iterator pos;
    /// pos = std::find_if (coll.begin(), coll.end(), UserID::IDMatches(blockID));
    /// \endcode
    //------------------------------------------------------------------
    class IDMatches
    {
    public:
        //--------------------------------------------------------------
        /// Construct with the user ID to look for.
        //--------------------------------------------------------------
        IDMatches (lldb::user_id_t uid) : m_uid(uid) {}

        //--------------------------------------------------------------
        /// Unary predicate function object callback.
        //--------------------------------------------------------------
        bool
        operator () (const UserID& rhs) const { return m_uid == rhs.GetID(); }

    private:
        //--------------------------------------------------------------
        // Member variables.
        //--------------------------------------------------------------
        const lldb::user_id_t m_uid; ///< The user ID we are looking for
    };


protected:
    //------------------------------------------------------------------
    // Member variables.
    //------------------------------------------------------------------
    lldb::user_id_t m_uid; ///< The user ID that uniquely identifies an object.
};

inline bool operator== (const UserID& lhs, const UserID& rhs)
{
  return lhs.GetID() == rhs.GetID();
}

inline bool operator!= (const UserID& lhs, const UserID& rhs)
{
  return lhs.GetID() != rhs.GetID();
}

//--------------------------------------------------------------
/// Stream the UserID object to a Stream.
//--------------------------------------------------------------
Stream& operator << (Stream& strm, const UserID& uid);

} // namespace lldb_private

#endif  // liblldb_UserID_h_