This file is indexed.

/usr/include/hphp/util/lru-cache-key.h is in hhvm-dev 3.11.1+dfsg-1ubuntu1.

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
/*
 * Copyright (c) 2014 Tim Starling
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef incl_HPHP_UTIL_LRU_CACHE_KEY_H
#define incl_HPHP_UTIL_LRU_CACHE_KEY_H

#include <atomic>
#include <cstring>
#include <limits>
#include <memory>

#include "hphp/util/hash.h"

namespace HPHP {

struct LRUCacheKey {
  LRUCacheKey(const char* data, size_t size)
    : m_storage(new Storage(data, size))
  {}

  LRUCacheKey() {}

  uint64_t hash() const {
    return m_storage->hash();
  }

  size_t size() const {
    return m_storage->m_size;
  }

  const char* data() const {
    return m_storage->m_data;
  }

  const char* c_str() const {
    return data();
  }

  bool operator==(const LRUCacheKey& other) const {
    size_t s = size();
    return s == other.size() && 0 == std::memcmp(data(), other.data(), s);
  }

  struct HashCompare {
    bool equal(const LRUCacheKey& j, const LRUCacheKey& k) const {
      return j == k;
    }

    size_t hash(const LRUCacheKey& k) const {
      return k.hash();
    }
  };

private:
  struct Storage {
    Storage(const char* data, size_t size)
      : m_size(size), m_hash(0)
    {
      m_data = new char[size + 1];
      memcpy(m_data, data, size);
      m_data[size] = '\0';
    }

    ~Storage() {
      delete[] m_data;
    }

    char* m_data;
    size_t m_size;
    mutable std::atomic<size_t> m_hash;

    size_t hash() const {
      size_t h = m_hash.load(std::memory_order_relaxed);
      if (h == 0) {
        uint64_t h128[2];
        MurmurHash3::hash128<false>(m_data, m_size, 0, h128);
        h = (size_t)h128[0];
        if (h == 0) {
          h = 1;
        }
        m_hash.store(h, std::memory_order_relaxed);
      }
      return h;
    }
  };

  std::shared_ptr<Storage> m_storage;
};

} // namespace HPHP

#endif