#ifndef IDBKey_h
#define IDBKey_h
#if ENABLE(INDEXED_DATABASE)
#include <wtf/Forward.h>
#include <wtf/RefCounted.h>
#include <wtf/Vector.h>
#include <wtf/text/WTFString.h>
namespace WebCore {
class IDBKey : public RefCounted<IDBKey> {
public:
typedef Vector<RefPtr<IDBKey>> KeyArray;
static Ref<IDBKey> createInvalid()
{
return adoptRef(*new IDBKey());
}
static Ref<IDBKey> createNumber(double number)
{
return adoptRef(*new IDBKey(NumberType, number));
}
static Ref<IDBKey> createString(const String& string)
{
return adoptRef(*new IDBKey(string));
}
static Ref<IDBKey> createDate(double date)
{
return adoptRef(*new IDBKey(DateType, date));
}
static PassRefPtr<IDBKey> createMultiEntryArray(const KeyArray& array)
{
KeyArray result;
size_t sizeEstimate = 0;
for (auto& key : array) {
if (!key->isValid())
continue;
bool skip = false;
for (auto& resultKey : result) {
if (key->isEqual(resultKey.get())) {
skip = true;
break;
}
}
if (!skip) {
result.append(key);
sizeEstimate += key->m_sizeEstimate;
}
}
RefPtr<IDBKey> idbKey = adoptRef(new IDBKey(result, sizeEstimate));
ASSERT(idbKey->isValid());
return idbKey.release();
}
static Ref<IDBKey> createArray(const KeyArray& array)
{
size_t sizeEstimate = 0;
for (auto& key : array)
sizeEstimate += key->m_sizeEstimate;
return adoptRef(*new IDBKey(array, sizeEstimate));
}
WEBCORE_EXPORT ~IDBKey();
enum Type {
MaxType = -1,
InvalidType = 0,
ArrayType,
StringType,
DateType,
NumberType,
MinType
};
Type type() const { return m_type; }
WEBCORE_EXPORT bool isValid() const;
const KeyArray& array() const
{
ASSERT(m_type == ArrayType);
return m_array;
}
const String& string() const
{
ASSERT(m_type == StringType);
return m_string;
}
double date() const
{
ASSERT(m_type == DateType);
return m_number;
}
double number() const
{
ASSERT(m_type == NumberType);
return m_number;
}
int compare(const IDBKey* other) const;
bool isLessThan(const IDBKey* other) const;
bool isEqual(const IDBKey* other) const;
size_t sizeEstimate() const { return m_sizeEstimate; }
static int compareTypes(Type a, Type b)
{
return b - a;
}
using RefCounted<IDBKey>::ref;
using RefCounted<IDBKey>::deref;
#ifndef NDEBUG
String loggingString() const;
#endif
private:
IDBKey() : m_type(InvalidType), m_number(0), m_sizeEstimate(OverheadSize) { }
IDBKey(Type type, double number) : m_type(type), m_number(number), m_sizeEstimate(OverheadSize + sizeof(double)) { }
explicit IDBKey(const String& value) : m_type(StringType), m_string(value), m_number(0), m_sizeEstimate(OverheadSize + value.length() * sizeof(UChar)) { }
IDBKey(const KeyArray& keyArray, size_t arraySize) : m_type(ArrayType), m_array(keyArray), m_number(0), m_sizeEstimate(OverheadSize + arraySize) { }
const Type m_type;
const KeyArray m_array;
const String m_string;
const double m_number;
const size_t m_sizeEstimate;
enum { OverheadSize = 16 };
};
}
#endif // ENABLE(INDEXED_DATABASE)
#endif // IDBKey_h