reliability.hpp

#ifndef LIBTEDDY_RELIABILITY_HPP
#define LIBTEDDY_RELIABILITY_HPP
 
#include <libteddy/details/reliability_manager.hpp>
 
namespace teddy
{
using default_oder = std::vector<int32>;
 
struct bss_manager :
    public reliability_manager<degrees::fixed<2>, domains::fixed<2>>
{
    bss_manager(
        int32 componentCount,
        int64 nodePoolSize,
        std::vector<int32> order = default_oder()
    );
 
    bss_manager(
        int32 componentCount,
        int64 nodePoolSize,
        int64 overflowNodePoolSize,
        std::vector<int32> order = default_oder()
    );
};
 
template<int32 M>
struct mss_manager :
    public reliability_manager<degrees::fixed<M>, domains::fixed<M>>
{
    mss_manager(
        int32 componentCount,
        int64 nodePoolSize,
        std::vector<int32> order = default_oder()
    );
 
    mss_manager(
        int32 componentCount,
        int64 nodePoolSize,
        int64 overflowNodePoolSize,
        std::vector<int32> order = default_oder()
    );
};
 
struct imss_manager : public reliability_manager<degrees::mixed, domains::mixed>
{
    imss_manager(
        int32 componentCount,
        int64 nodePoolSize,
        std::vector<int32> domains,
        std::vector<int32> order = default_oder()
    );
 
    imss_manager(
        int32 componentCount,
        int64 nodePoolSize,
        int64 overflowNodePoolSize,
        std::vector<int32> domains,
        std::vector<int32> order = default_oder()
    );
};
 
template<int32 M>
struct ifmss_manager :
    public reliability_manager<degrees::fixed<M>, domains::mixed>
{
    ifmss_manager(
        int32 componentCount,
        int64 nodePoolSize,
        std::vector<int32> domains,
        std::vector<int32> order = default_oder()
    );
 
    ifmss_manager(
        int32 componentCount,
        int64 nodePoolSize,
        int64 overflowNodePoolSize,
        std::vector<int32> domains,
        std::vector<int32> order = default_oder()
    );
};
 
inline bss_manager::bss_manager(
    int32 const componentCount,
    int64 const nodePoolSize,
    std::vector<int32> order
) :
    bss_manager(
        componentCount,
        nodePoolSize,
        nodePoolSize / 2,
        static_cast<std::vector<int32>&&>(order)
    )
{
}
 
inline bss_manager::bss_manager(
    int32 const componentCount,
    int64 const nodePoolSize,
    int64 const overflowNodePoolSize,
    std::vector<int32> order
) :
    reliability_manager<degrees::fixed<2>, domains::fixed<2>>(
        componentCount,
        nodePoolSize,
        overflowNodePoolSize,
        static_cast<std::vector<int32>&&>(order)
    )
{
}
 
template<int32 M>
mss_manager<M>::mss_manager(
    int32 const componentCount,
    int64 const nodePoolSize,
    std::vector<int32> order
) :
    mss_manager(
        componentCount,
        nodePoolSize,
        nodePoolSize / 2,
        static_cast<std::vector<int32>&&>(order)
    )
{
}
 
template<int32 M>
mss_manager<M>::mss_manager(
    int32 const componentCount,
    int64 const nodePoolSize,
    int64 const overflowNodePoolSize,
    std::vector<int32> order
) :
    reliability_manager<degrees::fixed<M>, domains::fixed<M>>(
        componentCount,
        nodePoolSize,
        overflowNodePoolSize,
        static_cast<std::vector<int32>&&>(order)
    )
{
}
 
inline imss_manager::imss_manager(
    int32 const componentCount,
    int64 const nodePoolSize,
    std::vector<int32> domains,
    std::vector<int32> order
) :
    imss_manager(
        componentCount,
        nodePoolSize,
        nodePoolSize / 2,
        static_cast<std::vector<int32>&&>(domains),
        static_cast<std::vector<int32>&&>(order)
    )
{
}
 
inline imss_manager::imss_manager(
    int32 const componentCount,
    int64 const nodePoolSize,
    int64 const overflowNodePoolSize,
    std::vector<int32> domains,
    std::vector<int32> order
) :
    reliability_manager<degrees::mixed, domains::mixed>(
        componentCount,
        nodePoolSize,
        overflowNodePoolSize,
        static_cast<std::vector<int32>&&>(domains),
        static_cast<std::vector<int32>&&>(order)
    )
{
}
 
template<int32 M>
ifmss_manager<M>::ifmss_manager(
    int32 const componentCount,
    int64 const nodePoolSize,
    std::vector<int32> domains,
    std::vector<int32> order
) :
    ifmss_manager(
        componentCount,
        nodePoolSize,
        nodePoolSize / 2,
        static_cast<std::vector<int32>&&>(domains),
        static_cast<std::vector<int32>&&>(order)
    )
{
}
 
template<int32 M>
ifmss_manager<M>::ifmss_manager(
    int32 const componentCount,
    int64 const nodePoolSize,
    int64 const overflowNodePoolSize,
    std::vector<int32> domains,
    std::vector<int32> order
) :
    reliability_manager<degrees::fixed<M>, domains::mixed>(
        componentCount,
        nodePoolSize,
        overflowNodePoolSize,
        static_cast<std::vector<int32>&&>(domains),
        static_cast<std::vector<int32>&&>(order)
    )
{
}
} // namespace teddy
 
#endif