#include <iostream>
#include <string>
#include <vector>

enum Size {
  small,
  medium,
  large
};

enum Color {
  red,
  green,
  blue
};

struct Item {
  std::string name;
  Size size;
  Color color;
  Item(const std::string& name, Size size, Color color):
  name(name)
  ,size(size)
  ,color(color) {}
};

struct ItemContainer {
  std::vector<Item> items;

  void addItem(const Item& item) {
    items.push_back(item);
  }

  std::vector<Item>& getItems() {
    return items;
  }
};

template <typename T>
struct AndSpecification;

template <typename T>
struct OrSpecification;

template <typename T>
struct Specification {
  virtual bool is_satisfied(const T&) const = 0;

  AndSpecification<T> operator&&(const Specification<T>& other) {
    return AndSpecification<T>(*this, other);
  }

  OrSpecification<T> operator||(const Specification<T>& other) {
    return OrSpecification<T>(*this, other);
  }
};

template <typename T>
struct Filter {
  virtual std::vector<T*> filter(ItemContainer& container, const Specification<T>& spec) {
    auto &vec = container.getItems();

    std::vector<T*> res;

     for (auto& i: vec) {
       if (spec.is_satisfied(i)) {
         res.push_back(&i);
       }
     }

     return res;
  };
};

struct SizeSpecification: Specification<Item> {
  Size size;
  SizeSpecification(Size size): size(size) {}

   bool is_satisfied(const Item& item) const {
     return item.size == size;
   }
};

struct ColorSpecification: Specification<Item> {
  Color color;
  ColorSpecification(Color color): color(color) {}

  bool is_satisfied(const Item& item) const {
    return item.color == color;
  }
};

template <typename T>
struct OrSpecification: Specification<T> {
  const Specification<T>& specLeft;
  const Specification<T>& specRight;

  OrSpecification(const Specification<T>& specLeft, const Specification<T>& specRight):
    specLeft(specLeft)
    ,specRight(specRight)
  {}

  bool is_satisfied(const Item& item) const {
    return specLeft.is_satisfied(item) || specRight.is_satisfied(item);
  }
};

template <typename T>
struct AndSpecification: Specification<T> {
  const Specification<T>& specLeft;
  const Specification<T>& specRight;

  AndSpecification(const Specification<T>& specLeft, const Specification<T>& specRight):
    specLeft(specLeft)
    ,specRight(specRight)
  {}

  bool is_satisfied(const Item& item) const {
    return specLeft.is_satisfied(item) && specRight.is_satisfied(item);
  }
};

int main()
{
  auto container = ItemContainer();
  container.addItem(Item("Medium Green", Size::medium, Color::green));
  container.addItem(Item("Large Red", Size::large, Color::red));
  container.addItem(Item("Small Blue", Size::small, Color::blue));
  container.addItem(Item("Small Red", Size::small, Color::red));

  Filter<Item> genericFilter;
  SizeSpecification sizeSpec(Size::small);
  ColorSpecification colorSpec(Color::red);
    auto filt = (colorSpec && sizeSpec)||(colorSpec || sizeSpec);
  auto filteredItems = genericFilter.filter(container, filt);
  for (const auto &item: filteredItems) {
    std::cout << "Filtered: " << item->name << std::endl;
  }

}