masked_elem.h

Go to the documentation of this file.

#ifndef MF_MASKED_ELEM_H_
#define MF_MASKED_ELEM_H_

#include "elem.h"
#include <cstddef>
#include <type_traits>

namespace mf {


template<typename Elem, typename = void>
struct masked_elem {
    static_assert(! std::is_const<Elem>::value, "masked_elem cannot have const Elem");
    static_assert(! elem_traits<Elem>::is_nullable, "masked_elem elem cannot be nullable in this specialization");
    
    Elem elem; 
    bool mask; 
    
    static masked_elem null() { return masked_elem(); }
    bool is_null() const { return ! mask; }
    explicit operator bool () const { return ! is_null(); }
    
    masked_elem() : elem(), mask(false) { }
    masked_elem(const Elem& el) : elem(el), mask(true) { }
    masked_elem(const masked_elem&) = default;
    
    masked_elem& operator=(const masked_elem&) = default;
    masked_elem& operator=(const Elem& el) { elem = el; mask = true; return *this; }
    
    friend bool operator==(const masked_elem& a, const masked_elem& b) {
        if(a.mask && b.mask) return true;
        else if(a.mask != b.mask) return false;
        else return (a.elem == b.elem);
    }
    friend bool operator!=(const masked_elem& a, const masked_elem& b) {
        return !(a == b);
    }
    
    operator const Elem& () const { MF_EXPECTS(mask); return elem; }
    operator Elem& () { MF_EXPECTS(mask); return elem; }
};



template<typename Elem>
class masked_elem<Elem, std::enable_if_t<elem_traits<Elem>::is_nullable>> {
    static_assert(! std::is_const<Elem>::value, "masked_elem cannot have const Elem");
    static_assert(elem_traits<Elem>::is_nullable, "masked_elem elem must be nullable in this specialization");

    Elem elem; 
    
    static masked_elem null() { return masked_elem(); }
    bool is_null() const { return elem.is_null(); }
    explicit operator bool () const { return ! is_null(); }
    
    masked_elem() : elem(Elem::null()) { }
    masked_elem(const Elem& el) : elem(el) { }
    masked_elem(const masked_elem&) = default;
    
    masked_elem& operator=(const masked_elem&) = default;
    masked_elem& operator=(const Elem& el) { elem = el; return *this; }
    
    friend bool operator==(const masked_elem& a, const masked_elem& b) {
        return (a.elem == b.elem);
    }
    friend bool operator!=(const masked_elem& a, const masked_elem& b) {
        return !(a == b);
    }
    
    operator const Elem& () const { return elem; }
    operator Elem& () { return elem; }
};


// TODO const support


template<typename Elem>
struct elem_traits<masked_elem<Elem>> :
    elem_traits_base<masked_elem<Elem>, masked_elem<Elem>, 1, true> { };


namespace detail {
    template<typename Elem>
    struct unmasked_type {
        using type = Elem;
    };
    
    template<typename Elem>
    struct unmasked_type<masked_elem<Elem>> {
        using type = Elem;
    };
    
    template<typename Elem>
    struct masked_type {
        using type = masked_elem<Elem>;
    };
    
    template<typename Elem>
    struct masked_type<masked_elem<Elem>> {
        using type = masked_elem<Elem>;
    };
}


template<typename Elem> using masked_type = typename detail::masked_type<Elem>::type;


template<typename Elem> using unmasked_type = typename detail::unmasked_type<Elem>::type;


}

#endif