Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
#include "PersistenceType.h"
#include <utility>
#include "nsIFile.h"
#include "nsLiteralString.h"
#include "nsString.h"
namespace mozilla::dom::quota {
namespace {
constexpr auto kPersistentCString = "persistent"_ns;
constexpr auto kTemporaryCString = "temporary"_ns;
constexpr auto kDefaultCString = "default"_ns;
constexpr auto kPrivateCString = "private"_ns;
constexpr auto kPermanentString = u"permanent"_ns;
constexpr auto kTemporaryString = u"temporary"_ns;
constexpr auto kDefaultString = u"default"_ns;
constexpr auto kPrivateString = u"private"_ns;
static_assert(PERSISTENCE_TYPE_PERSISTENT == 0 &&
PERSISTENCE_TYPE_TEMPORARY == 1 &&
PERSISTENCE_TYPE_DEFAULT == 2 &&
PERSISTENCE_TYPE_PRIVATE == 3 &&
PERSISTENCE_TYPE_INVALID == 4,
"Incorrect enum values!");
template <PersistenceType type>
struct PersistenceTypeTraits;
template <>
struct PersistenceTypeTraits<PERSISTENCE_TYPE_PERSISTENT> {
template <typename T>
static T To();
static bool From(const nsACString& aString) {
return aString == kPersistentCString;
}
static bool From(const int32_t aInt32) { return aInt32 == 0; }
static bool From(nsIFile& aFile) {
nsAutoString leafName;
MOZ_ALWAYS_SUCCEEDS(aFile.GetLeafName(leafName));
return leafName == kPermanentString;
}
};
template <>
nsLiteralCString
PersistenceTypeTraits<PERSISTENCE_TYPE_PERSISTENT>::To<nsLiteralCString>() {
return kPersistentCString;
}
template <>
struct PersistenceTypeTraits<PERSISTENCE_TYPE_TEMPORARY> {
template <typename T>
static T To();
static bool From(const nsACString& aString) {
return aString == kTemporaryCString;
}
static bool From(const int32_t aInt32) { return aInt32 == 1; }
static bool From(nsIFile& aFile) {
nsAutoString leafName;
MOZ_ALWAYS_SUCCEEDS(aFile.GetLeafName(leafName));
return leafName == kTemporaryString;
}
};
template <>
nsLiteralCString
PersistenceTypeTraits<PERSISTENCE_TYPE_TEMPORARY>::To<nsLiteralCString>() {
return kTemporaryCString;
}
template <>
struct PersistenceTypeTraits<PERSISTENCE_TYPE_DEFAULT> {
template <typename T>
static T To();
static bool From(const nsACString& aString) {
return aString == kDefaultCString;
}
static bool From(const int32_t aInt32) { return aInt32 == 2; }
static bool From(nsIFile& aFile) {
nsAutoString leafName;
MOZ_ALWAYS_SUCCEEDS(aFile.GetLeafName(leafName));
return leafName == kDefaultString;
}
};
template <>
nsLiteralCString
PersistenceTypeTraits<PERSISTENCE_TYPE_DEFAULT>::To<nsLiteralCString>() {
return kDefaultCString;
}
template <>
struct PersistenceTypeTraits<PERSISTENCE_TYPE_PRIVATE> {
template <typename T>
static T To();
static bool From(const nsACString& aString) {
return aString == kPrivateCString;
}
static bool From(const int32_t aInt32) { return aInt32 == 3; }
static bool From(nsIFile& aFile) {
nsAutoString leafName;
MOZ_ALWAYS_SUCCEEDS(aFile.GetLeafName(leafName));
return leafName == kPrivateString;
}
};
template <>
nsLiteralCString
PersistenceTypeTraits<PERSISTENCE_TYPE_PRIVATE>::To<nsLiteralCString>() {
return kPrivateCString;
}
template <typename T>
Maybe<T> TypeTo_impl(const PersistenceType aPersistenceType) {
switch (aPersistenceType) {
case PERSISTENCE_TYPE_PERSISTENT:
return Some(PersistenceTypeTraits<PERSISTENCE_TYPE_PERSISTENT>::To<T>());
case PERSISTENCE_TYPE_TEMPORARY:
return Some(PersistenceTypeTraits<PERSISTENCE_TYPE_TEMPORARY>::To<T>());
case PERSISTENCE_TYPE_DEFAULT:
return Some(PersistenceTypeTraits<PERSISTENCE_TYPE_DEFAULT>::To<T>());
case PERSISTENCE_TYPE_PRIVATE:
return Some(PersistenceTypeTraits<PERSISTENCE_TYPE_PRIVATE>::To<T>());
default:
return Nothing();
}
}
template <typename T>
Maybe<PersistenceType> TypeFrom_impl(T& aData) {
if (PersistenceTypeTraits<PERSISTENCE_TYPE_PERSISTENT>::From(aData)) {
return Some(PERSISTENCE_TYPE_PERSISTENT);
}
if (PersistenceTypeTraits<PERSISTENCE_TYPE_TEMPORARY>::From(aData)) {
return Some(PERSISTENCE_TYPE_TEMPORARY);
}
if (PersistenceTypeTraits<PERSISTENCE_TYPE_DEFAULT>::From(aData)) {
return Some(PERSISTENCE_TYPE_DEFAULT);
}
if (PersistenceTypeTraits<PERSISTENCE_TYPE_PRIVATE>::From(aData)) {
return Some(PERSISTENCE_TYPE_PRIVATE);
}
return Nothing();
}
void BadPersistenceType() { MOZ_CRASH("Bad persistence type value!"); }
} // namespace
bool IsValidPersistenceType(const PersistenceType aPersistenceType) {
switch (aPersistenceType) {
case PERSISTENCE_TYPE_PERSISTENT:
case PERSISTENCE_TYPE_TEMPORARY:
case PERSISTENCE_TYPE_DEFAULT:
case PERSISTENCE_TYPE_PRIVATE:
return true;
default:
return false;
}
}
bool IsBestEffortPersistenceType(const PersistenceType aPersistenceType) {
switch (aPersistenceType) {
case PERSISTENCE_TYPE_TEMPORARY:
case PERSISTENCE_TYPE_DEFAULT:
case PERSISTENCE_TYPE_PRIVATE:
return true;
case PERSISTENCE_TYPE_PERSISTENT:
case PERSISTENCE_TYPE_INVALID:
default:
return false;
}
}
nsLiteralCString PersistenceTypeToString(
const PersistenceType aPersistenceType) {
const auto maybeString = TypeTo_impl<nsLiteralCString>(aPersistenceType);
if (maybeString.isNothing()) {
BadPersistenceType();
}
return maybeString.value();
}
Maybe<PersistenceType> PersistenceTypeFromString(const nsACString& aString,
const fallible_t&) {
return TypeFrom_impl(aString);
}
PersistenceType PersistenceTypeFromString(const nsACString& aString) {
const auto maybePersistenceType = TypeFrom_impl(aString);
if (maybePersistenceType.isNothing()) {
BadPersistenceType();
}
return maybePersistenceType.value();
}
Maybe<PersistenceType> PersistenceTypeFromInt32(const int32_t aInt32,
const fallible_t&) {
return TypeFrom_impl(aInt32);
}
Maybe<PersistenceType> PersistenceTypeFromFile(nsIFile& aFile,
const fallible_t&) {
return TypeFrom_impl(aFile);
}
std::array<PersistenceType, 2> ComplementaryPersistenceTypes(
const PersistenceType aPersistenceType) {
MOZ_ASSERT(aPersistenceType == PERSISTENCE_TYPE_DEFAULT ||
aPersistenceType == PERSISTENCE_TYPE_TEMPORARY ||
aPersistenceType == PERSISTENCE_TYPE_PRIVATE);
if (aPersistenceType == PERSISTENCE_TYPE_TEMPORARY) {
return {PERSISTENCE_TYPE_DEFAULT, PERSISTENCE_TYPE_PRIVATE};
}
if (aPersistenceType == PERSISTENCE_TYPE_DEFAULT) {
return {PERSISTENCE_TYPE_TEMPORARY, PERSISTENCE_TYPE_PRIVATE};
}
return {PERSISTENCE_TYPE_DEFAULT, PERSISTENCE_TYPE_TEMPORARY};
}
} // namespace mozilla::dom::quota