cluck_status.cpp

Go to the documentation of this file.

// Copyright (c) 2016-2025  Made to Order Software Corp.  All Rights Reserved
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 
// self
//
#include    "cluck/cluck_status.h"
 
#include    "cluck/exception.h"
#include    "cluck/names.h"
 
 
// communicator
//
#include    <communicator/names.h>
 
 
// eventdispatcher
//
#include    <eventdispatcher/names.h>
 
 
// last include
//
#include    <snapdev/poison.h>
 
 
 
namespace cluck
{
 
namespace
{
 
 
 
bool g_lock_ready = false;
 
 
void msg_ready(
      ed::message & msg
    , ed::connection_with_send_message::weak_t messenger)
{
    snapdev::NOT_USED(msg);
 
    // messenger still available?
    //
    ed::connection_with_send_message::pointer_t m(messenger.lock());
    if(m == nullptr)
    {
        return;
    }
 
    ed::message lock_status_msg;
    lock_status_msg.set_command(g_name_cluck_cmd_lock_status);
    lock_status_msg.set_service(g_name_cluck_service_name);
    lock_status_msg.add_parameter(
              communicator::g_name_communicator_param_cache
            , communicator::g_name_communicator_value_no);
    m->send_message(lock_status_msg);
}
 
 
void msg_lock_status(
      ed::message & msg
    , typename ed::dispatcher_match::execute_callback_t callback)
{
    g_lock_ready = msg.get_command() == g_name_cluck_cmd_lock_ready;
 
    if(callback != nullptr)
    {
        callback(msg);
    }
}
 
 
 
}
// no name namespace
 
 
 
 
 
 
void listen_to_cluck_status(
      ed::connection_with_send_message::pointer_t messenger
    , ed::dispatcher::pointer_t dispatcher
    , typename ed::dispatcher_match::execute_callback_t callback)
{
    {
        ed::dispatcher_match lock_ready(ed::define_match(
                  ed::Expression(g_name_cluck_cmd_lock_ready)
                , ed::Callback(std::bind(&msg_lock_status, std::placeholders::_1, callback))));
        dispatcher->add_match(lock_ready);
    }
 
    {
        ed::dispatcher_match no_lock(ed::define_match(
                  ed::Expression(g_name_cluck_cmd_no_lock)
                , ed::Callback(std::bind(&msg_lock_status, std::placeholders::_1, callback))));
        dispatcher->add_match(no_lock);
    }
 
    {
        ed::connection_with_send_message::weak_t m(messenger);
        ed::dispatcher_match ready(ed::define_match(
                  ed::Expression(ed::g_name_ed_cmd_ready)
                , ed::Callback(std::bind(&msg_ready, std::placeholders::_1, m))
                , ed::MatchFunc(&ed::one_to_one_callback_match)
                , ed::Priority(ed::dispatcher_match::DISPATCHER_MATCH_CALLBACK_PRIORITY)));
        dispatcher->add_match(ready);
    }
 
}
 
 
bool is_lock_ready()
{
    return g_lock_ready;
}
 
 
 
} // namespace cluck
// vim: ts=4 sw=4 et