This file is indexed.

/usr/include/dlib/threads/rmutex_extension.h is in libdlib-dev 18.18-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  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
// Copyright (C) 2005  Davis E. King (davis@dlib.net)
// License: Boost Software License   See LICENSE.txt for the full license.
#ifndef DLIB_RMUTEX_EXTENSIOn_
#define DLIB_RMUTEX_EXTENSIOn_

#include "threads_kernel.h"
#include "rmutex_extension_abstract.h"

namespace dlib
{

// ----------------------------------------------------------------------------------------

    class rmutex
    {
        /*!
            INITIAL VALUE
                count == 0
                thread_id == 0

            CONVENTION
                - count == lock_count()

                - if (no thread currently has a lock on this mutex) then
                    - count == 0
                - else
                    - count == the number of times the thread that owns this mutex has
                      called lock()
                    - thread_id == the id of this thread.
        !*/
    public:

        rmutex (
        ) : s(m),
            thread_id(0),
            count(0)
        {}

        ~rmutex (
        )
        {}

        unsigned long lock_count (
        ) const
        {
            return count;
        }

        void lock (
            unsigned long times = 1
        ) const
        {
            const thread_id_type current_thread_id = get_thread_id();
            m.lock();
            if (thread_id == current_thread_id)
            {
                // we already own this mutex in this case
                count += times;                
            }
            else
            {
                // wait for our turn to claim this rmutex
                while (count != 0)
                    s.wait();

                count = times;
                thread_id = current_thread_id;
            }
            m.unlock();
        }

        void unlock (
            unsigned long times = 1
        ) const
        {
            const thread_id_type current_thread_id = get_thread_id();
            m.lock();
            if (thread_id == current_thread_id)
            {
                if (count <= times)
                {
                    count = 0;
                    s.signal();
                }
                else
                {
                    count -= times;
                }
            }
            m.unlock();
        }

    private:
        mutex m;
        signaler s;
        mutable thread_id_type thread_id;
        mutable unsigned long count;

        // restricted functions
        rmutex(rmutex&);        // copy constructor
        rmutex& operator=(rmutex&);    // assignment operator
    };

// ----------------------------------------------------------------------------------------

}

#endif // DLIB_RMUTEX_EXTENSIOn_