#include #include const std::string rarities[] = { "Common", "Rare", "Epic", "Legendary" }; const std::string classes[] = { "Druid", "Hunter", "Mage", "Paladin", "Priest", "Rogue", "Shaman", "Warlock", "Warrior", "Neutral" }; const std::string types[] = { "Minion", "Spell", "Weapon", "Secret", "Hero" }; const std::string races[] = { "", "Beast", "Demon", "Dragon", "Elemental", "Mech", "Murlock", "Pirate", "Totem" }; enum class Rarity : std::uint16_t { COMMON, RARE, EPIC, LEGENDARY }; enum class Class : std::uint16_t { DRUID, HUNTER, MAGE, PALADIN, PRIEST, ROGUE, SHAMAN, WARLOCK, WARRIOR, NEUTRAL }; enum class Type : std::uint16_t { MINION, SPELL, WEAPON, SECRET, HERO }; enum class Race : std::uint16_t { NONE, BEAST, DEMON, DRAGON, ELEMENTAL, MECH, MURLOC, PIRATE, TOTEM }; class Card { private: std::string name; Rarity rarity; Class behaviour; Type type; Race race; int manaCost, attack, health; bool isGolden; public: // Minion Card( const std::string name, const Rarity, const Class, const Type, const Race, int mana, int att, int hp, bool golden ); // Spell Card( const std::string name, const Rarity, const Class, const Type, int mana, bool golden ); // Weapon Card( const std::string name, const Rarity, const Class, const Type, int mana, int att, int hp, bool golden ); void showCard() const; inline Rarity getRarity() const { return this->rarity; } inline Class getClass() const { return this->behaviour; } inline Type getType() const { return this->type; } inline Race getRace() const { return this->race; } inline int getManaCost() const { return this->manaCost; } inline int getAttack() const { return this->attack; } inline int getHealth() const { return this->health; } inline bool getGolden() const { return this->isGolden; } }; Card::Card( const std::string _name, const Rarity _rarity, const Class _behaviour, const Type _type, const Race _race, int _mana, int _att, int _hp, bool _golden ) : name{ _name }, rarity{ _rarity }, behaviour{ _behaviour }, type{ _type }, race{ _race }, manaCost{ _mana }, attack{ _att }, health{ _hp }, isGolden{ _golden } {} Card::Card( const std::string _name, const Rarity _rarity, const Class _behaviour, const Type _type, int _mana, bool _golden ) : name{ _name }, rarity{ _rarity },behaviour{ _behaviour }, type{ _type }, manaCost{ _mana }, isGolden{ _golden } {} Card::Card( const std::string _name, const Rarity _rarity, const Class _behaviour, const Type _type, int _mana, int _att, int _hp, bool _golden ) : name{ _name }, rarity{ _rarity }, behaviour{ _behaviour }, type{ _type }, manaCost{ _mana }, attack{ _att }, health{ _hp }, isGolden{ _golden } {} void Card::showCard() const { if ( this->type == Type::MINION ) { std::cout << ( ( this->isGolden ) ? "GOLDEN " : "" ) << this->name << "(" << rarities[ static_cast< int >( this->rarity ) ] << ", " << classes[ static_cast< int >( this->behaviour ) ] << ", " << types[ static_cast< int >( this->type ) ] << ", " << races[ static_cast< int >( this->race ) ] << ( static_cast< int >( this->race ) ? ", " : "" ) << this->manaCost << ", " << this->attack << ", " << this->health << ")" << std::endl; } else if ( this->type == Type::SPELL || this->type == Type::SECRET ) { std::cout << ( ( this->isGolden ) ? "GOLDEN " : "" ) << this->name << "(" << rarities[ static_cast< int >( this->rarity ) ] << ", " << classes[ static_cast< int >( this->behaviour ) ] << ", " << types[ static_cast< int >( this->type ) ] << ", " << this->manaCost << ")" << std::endl; } else { std::cout << ( ( this->isGolden ) ? "GOLDEN " : "" ) << this->name << "(" << rarities[ static_cast< int >( this->rarity ) ] << ", " << classes[ static_cast< int >( this->behaviour ) ] << ", " << types[ static_cast< int >( this->type ) ] << ", " << this->manaCost << ", " << this->attack << ", " << this->health << ")" << std::endl; } } class CardCollection { private: std::vector< Card > collection = { Card( "Druid of the Scythe", Rarity::COMMON, Class::DRUID, Type::MINION, Race::NONE, 3, 2, 2, true ), Card( "Witching Hour", Rarity::RARE, Class::DRUID, Type::SPELL, 3, false ), Card( "Rat Trap", Rarity::EPIC, Class::HUNTER, Type::SECRET, 2, false ), Card( "Houndmaster Shaw", Rarity::LEGENDARY, Class::HUNTER, Type::MINION, Race::NONE, 4, 3, 6, false ), Card( "Book of Specters", Rarity::EPIC, Class::MAGE, Type::SPELL, 2, false ), Card( "Vex Crow", Rarity::COMMON, Class::MAGE, Type::MINION, Race::BEAST, 4, 3, 3, false ), Card( "Sound the Bells", Rarity::COMMON, Class::PALADIN, Type::SPELL, 2, true ), Card( "Bellringer Sentry", Rarity::RARE, Class::PALADIN, Type::MINION, Race::NONE, 4, 3, 4, true ), Card( "Chameleos", Rarity::LEGENDARY, Class::PRIEST, Type::MINION, Race::BEAST, 1, 1, 1, false ), Card( "Divine Hymn", Rarity::COMMON, Class::PRIEST, Type::SPELL, 2, false ), Card( "Blink Fox", Rarity::COMMON, Class::ROGUE, Type::MINION, Race::BEAST, 3, 3, 3, false ), Card( "Face Collector", Rarity::LEGENDARY, Class::ROGUE, Type::MINION, Race::NONE, 3, 2, 2, false ), Card( "Hagatha the Witch", Rarity::LEGENDARY, Class::SHAMAN, Type::HERO, Race::NONE, 8, 0, 5, false ), Card( "Shudderwock", Rarity::LEGENDARY, Class::SHAMAN, Type::MINION, Race::BEAST, 9, 6, 6, false ), Card( "Ratcatcher", Rarity::EPIC, Class::WARLOCK, Type::MINION, Race::NONE, 3, 2, 2, false ), Card( "Lord Godfrey", Rarity::LEGENDARY, Class::WARLOCK, Type::MINION, Race::NONE, 7, 4, 4, false ), Card( "Warpath", Rarity::COMMON, Class::WARRIOR, Type::SPELL, 2, false ), Card( "Militia Commander", Rarity::RARE, Class::WARRIOR, Type::MINION, Race::NONE, 4, 2, 5, true ), Card( "Hench-Clan Thug", Rarity::COMMON, Class::NEUTRAL, Type::MINION, Race::NONE, 3, 3, 3, true ), Card( "Lifedrinker", Rarity::RARE, Class::NEUTRAL, Type::MINION, Race::BEAST, 4, 3, 3, true ), Card( "Genn Greymane", Rarity::LEGENDARY, Class::NEUTRAL, Type::MINION, Race::NONE, 6, 6, 5, false ), Card( "Baku the Mooneater", Rarity::LEGENDARY, Class::NEUTRAL, Type::MINION, Race::BEAST, 9, 7, 8, false ) }; public: void showCollection() const; inline std::vector< Card > getCollection() const { return this->collection; } }; void CardCollection::showCollection() const { for ( const auto& card : collection ) { card.showCard(); } } template < typename T > struct AndSpecification; template < typename T > struct OrSpecification; template < typename T > struct NotSpecification; template < typename T > struct Specification { virtual bool isSatisfied( const T& card ) const = 0; AndSpecification< T > operator && ( Specification&& other ) { return AndSpecification< T >( *this, other ); } OrSpecification< T > operator || ( Specification&& other ) { return OrSpecification< T >( *this, other ); } NotSpecification< T > operator ! () { return NotSpecification< T >( *this ); } }; struct RaritySpecification : Specification< Card > { private: Rarity rarity; public: explicit RaritySpecification( const Rarity _rarity ) : rarity{ _rarity } {} bool isSatisfied( const Card& card ) const override { return card.getRarity() == rarity; } }; struct ClassSpecification : Specification< Card > { private: Class behaviour; public: explicit ClassSpecification( const Class _behaviour ) : behaviour{ _behaviour } {} bool isSatisfied( const Card& card ) const override { return card.getClass() == behaviour; } }; struct TypeSpecification : Specification< Card > { private: Type type; public: explicit TypeSpecification( const Type _type ) : type{ _type } {} bool isSatisfied( const Card& card ) const override { return card.getType() == type; } }; struct RaceSpecification : Specification< Card > { private: Race race; public: explicit RaceSpecification( const Race _race ) : race{ _race } {} bool isSatisfied( const Card& card ) const override { return card.getRace() == race; } }; struct ManaSpecification : Specification< Card > { private: int manaCost; public: explicit ManaSpecification( const int _manaCost ) : manaCost{ _manaCost } {} bool isSatisfied( const Card& card ) const override { return card.getManaCost() == manaCost; } }; struct AttackSpecification : Specification< Card > { private: int attack; public: explicit AttackSpecification( const int _attack ) : attack{ _attack } {} bool isSatisfied( const Card& card ) const override { return card.getAttack() == attack; } }; struct HealthSpecification : Specification< Card > { private: int health; public: explicit HealthSpecification( const int _health ) : health{ _health } {} bool isSatisfied( const Card& card ) const override { return card.getHealth() == health; } }; struct GoldenSpecification : Specification< Card > { private: bool golden; public: explicit GoldenSpecification( const bool _golden ) : golden{ _golden } {} bool isSatisfied( const Card& card ) const override { return card.getGolden() == golden; } }; template < typename T > struct AndSpecification : Specification< T > { private: Specification< T >& first; Specification< T >& second; public: AndSpecification( Specification< T >& _first, Specification< T >& _second ) : first{ _first }, second{ _second } {} bool isSatisfied( const T& card ) const override { return first.isSatisfied( card ) && second.isSatisfied( card ); } }; template < typename T > struct OrSpecification : Specification< T > { private: Specification< T >& first; Specification< T >& second; public: OrSpecification( Specification< T >& _first, Specification< T >& _second ) : first{ _first }, second{ _second } {} bool isSatisfied( const T& card ) const override { return first.isSatisfied( card ) || second.isSatisfied( card ); } }; template < typename T > struct NotSpecification : Specification< T > { private: Specification< T >& first; public: NotSpecification( Specification< T >& _first ) : first{ _first } {} bool isSatisfied( const T& card ) const override { return !first.isSatisfied( card ); } }; template < typename T > struct Filter { virtual std::vector< T > filter( const std::vector< T >&, const Specification< T >& ) = 0; }; struct CardFilter : Filter< Card > { std::vector< Card > filter( const std::vector< Card >& collection, const Specification< Card >& spec ) override { std::vector< Card > result; for ( const Card& card : collection ) { if ( spec.isSatisfied( card ) ) { result.emplace_back( card ); } } return result; } }; int main( int argc, char** argv ) { CardCollection playerCollection; CardFilter cf; std::cout << "Cards in your collection:\n"; playerCollection.showCollection(); auto filter = GoldenSpecification( true ) && !ClassSpecification( Class::NEUTRAL ); auto filteredCards = cf.filter( playerCollection.getCollection(), filter ); std::cout << "\nCards matching your filter:\n"; for ( const auto& card : filteredCards ) { card.showCard(); } return EXIT_SUCCESS; }

Collection Filter