Entity Filter System with a hint of magic

EntityFilter.h

#pragma once

#include "ComponentsConfig.h"

namespace Ursine
{
    // forward declarations
    class Entity;

    class EntityFilter
    { 
        ComponentTypeMask _mask_one;
        ComponentTypeMask _mask_exclude;
        ComponentTypeMask _mask_contains;

    public:
        EntityFilter(void);

        inline ComponentTypeMask OneMask(void) const;
        inline ComponentTypeMask ExcludeMask(void) const;
        inline ComponentTypeMask ContainsMask(void) const;

        bool Matches(Entity *entity) const;

        template<class... Types>
        EntityFilter &All(void);

        template<class... Types>
        EntityFilter &Exclude(void);

        template<class... Types>
        EntityFilter &One(void);
    };
}

#include "EntityFilter.hpp"

EntityFilter.hpp

#include "ComponentRegistrar.h"

namespace Ursine
{
    namespace
    {
        template<typename... Types>
        struct MaskUnpack { };

        template<>
        struct MaskUnpack<>
        {
            static ComponentTypeMask Apply(void)
            {
                return 0;
            }
        };

        template<typename First, typename... Types>
        struct MaskUnpack<First, Types...>
        {
            static ComponentTypeMask Apply(void)
            {
                return ComponentRegistrar::GetMask<First>() | MaskUnpack<Types...>::Apply();
            }
        };
    }

    inline ComponentTypeMask EntityFilter::OneMask(void) const
    {
        return _mask_one;
    }

    inline ComponentTypeMask EntityFilter::ExcludeMask(void) const
    {
        return _mask_exclude;
    }

    inline ComponentTypeMask EntityFilter::ContainsMask(void) const
    {
        return _mask_contains;
    }

    template<class... Types>
    EntityFilter &EntityFilter::All(void)
    {
        _mask_contains |= MaskUnpack<Types...>::Apply();

        return *this;
    }

    template<class... Types>
    EntityFilter &EntityFilter::Exclude(void)
    {
        _mask_exclude |= MaskUnpack<Types...>::Apply();

        return *this;
    }

    template<class... Types>
    EntityFilter &EntityFilter::One(void)
    {
        _mask_one |= MaskUnpack<Types...>::Apply();

        return *this;
    }
}