Skip to content

Commit

Permalink
Rename InitializerTarget{,Ref}{,T} to Target{,Ref}{,T}.
Browse files Browse the repository at this point in the history 
They are related to `Initializer` but they are applicable in their own ways also
to everything `Initializer` can be constructed from: already constructed
objects, `riegeli::Maker()`, and `riegeli::Invoker()`.

In the context of Riegeli this is an important core concept.

The names are quite long. Related names will come, which would get even longer.

PiperOrigin-RevId: 694485013
  • Loading branch information
@QrczakMK
QrczakMK committed Nov 8, 2024
1 parent 3daf0fd commit 220be07
Show file tree
Hide file tree
Showing 74 changed files with 355 additions and 443 deletions.
34 changes: 14 additions & 20 deletions riegeli/base/any.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -245,28 +245,26 @@ class
// Creates an empty `Any`.
Any() noexcept { this->Initialize(); }

// Holds a `Dependency<Handle, InitializerTargetT<Manager>>`.
// Holds a `Dependency<Handle, TargetT<Manager>>`.
template <
typename Manager,
std::enable_if_t<
absl::conjunction<
absl::negation<std::is_same<InitializerTargetT<Manager>, Any>>,
IsValidDependency<Handle, InitializerTargetT<Manager>>>::value,
absl::conjunction<absl::negation<std::is_same<TargetT<Manager>, Any>>,
IsValidDependency<Handle, TargetT<Manager>>>::value,
int> = 0>
/*implicit*/ Any(Manager&& manager);
template <
typename Manager,
std::enable_if_t<
absl::conjunction<
absl::negation<std::is_same<InitializerTargetT<Manager>, Any>>,
IsValidDependency<Handle, InitializerTargetT<Manager>>>::value,
absl::conjunction<absl::negation<std::is_same<TargetT<Manager>, Any>>,
IsValidDependency<Handle, TargetT<Manager>>>::value,
int> = 0>
Any& operator=(Manager&& manager);
template <
typename Manager,
std::enable_if_t<
absl::conjunction<
std::is_same<InitializerTargetT<Manager>, Any>,
std::is_same<TargetT<Manager>, Any>,
absl::negation<std::is_same<std::decay_t<Manager>, Any>>>::value,
int> = 0>
Any& operator=(Manager&& manager) {
Expand Down Expand Up @@ -673,31 +671,27 @@ template <
typename Manager,
std::enable_if_t<
absl::conjunction<
absl::negation<
std::is_same<InitializerTargetT<Manager>,
Any<Handle, inline_size, inline_align>>>,
IsValidDependency<Handle, InitializerTargetT<Manager>>>::value,
absl::negation<std::is_same<
TargetT<Manager>, Any<Handle, inline_size, inline_align>>>,
IsValidDependency<Handle, TargetT<Manager>>>::value,
int>>
inline Any<Handle, inline_size, inline_align>::Any(Manager&& manager) {
this->template Initialize<InitializerTargetT<Manager>>(
std::forward<Manager>(manager));
this->template Initialize<TargetT<Manager>>(std::forward<Manager>(manager));
}

template <typename Handle, size_t inline_size, size_t inline_align>
template <
typename Manager,
std::enable_if_t<
absl::conjunction<
absl::negation<
std::is_same<InitializerTargetT<Manager>,
Any<Handle, inline_size, inline_align>>>,
IsValidDependency<Handle, InitializerTargetT<Manager>>>::value,
absl::negation<std::is_same<
TargetT<Manager>, Any<Handle, inline_size, inline_align>>>,
IsValidDependency<Handle, TargetT<Manager>>>::value,
int>>
inline Any<Handle, inline_size, inline_align>&
Any<Handle, inline_size, inline_align>::operator=(Manager&& manager) {
this->Destroy();
this->template Initialize<InitializerTargetT<Manager>>(
std::forward<Manager>(manager));
this->template Initialize<TargetT<Manager>>(std::forward<Manager>(manager));
return *this;
}

Expand Down
47 changes: 20 additions & 27 deletions riegeli/base/any_initializer.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -61,18 +61,16 @@ class AnyInitializer {
// An `Any` will be empty.
AnyInitializer() noexcept : construct_(ConstructMethodEmpty) {}

// An `Any` will hold a `Dependency<Handle, InitializerTargetT<Manager>>`.
template <
typename Manager,
std::enable_if_t<
absl::conjunction<
absl::negation<
std::is_same<std::decay_t<Manager>, AnyInitializer>>,
absl::disjunction<
any_internal::IsAny<Handle, InitializerTargetT<Manager>>,
IsValidDependency<Handle, InitializerTargetT<Manager>>>>::
value,
int> = 0>
// An `Any` will hold a `Dependency<Handle, TargetT<Manager>>`.
template <typename Manager,
std::enable_if_t<
absl::conjunction<
absl::negation<
std::is_same<std::decay_t<Manager>, AnyInitializer>>,
absl::disjunction<
any_internal::IsAny<Handle, TargetT<Manager>>,
IsValidDependency<Handle, TargetT<Manager>>>>::value,
int> = 0>
/*implicit*/ AnyInitializer(Manager&& manager ABSL_ATTRIBUTE_LIFETIME_BOUND)
: construct_(ConstructMethod<Manager>),
context_(std::forward<Manager>(manager)) {}
Expand All @@ -97,17 +95,15 @@ class AnyInitializer {
size_t available_align);

template <typename Manager,
std::enable_if_t<!any_internal::IsAny<
Handle, InitializerTargetT<Manager>>::value,
int> = 0>
std::enable_if_t<
!any_internal::IsAny<Handle, TargetT<Manager>>::value, int> = 0>
static void ConstructMethod(TypeErasedRef context,
MethodsAndHandle& methods_and_handle,
Storage storage, size_t available_size,
size_t available_align);
template <typename Manager,
std::enable_if_t<
any_internal::IsAny<Handle, InitializerTargetT<Manager>>::value,
int> = 0>
any_internal::IsAny<Handle, TargetT<Manager>>::value, int> = 0>
static void ConstructMethod(TypeErasedRef context,
MethodsAndHandle& methods_and_handle,
Storage storage, size_t available_size,
Expand Down Expand Up @@ -140,14 +136,13 @@ void AnyInitializer<Handle>::ConstructMethodEmpty(
}

template <typename Handle>
template <
typename Manager,
std::enable_if_t<
!any_internal::IsAny<Handle, InitializerTargetT<Manager>>::value, int>>
template <typename Manager,
std::enable_if_t<
!any_internal::IsAny<Handle, TargetT<Manager>>::value, int>>
void AnyInitializer<Handle>::ConstructMethod(
TypeErasedRef context, MethodsAndHandle& methods_and_handle,
Storage storage, size_t available_size, size_t available_align) {
using Target = InitializerTargetT<Manager>;
using Target = TargetT<Manager>;
// This is equivalent to calling `MethodsFor<Target, true>::Construct()`
// or `MethodsFor<Target, false>::Construct()`. Separate allocation of
// `Dependency<Handle, Target>` from its construction, so that the code for
Expand Down Expand Up @@ -197,12 +192,11 @@ void AnyInitializer<Handle>::ConstructMethod(
template <typename Handle>
template <
typename Manager,
std::enable_if_t<
any_internal::IsAny<Handle, InitializerTargetT<Manager>>::value, int>>
std::enable_if_t<any_internal::IsAny<Handle, TargetT<Manager>>::value, int>>
void AnyInitializer<Handle>::ConstructMethod(
TypeErasedRef context, MethodsAndHandle& methods_and_handle,
Storage storage, size_t available_size, size_t available_align) {
using Target = InitializerTargetT<Manager>;
using Target = TargetT<Manager>;
// Materialize `Target` to consider adopting its storage.
[&](Target&& target) {
// `target.methods_and_handle_.methods->used_size <=
Expand Down Expand Up @@ -246,8 +240,7 @@ void AnyInitializer<Handle>::ConstructMethod(
// necessary: `Target` is always an `Any`, never an lvalue reference.
MethodsFor<Target, /*is_inline=*/false>::Construct(
storage, &methods_and_handle.handle, std::move(target));
}(Initializer<InitializerTargetT<Manager>>(context.Cast<Manager>())
.Reference());
}(Initializer<TargetT<Manager>>(context.Cast<Manager>()).Reference());
}

} // namespace riegeli
Expand Down
12 changes: 6 additions & 6 deletions riegeli/base/chain_base.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -866,12 +866,12 @@ class Chain::Block {
// The `substr` parameter of these member functions, if present, will get the
// `substr` parameter passed to `FromExternal()`. Having `substr` available in
// these functions might avoid storing `substr` in the external object.
template <typename T,
std::enable_if_t<
absl::conjunction<
absl::negation<std::is_same<InitializerTargetT<T>, Block>>,
SupportsToStringView<InitializerTargetT<T>>>::value,
int> = 0>
template <
typename T,
std::enable_if_t<
absl::conjunction<absl::negation<std::is_same<TargetT<T>, Block>>,
SupportsToStringView<TargetT<T>>>::value,
int> = 0>
explicit Block(T&& object);
template <typename T>
explicit Block(T&& object, absl::string_view substr);
Expand Down
17 changes: 8 additions & 9 deletions riegeli/base/chain_details.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -859,19 +859,18 @@ inline Chain::BlockIterator::reference Chain::BlockIterator::operator[](

template <
typename T,
std::enable_if_t<
absl::conjunction<
absl::negation<std::is_same<InitializerTargetT<T>, Chain::Block>>,
SupportsToStringView<InitializerTargetT<T>>>::value,
int>>
std::enable_if_t<absl::conjunction<
absl::negation<std::is_same<TargetT<T>, Chain::Block>>,
SupportsToStringView<TargetT<T>>>::value,
int>>
inline Chain::Block::Block(T&& object)
: block_(ExternalMethodsFor<InitializerTargetT<T>>::NewBlock(
std::forward<T>(object))) {}
: block_(
ExternalMethodsFor<TargetT<T>>::NewBlock(std::forward<T>(object))) {}

template <typename T>
inline Chain::Block::Block(T&& object, absl::string_view substr)
: block_(ExternalMethodsFor<InitializerTargetT<T>>::NewBlock(
std::forward<T>(object), substr)) {}
: block_(ExternalMethodsFor<TargetT<T>>::NewBlock(std::forward<T>(object),
substr)) {}

inline Chain::Block::Block(RawBlock* block, absl::string_view substr) {
if (block->size() == substr.size()) {
Expand Down
43 changes: 20 additions & 23 deletions riegeli/base/external_ref_base.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1702,7 +1702,7 @@ class ExternalRef {
private:
friend class ExternalRef;

using T = InitializerTargetRefT<Arg>;
using T = TargetRefT<Arg>;

void Initialize(Arg arg, absl::string_view substr) {
StorageBase::Initialize(substr);
Expand Down Expand Up @@ -1821,34 +1821,34 @@ class ExternalRef {
struct StorageWholeImpl;

template <typename Arg>
struct StorageWholeImpl<
Arg, std::enable_if_t<!HasCallOperator<
absl::remove_cvref_t<InitializerTargetRefT<Arg>>>::value>> {
using type = StorageWholeWithoutCallOperator<InitializerTargetRefT<Arg>>;
struct StorageWholeImpl<Arg,
std::enable_if_t<!HasCallOperator<
absl::remove_cvref_t<TargetRefT<Arg>>>::value>> {
using type = StorageWholeWithoutCallOperator<TargetRefT<Arg>>;
};

template <typename Arg>
struct StorageWholeImpl<
Arg, std::enable_if_t<HasCallOperator<
absl::remove_cvref_t<InitializerTargetRefT<Arg>>>::value>> {
using type = StorageWholeWithCallOperator<InitializerTargetRefT<Arg>>;
Arg, std::enable_if_t<
HasCallOperator<absl::remove_cvref_t<TargetRefT<Arg>>>::value>> {
using type = StorageWholeWithCallOperator<TargetRefT<Arg>>;
};

template <typename Arg, typename Enable = void>
struct StorageSubstrImpl;

template <typename Arg>
struct StorageSubstrImpl<
Arg, std::enable_if_t<!HasCallOperator<
absl::remove_cvref_t<InitializerTargetRefT<Arg>>>::value>> {
struct StorageSubstrImpl<Arg,
std::enable_if_t<!HasCallOperator<
absl::remove_cvref_t<TargetRefT<Arg>>>::value>> {
using type = StorageSubstrWithoutCallOperator<Arg>;
};

template <typename Arg>
struct StorageSubstrImpl<
Arg, std::enable_if_t<HasCallOperator<
absl::remove_cvref_t<InitializerTargetRefT<Arg>>>::value>> {
using type = StorageSubstrWithCallOperator<InitializerTargetRefT<Arg>>;
Arg, std::enable_if_t<
HasCallOperator<absl::remove_cvref_t<TargetRefT<Arg>>>::value>> {
using type = StorageSubstrWithCallOperator<TargetRefT<Arg>>;
};

public:
Expand All @@ -1869,10 +1869,9 @@ class ExternalRef {
// The object must support `riegeli::ToStringView()`.
//
// `storage` must outlive usages of the returned `ExternalRef`.
template <
typename Arg,
std::enable_if_t<
SupportsExternalRefWhole<InitializerTargetRefT<Arg>>::value, int> = 0>
template <typename Arg,
std::enable_if_t<SupportsExternalRefWhole<TargetRefT<Arg>>::value,
int> = 0>
explicit ExternalRef(Arg&& arg ABSL_ATTRIBUTE_LIFETIME_BOUND,
StorageWhole<Arg&&>&& storage
ABSL_ATTRIBUTE_LIFETIME_BOUND =
Expand All @@ -1888,9 +1887,8 @@ class ExternalRef {
//
// `storage` must outlive usages of the returned `ExternalRef`.
template <typename Arg,
std::enable_if_t<
SupportsExternalRefSubstr<InitializerTargetRefT<Arg>>::value,
int> = 0>
std::enable_if_t<SupportsExternalRefSubstr<TargetRefT<Arg>>::value,
int> = 0>
explicit ExternalRef(
Arg&& arg ABSL_ATTRIBUTE_LIFETIME_BOUND, absl::string_view substr,
StorageSubstr<Arg&&>&& storage ABSL_ATTRIBUTE_LIFETIME_BOUND =
Expand All @@ -1907,8 +1905,7 @@ class ExternalRef {
// responsible for using an appropriate type of the external object.
template <
typename Arg,
std::enable_if_t<SupportsToStringView<InitializerTargetRefT<Arg>>::value,
int> = 0>
std::enable_if_t<SupportsToStringView<TargetRefT<Arg>>::value, int> = 0>
static ExternalRef From(Arg&& arg ABSL_ATTRIBUTE_LIFETIME_BOUND,
StorageWhole<Arg&&>&& storage
ABSL_ATTRIBUTE_LIFETIME_BOUND =
Expand Down
Loading

0 comments on commit 220be07

Please sign in to comment.