Описать работу ателье

//Смысл в очереди в том, что у нас есть ателье, в нем есть мастер и клиенты
//мастер принмает заказы в таком порядке :
//сначало обычные впринципе до 20 заказов в день
//если появляются срочные заказы их ставят в очередь 1, и тоже самое с очень срочными.
//Но если срочных набирается 4 заказа, то мастер сделав 4 срочных делает 2 обычных заказа.
//Вот такая очередь.
#include <queue>
#include <iostream>
 
enum T_prior_val
{
    EMPTY,
    OCHEN_SROCHN,
    SROCHN,
    OBYCHN
};
 
struct T_order
{
    int  ind_;
    int  prioritet_;
    T_order(int ind = 0, int prioritet = 0) : ind_(ind), prioritet_(prioritet)
    {}
};
 
typedef std::queue<T_order>  T_orders;
 
void input_orders
    (
        T_orders&  OCHEN_SROCHN_orders,
        T_orders&  SROCHN_orders,
        T_orders&  OBYCHN_orders
    )
{
    std::cout << "Введите приоритеты заказов:"       << std::endl
              << OCHEN_SROCHN << " - очень срочный;" << std::endl
              << SROCHN       << " - срочный;"       << std::endl
              << OBYCHN       << " - обычный;"       << std::endl
              << EMPTY        << " - конец ввода;"   << std::endl;
 
    int  cur_order_ind  = 1;
    int  cur_prioritet  = EMPTY;
    for(;;)
    {
        std::cout << "Заказ #" << cur_order_ind << ": ";
        std::cin >> cur_prioritet;
        switch(cur_prioritet)
        {
        case OCHEN_SROCHN:
            OCHEN_SROCHN_orders.push(T_order(cur_order_ind++, cur_prioritet));
            break;
        case SROCHN:
            SROCHN_orders.push(T_order(cur_order_ind++, cur_prioritet));
            break;
        case OBYCHN:
            OBYCHN_orders.push(T_order(cur_order_ind++, cur_prioritet));
            break;
        case EMPTY:
            return;
        default:
            return;           
        }//switch(cur_prioritet)
    }//for(;;)
}
 
void print_order(const T_order&  order)
{
    std::cout << "Заказ # " << order.ind_;
    switch(order.prioritet_)
    {
    case OCHEN_SROCHN:
        std::cout << " (очень срочный)";
        break;
    case SROCHN:
        std::cout << " (срочный)";
        break;
    case OBYCHN:
        std::cout << " (обычный)";
        break;
    case EMPTY:
        return;
    default:
        return;           
    }//switch(order.prioritet_)
    std::cout << std::endl;
}
 
void  orders_processing
    (
        T_orders&  OCHEN_SROCHN_orders,
        T_orders&  SROCHN_orders,
        T_orders&  OBYCHN_orders
    )
{
    std::cout << std::endl
              << "Очередность обработки заказов: " << std::endl;
    const int  MAX_SROCHN_PODRYAD  = 4;
    const int  MAX_OBYCHN_PODRYAD  = 2;
    const int  MAX_ORDER_COUNT    = 20;        
    int        order_count = 0;
    while(!OCHEN_SROCHN_orders.empty())
    {
        print_order(OCHEN_SROCHN_orders.front());
        OCHEN_SROCHN_orders.pop();
        if(++order_count == MAX_ORDER_COUNT) return;
    }
 
    while(!SROCHN_orders.empty() || !OBYCHN_orders.empty())
    {
        for(int srochn_order_count = 0; 
            srochn_order_count < MAX_SROCHN_PODRYAD; ++srochn_order_count)
        {
            if(!SROCHN_orders.empty())
            {
                print_order(SROCHN_orders.front());
                SROCHN_orders.pop();
                if(++order_count == MAX_ORDER_COUNT) return;           
            }
        }//for(int srochn_order_count = 0; srochn_order_count < MAX_SROCHN_PODRYAD;...
 
        for(int obychn_order_count = 0; 
            obychn_order_count < MAX_OBYCHN_PODRYAD; ++obychn_order_count)
        {
            if(!OBYCHN_orders.empty())
            {
                print_order(OBYCHN_orders.front());
                OBYCHN_orders.pop();
                if(++order_count == MAX_ORDER_COUNT) return;           
            }
        }//for(int obychn_order_count = 0; obychn_order_count < MAX_OBYCHN_PODRYAD;...
    }//while(!SROCHN_orders.empty())  
}
 
int main()
{
    std::locale::global(std::locale("rus"));
    T_orders  OCHEN_SROCHN_orders;
    T_orders  SROCHN_orders;
    T_orders  OBYCHN_orders;
 
    input_orders
        (
            OCHEN_SROCHN_orders,
            SROCHN_orders,
            OBYCHN_orders
        );
 
    orders_processing
        (
            OCHEN_SROCHN_orders,
            SROCHN_orders,
            OBYCHN_orders
        );
 
    return 0;
}