knowrob::DisjunctiveBroadcaster Class Reference

#include <DisjunctiveBroadcaster.h>

Inheritance diagram for knowrob::DisjunctiveBroadcaster:

Collaboration diagram for knowrob::DisjunctiveBroadcaster:

Public Member Functions
	DisjunctiveBroadcaster ()
	DisjunctiveBroadcaster ()
Public Member Functions inherited from knowrob::TokenBroadcaster
	TokenBroadcaster ()
	~TokenBroadcaster () override
void	addSubscriber (const std::shared_ptr< Channel > &subscriber)
void	removeSubscriber (const std::shared_ptr< Channel > &subscriber)
	TokenBroadcaster ()
	~TokenBroadcaster () override
void	addSubscriber (const std::shared_ptr< Channel > &subscriber)
void	removeSubscriber (const std::shared_ptr< Channel > &subscriber)
Public Member Functions inherited from knowrob::TokenStream
	TokenStream ()
virtual	~TokenStream ()
	TokenStream (const TokenStream &)=delete
virtual void	close ()
bool	isOpened () const
	TokenStream ()
virtual	~TokenStream ()
	TokenStream (const TokenStream &)=delete
virtual void	close ()
bool	isOpened () const

Protected Member Functions
void	push (const TokenPtr &msg) override
void	pushAnswer (const AnswerPtr &answer)
void	pushDeferredMessages ()
void	push (const TokenPtr &msg) override
void	pushAnswer (const AnswerPtr &answer)
void	pushDeferredMessages ()
Protected Member Functions inherited from knowrob::TokenBroadcaster
virtual void	pushToBroadcast (const TokenPtr &tok)
void	push (const TokenPtr &tok) override
virtual void	pushToBroadcast (const TokenPtr &tok)
Protected Member Functions inherited from knowrob::TokenStream
virtual void	push (Channel &channel, const TokenPtr &tok)
virtual void	push (Channel &channel, const TokenPtr &tok)

Protected Attributes
std::vector< AnswerNoPtr >	negativeAnswers_
std::vector< AnswerYesPtr >	deferredPositiveAnswers_
bool	isCertainlyPositive_
std::mutex	db_mutex_
Protected Attributes inherited from knowrob::TokenBroadcaster
std::list< std::shared_ptr< Channel > >	subscribers_
std::mutex	mtx_
Protected Attributes inherited from knowrob::TokenStream
std::list< std::shared_ptr< Channel > >	channels_
std::atomic< bool >	isOpened_
std::mutex	channel_mutex_

Detailed Description

Consolidates answers from multiple sources that are considered in disjunction.

Definition at line 18 of file DisjunctiveBroadcaster.h.

Constructor & Destructor Documentation

DisjunctiveBroadcaster() [1/2]

DisjunctiveBroadcaster::DisjunctiveBroadcaster

(

)

Definition at line 10 of file DisjunctiveBroadcaster.cpp.

        : TokenBroadcaster(),
          isCertainlyPositive_(false) {
}

DisjunctiveBroadcaster() [2/2]

knowrob::DisjunctiveBroadcaster::DisjunctiveBroadcaster

(

)

Member Function Documentation

push() [1/2]

void DisjunctiveBroadcaster::push ( const TokenPtr &  msg )

overrideprotectedvirtual

Implements knowrob::TokenStream.

Definition at line 83 of file DisjunctiveBroadcaster.cpp.

                                                     {
    if (tok->indicatesEndOfEvaluation()) {
        // end of stream message indicates that the input stream has been closed.
        pushDeferredMessages();
        TokenBroadcaster::push(tok);
    } else if (tok->tokenType() == TokenType::ANSWER_TOKEN) {
        pushAnswer(std::static_pointer_cast<const Answer>(tok));
    } else {
        TokenBroadcaster::push(tok);
    }
}

push() [2/2]

void knowrob::DisjunctiveBroadcaster::push ( const TokenPtr &  msg )

overrideprotectedvirtual

Reimplemented from knowrob::TokenBroadcaster.

pushAnswer() [1/2]

void DisjunctiveBroadcaster::pushAnswer ( const AnswerPtr &  answer )

protected

Definition at line 44 of file DisjunctiveBroadcaster.cpp.

                                                               {
    // note that this stage consolidates results of independent evaluations that
    // are considered in disjunction. Thus, a positive answer from one evaluation
    // is sufficient to consider the query as satisfiable.
    // However, a negative answer from one evaluation is not sufficient to consider
    // the query as unsatisfiable, as there might be other evaluations that
    // consider the query as satisfiable.
 
    if (answer->isNegative()) {
        std::lock_guard<std::mutex> lock(db_mutex_);
        negativeAnswers_.emplace_back(std::static_pointer_cast<const AnswerNo>(answer));
    } else if (answer->isPositive()) {
        // a positive answer indicates that a subsystem suggests the input query is satisfiable.
        // however, the answer can be uncertain, so the "YES" answer is only
        // pushed directly in case it is a certain answer.
        // pushing of uncertain answers is delayed until a certain answer has been produced,
        // or until the end of the stream is reached.
        auto positiveAnswer = std::static_pointer_cast<const AnswerYes>(answer);
 
        if (positiveAnswer->isCertain()) {
            isCertainlyPositive_ = true;
            TokenBroadcaster::push(answer);
            pushDeferredMessages();
        } else {
            std::unique_lock<std::mutex> lock(db_mutex_);
            if (isCertainlyPositive_) {
                lock.unlock();
                // push uncertain positive message if a certain positive answer has been produced
                TokenBroadcaster::push(answer);
            } else {
                // else defer pushing uncertain positive answer until a certain answer has been produced, or eof reached
                deferredPositiveAnswers_.emplace_back(positiveAnswer);
            }
        }
    } else {
        // neither a positive nor a negative answer, i.e. reasoning system has no clue
    }
}

pushAnswer() [2/2]

void knowrob::DisjunctiveBroadcaster::pushAnswer ( const AnswerPtr &  answer )

protected

pushDeferredMessages() [1/2]

void DisjunctiveBroadcaster::pushDeferredMessages ( )

protected

Definition at line 15 of file DisjunctiveBroadcaster.cpp.

                                                  {
    std::lock_guard<std::mutex> lock(db_mutex_);
    if (isCertainlyPositive_) {
        for (auto &x: deferredPositiveAnswers_) {
            TokenBroadcaster::push(x);
        }
    } else {
        // neither a certain positive nor a certain negative answer has been produced.
        if (deferredPositiveAnswers_.empty()) {
            if (negativeAnswers_.size() == 1) {
                TokenBroadcaster::push(negativeAnswers_.back());
            } else if (!negativeAnswers_.empty()) {
                auto no = std::make_shared<AnswerNo>();
                for (auto &x: negativeAnswers_) {
                    no->mergeWith(*x);
                }
                TokenBroadcaster::push(no);
            }
        } else {
            // only push positive answers if there are any
            for (auto &x: deferredPositiveAnswers_) {
                TokenBroadcaster::push(x);
            }
        }
    }
    deferredPositiveAnswers_.clear();
    negativeAnswers_.clear();
}

pushDeferredMessages() [2/2]

void knowrob::DisjunctiveBroadcaster::pushDeferredMessages ( )

protected

Member Data Documentation

db_mutex_

std::mutex knowrob::DisjunctiveBroadcaster::db_mutex_

protected

Definition at line 26 of file DisjunctiveBroadcaster.h.

deferredPositiveAnswers_

std::vector< AnswerYesPtr > knowrob::DisjunctiveBroadcaster::deferredPositiveAnswers_

protected

Definition at line 24 of file DisjunctiveBroadcaster.h.

isCertainlyPositive_

bool knowrob::DisjunctiveBroadcaster::isCertainlyPositive_

protected

Definition at line 25 of file DisjunctiveBroadcaster.h.

negativeAnswers_

std::vector< AnswerNoPtr > knowrob::DisjunctiveBroadcaster::negativeAnswers_

protected

Definition at line 23 of file DisjunctiveBroadcaster.h.

---

The documentation for this class was generated from the following files:

• build/_CPack_Packages/Linux/DEB/knowrob-2.1.0-Linux/usr/include/knowrob/queries/DisjunctiveBroadcaster.h
• src/queries/DisjunctiveBroadcaster.cpp