encounter
/
dawn-cmake
mirror of https://github.com/encounter/dawn-cmake.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
dawn-cmake/src/castable_test.cc

174 lines
5.6 KiB
C++
Raw Normal View History

Add Castable template class Implements `As<Blah>()` and `Is<Blah>()` automatically. There are several benefits to using this over the pattern of hand-rolled `IsBlah()`, `AsBlah()` methods: (1) We don't have to maintain a whole lot of hand written code. (2) These allow us to cast from the base type to _any_ derived type in a single cast. The existing hand-rolled methods usually require a couple of intermediary casts to go from the base type to the leaf type. (3) The use of a template parameter means these casts can be called from other template logic. Note: Unlike the hand-rolled `AsBlah()` methods, it is safe to call `As<T>()` even if the type does not derive from `T`. If the object does not derive from `T` then `As` will simply return `nullptr`. This allows the calling logic to replace the common pattern of: ``` if (obj.IsBlah()) { auto* b = obj.AsBlah(); ... } ``` with: ``` if (auto* b = obj.As<Blah>()) { ... } ``` This halves the number of virtual method calls, and is one line shorter. Change-Id: I4312e9831d7de6703a97184640864b8050a34177 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34260 Reviewed-by: dan sinclair <dsinclair@chromium.org> Commit-Queue: Ben Clayton <bclayton@google.com>
2020-11-30 22:50:25 +00:00
// Copyright 2020 The Tint Authors.
//
// 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.
#include "src/castable.h"
#include <memory>
#include <string>
#include "gtest/gtest.h"
Castable: Minor tweaks Prefix the fully-qualified Unique name in TINT_INSTANTIATE_CLASS_ID with :: as there might (however unlikely) be a nested 'tint' namespace. Move the test structures in castable_test back into the anonymous namespace. This means `TINT_INSTANTIATE_CLASS_ID` needs to sit outside the anonymous namespace, but prevents global namespace pollution. Change-Id: I035e9568c081fee120726106dc2150c4990c3881 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34567 Commit-Queue: Ben Clayton <bclayton@google.com> Reviewed-by: dan sinclair <dsinclair@chromium.org>
2020-12-03 17:44:19 +00:00
namespace tint {
namespace {
Add ClassID::Unique template and TINT_INSTANTIATE_CLASS_ID We're seeing some chrome bots fail unittests in ways that suspiciously look like dynamic casts are doing Wrong Things. The ClassID::Of() logic depends on the linker folding away duplicate compilation unit definitions based on ODR rules. If we were to somehow end up with different definitions, then we'd have two or more different ClassIDs for the same T type - leading to issues similar to what we're seeing. I'm not entirely sure why/how this could happen - and we've so far been entirely unable to locally reproduce - but it _might_ have something to do with the goma cache. In an attempt to work around this, move the static symbol definition out of a header-local-static and into the .cc file for each of the types. Change-Id: If914d3045b9dac6fbe8824dac71153a768cfceb9 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34563 Reviewed-by: dan sinclair <dsinclair@chromium.org> Commit-Queue: Ben Clayton <bclayton@google.com>
2020-12-02 18:19:28 +00:00
struct Animal : public tint::Castable<Animal> {
Add Castable template class Implements `As<Blah>()` and `Is<Blah>()` automatically. There are several benefits to using this over the pattern of hand-rolled `IsBlah()`, `AsBlah()` methods: (1) We don't have to maintain a whole lot of hand written code. (2) These allow us to cast from the base type to _any_ derived type in a single cast. The existing hand-rolled methods usually require a couple of intermediary casts to go from the base type to the leaf type. (3) The use of a template parameter means these casts can be called from other template logic. Note: Unlike the hand-rolled `AsBlah()` methods, it is safe to call `As<T>()` even if the type does not derive from `T`. If the object does not derive from `T` then `As` will simply return `nullptr`. This allows the calling logic to replace the common pattern of: ``` if (obj.IsBlah()) { auto* b = obj.AsBlah(); ... } ``` with: ``` if (auto* b = obj.As<Blah>()) { ... } ``` This halves the number of virtual method calls, and is one line shorter. Change-Id: I4312e9831d7de6703a97184640864b8050a34177 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34260 Reviewed-by: dan sinclair <dsinclair@chromium.org> Commit-Queue: Ben Clayton <bclayton@google.com>
2020-11-30 22:50:25 +00:00
explicit Animal(std::string n) : name(n) {}
const std::string name;
};
Add ClassID::Unique template and TINT_INSTANTIATE_CLASS_ID We're seeing some chrome bots fail unittests in ways that suspiciously look like dynamic casts are doing Wrong Things. The ClassID::Of() logic depends on the linker folding away duplicate compilation unit definitions based on ODR rules. If we were to somehow end up with different definitions, then we'd have two or more different ClassIDs for the same T type - leading to issues similar to what we're seeing. I'm not entirely sure why/how this could happen - and we've so far been entirely unable to locally reproduce - but it _might_ have something to do with the goma cache. In an attempt to work around this, move the static symbol definition out of a header-local-static and into the .cc file for each of the types. Change-Id: If914d3045b9dac6fbe8824dac71153a768cfceb9 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34563 Reviewed-by: dan sinclair <dsinclair@chromium.org> Commit-Queue: Ben Clayton <bclayton@google.com>
2020-12-02 18:19:28 +00:00
struct Amphibian : public tint::Castable<Amphibian, Animal> {
Add Castable template class Implements `As<Blah>()` and `Is<Blah>()` automatically. There are several benefits to using this over the pattern of hand-rolled `IsBlah()`, `AsBlah()` methods: (1) We don't have to maintain a whole lot of hand written code. (2) These allow us to cast from the base type to _any_ derived type in a single cast. The existing hand-rolled methods usually require a couple of intermediary casts to go from the base type to the leaf type. (3) The use of a template parameter means these casts can be called from other template logic. Note: Unlike the hand-rolled `AsBlah()` methods, it is safe to call `As<T>()` even if the type does not derive from `T`. If the object does not derive from `T` then `As` will simply return `nullptr`. This allows the calling logic to replace the common pattern of: ``` if (obj.IsBlah()) { auto* b = obj.AsBlah(); ... } ``` with: ``` if (auto* b = obj.As<Blah>()) { ... } ``` This halves the number of virtual method calls, and is one line shorter. Change-Id: I4312e9831d7de6703a97184640864b8050a34177 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34260 Reviewed-by: dan sinclair <dsinclair@chromium.org> Commit-Queue: Ben Clayton <bclayton@google.com>
2020-11-30 22:50:25 +00:00
explicit Amphibian(std::string n) : Base(n) {}
};
Add ClassID::Unique template and TINT_INSTANTIATE_CLASS_ID We're seeing some chrome bots fail unittests in ways that suspiciously look like dynamic casts are doing Wrong Things. The ClassID::Of() logic depends on the linker folding away duplicate compilation unit definitions based on ODR rules. If we were to somehow end up with different definitions, then we'd have two or more different ClassIDs for the same T type - leading to issues similar to what we're seeing. I'm not entirely sure why/how this could happen - and we've so far been entirely unable to locally reproduce - but it _might_ have something to do with the goma cache. In an attempt to work around this, move the static symbol definition out of a header-local-static and into the .cc file for each of the types. Change-Id: If914d3045b9dac6fbe8824dac71153a768cfceb9 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34563 Reviewed-by: dan sinclair <dsinclair@chromium.org> Commit-Queue: Ben Clayton <bclayton@google.com>
2020-12-02 18:19:28 +00:00
struct Mammal : public tint::Castable<Mammal, Animal> {
Add Castable template class Implements `As<Blah>()` and `Is<Blah>()` automatically. There are several benefits to using this over the pattern of hand-rolled `IsBlah()`, `AsBlah()` methods: (1) We don't have to maintain a whole lot of hand written code. (2) These allow us to cast from the base type to _any_ derived type in a single cast. The existing hand-rolled methods usually require a couple of intermediary casts to go from the base type to the leaf type. (3) The use of a template parameter means these casts can be called from other template logic. Note: Unlike the hand-rolled `AsBlah()` methods, it is safe to call `As<T>()` even if the type does not derive from `T`. If the object does not derive from `T` then `As` will simply return `nullptr`. This allows the calling logic to replace the common pattern of: ``` if (obj.IsBlah()) { auto* b = obj.AsBlah(); ... } ``` with: ``` if (auto* b = obj.As<Blah>()) { ... } ``` This halves the number of virtual method calls, and is one line shorter. Change-Id: I4312e9831d7de6703a97184640864b8050a34177 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34260 Reviewed-by: dan sinclair <dsinclair@chromium.org> Commit-Queue: Ben Clayton <bclayton@google.com>
2020-11-30 22:50:25 +00:00
explicit Mammal(std::string n) : Base(n) {}
};
Add ClassID::Unique template and TINT_INSTANTIATE_CLASS_ID We're seeing some chrome bots fail unittests in ways that suspiciously look like dynamic casts are doing Wrong Things. The ClassID::Of() logic depends on the linker folding away duplicate compilation unit definitions based on ODR rules. If we were to somehow end up with different definitions, then we'd have two or more different ClassIDs for the same T type - leading to issues similar to what we're seeing. I'm not entirely sure why/how this could happen - and we've so far been entirely unable to locally reproduce - but it _might_ have something to do with the goma cache. In an attempt to work around this, move the static symbol definition out of a header-local-static and into the .cc file for each of the types. Change-Id: If914d3045b9dac6fbe8824dac71153a768cfceb9 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34563 Reviewed-by: dan sinclair <dsinclair@chromium.org> Commit-Queue: Ben Clayton <bclayton@google.com>
2020-12-02 18:19:28 +00:00
struct Reptile : public tint::Castable<Reptile, Animal> {
Add Castable template class Implements `As<Blah>()` and `Is<Blah>()` automatically. There are several benefits to using this over the pattern of hand-rolled `IsBlah()`, `AsBlah()` methods: (1) We don't have to maintain a whole lot of hand written code. (2) These allow us to cast from the base type to _any_ derived type in a single cast. The existing hand-rolled methods usually require a couple of intermediary casts to go from the base type to the leaf type. (3) The use of a template parameter means these casts can be called from other template logic. Note: Unlike the hand-rolled `AsBlah()` methods, it is safe to call `As<T>()` even if the type does not derive from `T`. If the object does not derive from `T` then `As` will simply return `nullptr`. This allows the calling logic to replace the common pattern of: ``` if (obj.IsBlah()) { auto* b = obj.AsBlah(); ... } ``` with: ``` if (auto* b = obj.As<Blah>()) { ... } ``` This halves the number of virtual method calls, and is one line shorter. Change-Id: I4312e9831d7de6703a97184640864b8050a34177 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34260 Reviewed-by: dan sinclair <dsinclair@chromium.org> Commit-Queue: Ben Clayton <bclayton@google.com>
2020-11-30 22:50:25 +00:00
explicit Reptile(std::string n) : Base(n) {}
};
Add ClassID::Unique template and TINT_INSTANTIATE_CLASS_ID We're seeing some chrome bots fail unittests in ways that suspiciously look like dynamic casts are doing Wrong Things. The ClassID::Of() logic depends on the linker folding away duplicate compilation unit definitions based on ODR rules. If we were to somehow end up with different definitions, then we'd have two or more different ClassIDs for the same T type - leading to issues similar to what we're seeing. I'm not entirely sure why/how this could happen - and we've so far been entirely unable to locally reproduce - but it _might_ have something to do with the goma cache. In an attempt to work around this, move the static symbol definition out of a header-local-static and into the .cc file for each of the types. Change-Id: If914d3045b9dac6fbe8824dac71153a768cfceb9 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34563 Reviewed-by: dan sinclair <dsinclair@chromium.org> Commit-Queue: Ben Clayton <bclayton@google.com>
2020-12-02 18:19:28 +00:00
struct Frog : public tint::Castable<Frog, Amphibian> {
Add Castable template class Implements `As<Blah>()` and `Is<Blah>()` automatically. There are several benefits to using this over the pattern of hand-rolled `IsBlah()`, `AsBlah()` methods: (1) We don't have to maintain a whole lot of hand written code. (2) These allow us to cast from the base type to _any_ derived type in a single cast. The existing hand-rolled methods usually require a couple of intermediary casts to go from the base type to the leaf type. (3) The use of a template parameter means these casts can be called from other template logic. Note: Unlike the hand-rolled `AsBlah()` methods, it is safe to call `As<T>()` even if the type does not derive from `T`. If the object does not derive from `T` then `As` will simply return `nullptr`. This allows the calling logic to replace the common pattern of: ``` if (obj.IsBlah()) { auto* b = obj.AsBlah(); ... } ``` with: ``` if (auto* b = obj.As<Blah>()) { ... } ``` This halves the number of virtual method calls, and is one line shorter. Change-Id: I4312e9831d7de6703a97184640864b8050a34177 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34260 Reviewed-by: dan sinclair <dsinclair@chromium.org> Commit-Queue: Ben Clayton <bclayton@google.com>
2020-11-30 22:50:25 +00:00
Frog() : Base("Frog") {}
};
Add ClassID::Unique template and TINT_INSTANTIATE_CLASS_ID We're seeing some chrome bots fail unittests in ways that suspiciously look like dynamic casts are doing Wrong Things. The ClassID::Of() logic depends on the linker folding away duplicate compilation unit definitions based on ODR rules. If we were to somehow end up with different definitions, then we'd have two or more different ClassIDs for the same T type - leading to issues similar to what we're seeing. I'm not entirely sure why/how this could happen - and we've so far been entirely unable to locally reproduce - but it _might_ have something to do with the goma cache. In an attempt to work around this, move the static symbol definition out of a header-local-static and into the .cc file for each of the types. Change-Id: If914d3045b9dac6fbe8824dac71153a768cfceb9 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34563 Reviewed-by: dan sinclair <dsinclair@chromium.org> Commit-Queue: Ben Clayton <bclayton@google.com>
2020-12-02 18:19:28 +00:00
struct Bear : public tint::Castable<Bear, Mammal> {
Add Castable template class Implements `As<Blah>()` and `Is<Blah>()` automatically. There are several benefits to using this over the pattern of hand-rolled `IsBlah()`, `AsBlah()` methods: (1) We don't have to maintain a whole lot of hand written code. (2) These allow us to cast from the base type to _any_ derived type in a single cast. The existing hand-rolled methods usually require a couple of intermediary casts to go from the base type to the leaf type. (3) The use of a template parameter means these casts can be called from other template logic. Note: Unlike the hand-rolled `AsBlah()` methods, it is safe to call `As<T>()` even if the type does not derive from `T`. If the object does not derive from `T` then `As` will simply return `nullptr`. This allows the calling logic to replace the common pattern of: ``` if (obj.IsBlah()) { auto* b = obj.AsBlah(); ... } ``` with: ``` if (auto* b = obj.As<Blah>()) { ... } ``` This halves the number of virtual method calls, and is one line shorter. Change-Id: I4312e9831d7de6703a97184640864b8050a34177 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34260 Reviewed-by: dan sinclair <dsinclair@chromium.org> Commit-Queue: Ben Clayton <bclayton@google.com>
2020-11-30 22:50:25 +00:00
Bear() : Base("Bear") {}
};
Add ClassID::Unique template and TINT_INSTANTIATE_CLASS_ID We're seeing some chrome bots fail unittests in ways that suspiciously look like dynamic casts are doing Wrong Things. The ClassID::Of() logic depends on the linker folding away duplicate compilation unit definitions based on ODR rules. If we were to somehow end up with different definitions, then we'd have two or more different ClassIDs for the same T type - leading to issues similar to what we're seeing. I'm not entirely sure why/how this could happen - and we've so far been entirely unable to locally reproduce - but it _might_ have something to do with the goma cache. In an attempt to work around this, move the static symbol definition out of a header-local-static and into the .cc file for each of the types. Change-Id: If914d3045b9dac6fbe8824dac71153a768cfceb9 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34563 Reviewed-by: dan sinclair <dsinclair@chromium.org> Commit-Queue: Ben Clayton <bclayton@google.com>
2020-12-02 18:19:28 +00:00
struct Gecko : public tint::Castable<Gecko, Reptile> {
Add Castable template class Implements `As<Blah>()` and `Is<Blah>()` automatically. There are several benefits to using this over the pattern of hand-rolled `IsBlah()`, `AsBlah()` methods: (1) We don't have to maintain a whole lot of hand written code. (2) These allow us to cast from the base type to _any_ derived type in a single cast. The existing hand-rolled methods usually require a couple of intermediary casts to go from the base type to the leaf type. (3) The use of a template parameter means these casts can be called from other template logic. Note: Unlike the hand-rolled `AsBlah()` methods, it is safe to call `As<T>()` even if the type does not derive from `T`. If the object does not derive from `T` then `As` will simply return `nullptr`. This allows the calling logic to replace the common pattern of: ``` if (obj.IsBlah()) { auto* b = obj.AsBlah(); ... } ``` with: ``` if (auto* b = obj.As<Blah>()) { ... } ``` This halves the number of virtual method calls, and is one line shorter. Change-Id: I4312e9831d7de6703a97184640864b8050a34177 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34260 Reviewed-by: dan sinclair <dsinclair@chromium.org> Commit-Queue: Ben Clayton <bclayton@google.com>
2020-11-30 22:50:25 +00:00
Gecko() : Base("Gecko") {}
};
TEST(CastableBase, Is) {
std::unique_ptr<CastableBase> frog = std::make_unique<Frog>();
std::unique_ptr<CastableBase> bear = std::make_unique<Bear>();
std::unique_ptr<CastableBase> gecko = std::make_unique<Gecko>();
ASSERT_TRUE(frog->Is<Animal>());
ASSERT_TRUE(bear->Is<Animal>());
ASSERT_TRUE(gecko->Is<Animal>());
ASSERT_TRUE(frog->Is<Amphibian>());
ASSERT_FALSE(bear->Is<Amphibian>());
ASSERT_FALSE(gecko->Is<Amphibian>());
ASSERT_FALSE(frog->Is<Mammal>());
ASSERT_TRUE(bear->Is<Mammal>());
ASSERT_FALSE(gecko->Is<Mammal>());
ASSERT_FALSE(frog->Is<Reptile>());
ASSERT_FALSE(bear->Is<Reptile>());
ASSERT_TRUE(gecko->Is<Reptile>());
}
Add Castsable::IsAnyOf<T1, T2, ...>() This makes it a little easier to check if an object is one of any of the types provided. Updated Type query functions to make use of IsAnyOf. Added tests. Change-Id: I12ea62b32042b6675d998ab85b86f2fe15861330 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/44462 Commit-Queue: Antonio Maiorano <amaiorano@google.com> Reviewed-by: Ben Clayton <bclayton@google.com>
2021-03-15 17:29:03 +00:00
TEST(CastableBase, IsAnyOf) {
std::unique_ptr<CastableBase> frog = std::make_unique<Frog>();
std::unique_ptr<CastableBase> bear = std::make_unique<Bear>();
std::unique_ptr<CastableBase> gecko = std::make_unique<Gecko>();
ASSERT_TRUE((frog->IsAnyOf<Animal, Mammal, Amphibian, Reptile>()));
ASSERT_TRUE((frog->IsAnyOf<Mammal, Amphibian>()));
ASSERT_TRUE((frog->IsAnyOf<Amphibian, Reptile>()));
ASSERT_FALSE((frog->IsAnyOf<Mammal, Reptile>()));
ASSERT_TRUE((bear->IsAnyOf<Animal, Mammal, Amphibian, Reptile>()));
ASSERT_TRUE((bear->IsAnyOf<Mammal, Amphibian>()));
ASSERT_TRUE((bear->IsAnyOf<Mammal, Reptile>()));
ASSERT_FALSE((bear->IsAnyOf<Amphibian, Reptile>()));
ASSERT_TRUE((gecko->IsAnyOf<Animal, Mammal, Amphibian, Reptile>()));
ASSERT_TRUE((gecko->IsAnyOf<Mammal, Reptile>()));
ASSERT_TRUE((gecko->IsAnyOf<Amphibian, Reptile>()));
ASSERT_FALSE((gecko->IsAnyOf<Mammal, Amphibian>()));
}
Add Castable template class Implements `As<Blah>()` and `Is<Blah>()` automatically. There are several benefits to using this over the pattern of hand-rolled `IsBlah()`, `AsBlah()` methods: (1) We don't have to maintain a whole lot of hand written code. (2) These allow us to cast from the base type to _any_ derived type in a single cast. The existing hand-rolled methods usually require a couple of intermediary casts to go from the base type to the leaf type. (3) The use of a template parameter means these casts can be called from other template logic. Note: Unlike the hand-rolled `AsBlah()` methods, it is safe to call `As<T>()` even if the type does not derive from `T`. If the object does not derive from `T` then `As` will simply return `nullptr`. This allows the calling logic to replace the common pattern of: ``` if (obj.IsBlah()) { auto* b = obj.AsBlah(); ... } ``` with: ``` if (auto* b = obj.As<Blah>()) { ... } ``` This halves the number of virtual method calls, and is one line shorter. Change-Id: I4312e9831d7de6703a97184640864b8050a34177 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34260 Reviewed-by: dan sinclair <dsinclair@chromium.org> Commit-Queue: Ben Clayton <bclayton@google.com>
2020-11-30 22:50:25 +00:00
TEST(CastableBase, As) {
std::unique_ptr<CastableBase> frog = std::make_unique<Frog>();
std::unique_ptr<CastableBase> bear = std::make_unique<Bear>();
std::unique_ptr<CastableBase> gecko = std::make_unique<Gecko>();
ASSERT_EQ(frog->As<Animal>(), static_cast<Animal*>(frog.get()));
ASSERT_EQ(bear->As<Animal>(), static_cast<Animal*>(bear.get()));
ASSERT_EQ(gecko->As<Animal>(), static_cast<Animal*>(gecko.get()));
ASSERT_EQ(frog->As<Amphibian>(), static_cast<Amphibian*>(frog.get()));
ASSERT_EQ(bear->As<Amphibian>(), nullptr);
ASSERT_EQ(gecko->As<Amphibian>(), nullptr);
ASSERT_EQ(frog->As<Mammal>(), nullptr);
ASSERT_EQ(bear->As<Mammal>(), static_cast<Mammal*>(bear.get()));
ASSERT_EQ(gecko->As<Mammal>(), nullptr);
ASSERT_EQ(frog->As<Reptile>(), nullptr);
ASSERT_EQ(bear->As<Reptile>(), nullptr);
ASSERT_EQ(gecko->As<Reptile>(), static_cast<Reptile*>(gecko.get()));
}
TEST(Castable, Is) {
std::unique_ptr<Animal> frog = std::make_unique<Frog>();
std::unique_ptr<Animal> bear = std::make_unique<Bear>();
std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
ASSERT_TRUE(frog->Is<Animal>());
ASSERT_TRUE(bear->Is<Animal>());
ASSERT_TRUE(gecko->Is<Animal>());
ASSERT_TRUE(frog->Is<Amphibian>());
ASSERT_FALSE(bear->Is<Amphibian>());
ASSERT_FALSE(gecko->Is<Amphibian>());
ASSERT_FALSE(frog->Is<Mammal>());
ASSERT_TRUE(bear->Is<Mammal>());
ASSERT_FALSE(gecko->Is<Mammal>());
ASSERT_FALSE(frog->Is<Reptile>());
ASSERT_FALSE(bear->Is<Reptile>());
ASSERT_TRUE(gecko->Is<Reptile>());
}
TEST(Castable, As) {
std::unique_ptr<Animal> frog = std::make_unique<Frog>();
std::unique_ptr<Animal> bear = std::make_unique<Bear>();
std::unique_ptr<Animal> gecko = std::make_unique<Gecko>();
ASSERT_EQ(frog->As<Animal>(), static_cast<Animal*>(frog.get()));
ASSERT_EQ(bear->As<Animal>(), static_cast<Animal*>(bear.get()));
ASSERT_EQ(gecko->As<Animal>(), static_cast<Animal*>(gecko.get()));
ASSERT_EQ(frog->As<Amphibian>(), static_cast<Amphibian*>(frog.get()));
ASSERT_EQ(bear->As<Amphibian>(), nullptr);
ASSERT_EQ(gecko->As<Amphibian>(), nullptr);
ASSERT_EQ(frog->As<Mammal>(), nullptr);
ASSERT_EQ(bear->As<Mammal>(), static_cast<Mammal*>(bear.get()));
ASSERT_EQ(gecko->As<Mammal>(), nullptr);
ASSERT_EQ(frog->As<Reptile>(), nullptr);
ASSERT_EQ(bear->As<Reptile>(), nullptr);
ASSERT_EQ(gecko->As<Reptile>(), static_cast<Reptile*>(gecko.get()));
}
Castable: Minor tweaks Prefix the fully-qualified Unique name in TINT_INSTANTIATE_CLASS_ID with :: as there might (however unlikely) be a nested 'tint' namespace. Move the test structures in castable_test back into the anonymous namespace. This means `TINT_INSTANTIATE_CLASS_ID` needs to sit outside the anonymous namespace, but prevents global namespace pollution. Change-Id: I035e9568c081fee120726106dc2150c4990c3881 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34567 Commit-Queue: Ben Clayton <bclayton@google.com> Reviewed-by: dan sinclair <dsinclair@chromium.org>
2020-12-03 17:44:19 +00:00
} // namespace
Rename TINT_INSTANTIATE_CLASS_ID() to TINT_INSTANTIATE_TYPEINFO() ClassID isn't a thing any more. Change-Id: Ie1c0d4a95e58ef7166d3cab5ef733a2dfc702345 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/42921 Commit-Queue: Ben Clayton <bclayton@google.com> Reviewed-by: James Price <jrprice@google.com> Reviewed-by: Antonio Maiorano <amaiorano@google.com>
2021-03-02 20:51:18 +00:00
TINT_INSTANTIATE_TYPEINFO(Animal);
TINT_INSTANTIATE_TYPEINFO(Amphibian);
TINT_INSTANTIATE_TYPEINFO(Mammal);
TINT_INSTANTIATE_TYPEINFO(Reptile);
TINT_INSTANTIATE_TYPEINFO(Frog);
TINT_INSTANTIATE_TYPEINFO(Bear);
TINT_INSTANTIATE_TYPEINFO(Gecko);
Castable: Minor tweaks Prefix the fully-qualified Unique name in TINT_INSTANTIATE_CLASS_ID with :: as there might (however unlikely) be a nested 'tint' namespace. Move the test structures in castable_test back into the anonymous namespace. This means `TINT_INSTANTIATE_CLASS_ID` needs to sit outside the anonymous namespace, but prevents global namespace pollution. Change-Id: I035e9568c081fee120726106dc2150c4990c3881 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34567 Commit-Queue: Ben Clayton <bclayton@google.com> Reviewed-by: dan sinclair <dsinclair@chromium.org>
2020-12-03 17:44:19 +00:00
Add Castable template class Implements `As<Blah>()` and `Is<Blah>()` automatically. There are several benefits to using this over the pattern of hand-rolled `IsBlah()`, `AsBlah()` methods: (1) We don't have to maintain a whole lot of hand written code. (2) These allow us to cast from the base type to _any_ derived type in a single cast. The existing hand-rolled methods usually require a couple of intermediary casts to go from the base type to the leaf type. (3) The use of a template parameter means these casts can be called from other template logic. Note: Unlike the hand-rolled `AsBlah()` methods, it is safe to call `As<T>()` even if the type does not derive from `T`. If the object does not derive from `T` then `As` will simply return `nullptr`. This allows the calling logic to replace the common pattern of: ``` if (obj.IsBlah()) { auto* b = obj.AsBlah(); ... } ``` with: ``` if (auto* b = obj.As<Blah>()) { ... } ``` This halves the number of virtual method calls, and is one line shorter. Change-Id: I4312e9831d7de6703a97184640864b8050a34177 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34260 Reviewed-by: dan sinclair <dsinclair@chromium.org> Commit-Queue: Ben Clayton <bclayton@google.com>
2020-11-30 22:50:25 +00:00
} // namespace tint