This file is indexed.

/usr/include/x86_64-linux-gnu/qcc/StringMapKey.h is in liballjoyn-common-dev-1504 15.04b-8.

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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
/**
 * @file
 */

/******************************************************************************
 * Copyright AllSeen Alliance. All rights reserved.
 *
 *    Permission to use, copy, modify, and/or distribute this software for any
 *    purpose with or without fee is hereby granted, provided that the above
 *    copyright notice and this permission notice appear in all copies.
 *
 *    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 *    WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 *    MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 *    ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 *    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 *    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 *    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 ******************************************************************************/

#ifndef _QCC_STRINGMAPKEY_H
#define _QCC_STRINGMAPKEY_H

#include <qcc/platform.h>

#include <qcc/Util.h>
#include <qcc/String.h>
#include <string.h>

#include <qcc/STLContainer.h>

namespace qcc {

/**
 * StringMapKey is useful when creating a std:map that wants a std::string
 * as its key. It is preferable to using a std::string directly since
 * doing so would require all lookup operations on the map to first create
 * a std::string (rather than using a simple const char*).
 */
class StringMapKey {
  public:
    /**
     * Create a backed version of the StringMapKey
     * Typically, this constructor is used when inserting into a map
     * since it causes storage to be allocated for the string
     *
     * @param key   String whose value will be copied into StringMapKey
     */
    StringMapKey(const qcc::String& key) : charPtr(NULL), str(key) { }

    /**
     * Create an unbacked version of the StringMapKey
     * Typically, this constructor is used when forming a key to pass to
     * map::find(), etc. The StringMapKey is a simple container for the
     * passed in char*. The char* arg to this constructor must remain
     * valid for the life of the StringMapKey.
     *
     * @param key   char* whose value (but not contents) will be stored
     *              in the StringMapKey.
     */
    StringMapKey(const char* key) : charPtr(key), str() { }

    /**
     * Get a char* representation of this StringKeyMap
     *
     * @return  char* representation this StringKeyMap
     */
    inline const char* c_str() const { return charPtr ? charPtr : str.c_str(); }

    /**
     * Return true if StringMapKey is empty.
     *
     * @return true iff StringMapKey is empty.
     */
    inline bool empty() const { return charPtr ? charPtr[0] == '\0' : str.empty(); }

    /**
     * Return the size of the contained string.
     *
     * @return size of the contained string.
     */
    inline size_t size() const { return charPtr ? strlen(charPtr) : str.size(); }

    /**
     * Less than operation
     */
    inline bool operator<(const StringMapKey& other) const { return ::strcmp(c_str(), other.c_str()) < 0; }

    /**
     * Equals operation
     */
    inline bool operator==(const StringMapKey& other) const { return ::strcmp(c_str(), other.c_str()) == 0; }

  private:
    const char* charPtr;
    qcc::String str;
};

}  // End of qcc namespace




namespace std {
/**
 * Functor to compute StrictWeakOrder
 */
template <>
struct less<qcc::StringMapKey> {
    inline bool operator()(const qcc::StringMapKey& a, const qcc::StringMapKey& b) const { return ::strcmp(a.c_str(), b.c_str()) < 0; }
};
}  // End of std namespace



_BEGIN_NAMESPACE_CONTAINER_FOR_HASH
/**
 * Functor to compute a hash for StringMapKey suitable for use with
 * std::unordered_map, std::unordered_set, std::hash_map, std::hash_set.
 */
template <>
struct hash<qcc::StringMapKey> {
    inline size_t operator()(const qcc::StringMapKey& k) const { return qcc::hash_string(k.c_str()); }
};
_END_NAMESPACE_CONTAINER_FOR_HASH



#endif