aalexandre
26178124a4
This concludes the inttypes replacement. These replacement have been mostly mechanical with the use of cxx_replace.
98 linhas
3.0 KiB
C++
98 linhas
3.0 KiB
C++
/*
|
|
+----------------------------------------------------------------------+
|
|
| HipHop for PHP |
|
|
+----------------------------------------------------------------------+
|
|
| Copyright (c) 2010- Facebook, Inc. (http://www.facebook.com) |
|
|
+----------------------------------------------------------------------+
|
|
| This source file is subject to version 3.01 of the PHP license, |
|
|
| that is bundled with this package in the file LICENSE, and is |
|
|
| available through the world-wide-web at the following url: |
|
|
| http://www.php.net/license/3_01.txt |
|
|
| If you did not receive a copy of the PHP license and are unable to |
|
|
| obtain it through the world-wide-web, please send a note to |
|
|
| license@php.net so we can mail you a copy immediately. |
|
|
+----------------------------------------------------------------------+
|
|
*/
|
|
|
|
#ifndef __HPHP_IMMUTABLE_MAP_H__
|
|
#define __HPHP_IMMUTABLE_MAP_H__
|
|
|
|
#include <runtime/base/types.h>
|
|
#include <util/lock.h>
|
|
#include <util/hash.h>
|
|
#include <util/atomic.h>
|
|
|
|
namespace HPHP {
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
class SharedVariant;
|
|
/**
|
|
* an immutable map is a php-style array that can take strings and
|
|
* ints as keys. the map also stores the order in which the elements
|
|
* are inserted. once an element is added to the map, it can not be
|
|
* removed.
|
|
*/
|
|
class ImmutableMap {
|
|
public:
|
|
int indexOf(const StringData* key);
|
|
int indexOf(int64_t key);
|
|
|
|
SharedVariant* getKeyIndex(int index) {
|
|
assert(index < size());
|
|
return buckets()[index].key;
|
|
}
|
|
|
|
SharedVariant* getValIndex(int index) {
|
|
assert(index < size());
|
|
return buckets()[index].val;
|
|
}
|
|
|
|
unsigned size() const {
|
|
return m.m_num;
|
|
}
|
|
|
|
unsigned capacity() const {
|
|
return m.m_capacity_mask + 1;
|
|
}
|
|
|
|
size_t getStructSize() {
|
|
size_t size = sizeof(ImmutableMap) +
|
|
sizeof(Bucket) * m.m_num +
|
|
sizeof(int) * (m.m_capacity_mask + 1);
|
|
return size;
|
|
}
|
|
|
|
static ImmutableMap* Create(ArrayData* arr,
|
|
bool unserializeObj,
|
|
bool& shouldCache);
|
|
static void Destroy(ImmutableMap* im);
|
|
private:
|
|
ImmutableMap() {}
|
|
~ImmutableMap() {}
|
|
void add(int pos, SharedVariant *key, SharedVariant *val);
|
|
|
|
struct Bucket {
|
|
/** index of the next bucket, or -1 if the end of a chain */
|
|
int next;
|
|
/** the value of this bucket */
|
|
SharedVariant *key;
|
|
SharedVariant *val;
|
|
};
|
|
/** index of the beginning of each hash chain */
|
|
int *hash() const { return (int*)(this + 1); }
|
|
/** buckets, stored in index order */
|
|
Bucket* buckets() const { return (Bucket*)(hash() + m.m_capacity_mask + 1); }
|
|
union {
|
|
struct {
|
|
unsigned int m_capacity_mask;
|
|
unsigned int m_num;
|
|
} m;
|
|
SharedVariant* align_dummy;
|
|
};
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
}
|
|
|
|
#endif /* __HPHP_IMMUTABLE_MAP_H__ */
|