bson_pl.cpp File Reference

#include "knowrob/reasoner/mongolog/bson_pl.h"
#include "knowrob/storage/mongo/MongoException.h"
#include <iostream>

Include dependency graph for bson_pl.cpp:

Go to the source code of this file.

Macros
#define	APPEND_BSON_PL_PAIR(list, key, value, type)

Functions
PlTerm	bson_to_term (const bson_t *doc)
bool	bsonpl_append (bson_t *doc, const char *key, const PlTerm &term, bson_error_t *err)
bool	bsonpl_concat (bson_t *doc, const PlTerm &term, bson_error_t *err)

Macro Definition Documentation

APPEND_BSON_PL_PAIR

#define APPEND_BSON_PL_PAIR	(		list,
			key,
			value,
			type
	)

Value:

        ((PlTail*)list)->append(PlCompound("-", \
        PlTermv(PlTerm(key), PlCompound(type, PlTerm(value))))) && false

Definition at line 11 of file bson_pl.cpp.

Function Documentation

bson_to_term()

PlTerm bson_to_term

(

const bson_t *

doc

)

Definition at line 210 of file bson_pl.cpp.

{
    static bson_visitor_t visitor = get_bson_visitor();
    bson_iter_t iter;
    PlTerm term;
    PlTail out_list(term);
    if (bson_iter_init(&iter, doc)) {
        if(bson_iter_visit_all(&iter, &visitor, &out_list)) {
            bson_error_t err;
            bson_set_error(&err,
                MONGOC_ERROR_BSON,
                MONGOC_ERROR_BSON_INVALID,
                "BSON iteration prematurely stopped.");
            throw knowrob::mongo::MongoException("bson", err);
        }
    }
    out_list.close();
    return term;
}

bsonpl_append()

bool bsonpl_append	(	bson_t *	doc,
		const char *	key,
		const PlTerm &	term,
		bson_error_t *	err
	)

Definition at line 311 of file bson_pl.cpp.

                                                                                        { // NOLINT(misc-no-recursion)
    if(PL_is_list((term_t)term)) {
        // append a document if term is a list
        bson_t nested_doc;
        BSON_APPEND_DOCUMENT_BEGIN(doc, key, &nested_doc);
        if(bsonpl_concat(&nested_doc, term, err)) {
            bson_append_document_end(doc, &nested_doc);
            return true;
        }
        else {
            return false;
        }
    }
    else if(std::string_view(term.name()) == "bson_t") {
        // the term contains a sub-pipeline encoded as bson_t* object which can be concatenated
        // with the pipeline under construction
        if(term.arity()!=1) {
            bson_set_error(err,
                MONGOC_ERROR_BSON,
                MONGOC_ERROR_BSON_INVALID,
                "invalid bson_t term -- arity should be 1: %s", (char*)term
            );
            return false;
        }
        const PlTerm &bson_value = term[1];
        auto *sub_bson = (bson_t*)bson_value.operator void *();
        if(sub_bson) {
            bool success = bson_concat(doc, sub_bson);
            bson_destroy(sub_bson);
            return success;
        }
        else {
            bson_set_error(err,
                MONGOC_ERROR_BSON,
                MONGOC_ERROR_BSON_INVALID,
                "invalid bson_t term -- void pointer is null: %s", (char*)term
            );
            return false;
        }
    }
    else {
        // append typed value otherwise
        return bsonpl_append_typed(doc,key,term,err);
    }
}

bsonpl_concat()

bool bsonpl_concat	(	bson_t *	doc,
		const PlTerm &	term,
		bson_error_t *	err
	)

Definition at line 357 of file bson_pl.cpp.

                                                                       { // NOLINT(misc-no-recursion)
    // the term given to bson_from_term must be a list
    PlTail list(term);
    PlTerm member;
    if(!list.next(member)) {
        // the term is a list []
        return true;
    }
    else if(PL_is_list((term_t)member)) {
        // the term is a list [[..]|_]
        do {
            if(!bsonpl_concat(doc,member,err)) {
                return false;
            }
        } while(list.next(member));
        return true;
    }
    else {
        // the term is a list [key,value]
        const char *key = (char*)member;
        list.next(member);
        return bsonpl_append(doc,key,member,err);
    }
}