scp_result searchElStr5_f_f_f_f_f(scp_operand *param1, scp_operand *param2, scp_operand *param3, scp_operand *param4, scp_operand *param5)
{
sc_addr arc1 = param2->addr;
sc_addr arc2 = param4->addr;
sc_addr begin1;
sc_addr end1;
sc_addr begin2;
sc_addr end2;
if (SC_RESULT_OK != sc_memory_get_arc_begin(arc1, &begin1))
{
return SCP_RESULT_ERROR;
}
if (SC_RESULT_OK != sc_memory_get_arc_end(arc1, &end1))
{
return SCP_RESULT_ERROR;
}
if (SC_RESULT_OK != sc_memory_get_arc_begin(arc2, &begin2))
{
return SCP_RESULT_ERROR;
}
if (SC_RESULT_OK != sc_memory_get_arc_end(arc2, &end2))
{
return SCP_RESULT_ERROR;
}
if (SC_ADDR_IS_EQUAL(param1->addr, begin1) && SC_ADDR_IS_EQUAL(param3->addr, end2) && SC_ADDR_IS_EQUAL(param5->addr, begin2) && SC_ADDR_IS_EQUAL(param2->addr, end2))
{
return SCP_RESULT_TRUE;
}
else
{
return SCP_RESULT_FALSE;
}
}
sc_result sc_graph_find_min_path(sc_addr graph, sc_addr beg_vertex, sc_addr end_vertex, sc_addr_list **path)
{
sc_addr curr_vertex, cur_wave;
sc_addr_list *not_checked_vertices = nullptr, *wave_list_head = nullptr, *path_head = nullptr;
sc_iterator3 *wave_it;
sc_iterator5 *it5 = sc_iterator5_f_a_a_a_f_new(graph,
sc_type_arc_pos_const_perm,
sc_type_node | sc_type_const,
sc_type_arc_pos_const_perm,
sc_graph_keynode_rrel_vertex);
if (sc_helper_check_arc(sc_graph_keynode_graph, graph, sc_type_arc_pos_const_perm) == SC_FALSE)
return SC_RESULT_ERROR_INVALID_PARAMS;
while (sc_iterator5_next(it5) == SC_TRUE)
{
if (SC_ADDR_IS_EQUAL(beg_vertex, it5->results[2]) == SC_FALSE)
{
not_checked_vertices = sc_addr_list_append(not_checked_vertices);
not_checked_vertices->value = it5->results[2];
}
}
cur_wave = sc_memory_node_new(sc_type_node | sc_type_const);
sc_memory_arc_new(sc_type_arc_pos_const_perm, cur_wave, beg_vertex);
wave_list_head = sc_addr_list_append(wave_list_head);
wave_list_head->value = cur_wave;
do {
cur_wave = create_wave(cur_wave, graph, ¬_checked_vertices);
wave_it = sc_iterator3_f_a_a_new(cur_wave,
sc_type_arc_pos_const_perm,
sc_type_node | sc_type_const);
if (sc_iterator3_next(wave_it) == SC_FALSE)
//TODO clear memory
return SC_RESULT_ERROR;
wave_list_head = sc_addr_list_append(wave_list_head);
wave_list_head->value = cur_wave;
} while(sc_helper_check_arc(cur_wave, end_vertex, sc_type_arc_pos_const_perm) == SC_FALSE);
path_head = sc_addr_list_append(path_head);
path_head->value = end_vertex;
curr_vertex = end_vertex;
wave_list_head = sc_addr_list_next(wave_list_head);
do {
curr_vertex = find_adjacent_from_wave(graph, wave_list_head->value, curr_vertex);
path_head = sc_addr_list_append(path_head);
path_head->value = curr_vertex;
} while((wave_list_head = sc_addr_list_next(wave_list_head)) != nullptr);
*path = path_head;
return SC_RESULT_OK;
}
sc_result resolve_nrel_system_identifier(sc_memory_context const * ctx)
{
sc_addr *results = 0;
sc_uint32 results_count = 0;
sc_stream *stream = sc_stream_memory_new(keynodes_str[SC_KEYNODE_NREL_SYSTEM_IDENTIFIER],
(sc_uint)(sizeof(sc_uchar) * strlen(keynodes_str[SC_KEYNODE_NREL_SYSTEM_IDENTIFIER])),
SC_STREAM_FLAG_READ, SC_FALSE);
sc_uint32 i = 0;
sc_iterator5 *it = 0;
sc_bool found = SC_FALSE;
sc_addr addr1, addr2;
// try to find nrel_system_identifier strings
if (sc_memory_find_links_with_content(ctx, stream, &results, &results_count) == SC_RESULT_OK)
{
for (i = 0; i < results_count; i++)
{
it = sc_iterator5_a_a_f_a_a_new(ctx,
sc_type_node | sc_type_const | sc_type_node_norole,
sc_type_arc_common | sc_type_const,
results[i],
sc_type_arc_pos_const_perm,
sc_type_const | sc_type_node | sc_type_node_norole);
while (sc_iterator5_next(it))
{
addr1 = sc_iterator5_value(it, 0);
addr2 = sc_iterator5_value(it, 4);
// comare begin sc-element and attribute, they must be equivalent
if (SC_ADDR_IS_EQUAL(addr1, addr2))
{
if (found == SC_FALSE)
{
sc_keynodes[SC_KEYNODE_NREL_SYSTEM_IDENTIFIER] = addr1;
found = SC_TRUE;
}else
{
sc_iterator5_free(it);
sc_stream_free(stream);
g_free(results);
g_error("There are more then one sc-elements with system identifier nrel_system_identifier ");
return SC_RESULT_ERROR;
}
}
}
sc_iterator5_free(it);
}
g_free(results);
}else
return SC_RESULT_ERROR;
sc_stream_free(stream);
return found == SC_TRUE ? SC_RESULT_OK : SC_RESULT_ERROR;
}
bool TestSearchIncidentArcs::check_search_incident_arcs()
{
assert(SC_ADDR_IS_NOT_EMPTY(mOrGraphAddr));
sc_addr arc1, arc2, arc3,v1,v2, v3, v4;
sc_memory_arc_new(sc_type_arc_pos_const_perm, sc_graph_keynode_oriented_graph, mOrGraphAddr);
// create
if (sc_graph_create_vertex(mOrGraphAddr, &v1) != SC_RESULT_OK)
return false;
if (sc_graph_create_vertex(mOrGraphAddr, &v2) != SC_RESULT_OK)
return false;
if (sc_graph_create_vertex(mOrGraphAddr, &v3) != SC_RESULT_OK)
return false;
if (sc_graph_create_vertex(mOrGraphAddr, &v4) != SC_RESULT_OK)
return false;
if (sc_graph_create_arc(mOrGraphAddr, v1, v2, &arc1) != SC_RESULT_OK)
return false;
if (sc_graph_create_arc(mOrGraphAddr, v1, v3, &arc2) != SC_RESULT_OK)
return false;
if (sc_graph_create_arc(mOrGraphAddr, v1, v4, &arc3) != SC_RESULT_OK)
return false;
if(sc_graph_check_arc(mOrGraphAddr,arc1) != SC_RESULT_OK)
return false;
sc_addr_list *arcc = (sc_addr_list*)nullptr;
if (search_incident_vertex_arc(mOrGraphAddr, v1, &arcc) != SC_RESULT_OK)
return false;
if(!SC_ADDR_IS_EQUAL(arcc->value, arc1))
return false;
arcc = sc_addr_list_next(arcc);
if(!SC_ADDR_IS_EQUAL(arcc->value, arc2))
return false;
arcc = sc_addr_list_next(arcc);
if(!SC_ADDR_IS_EQUAL(arcc->value, arc3))
return false;
return true;
}
sc_bool sc_addr_vector_contains(sc_addr addr, sc_addr_vector *requested_values)
{
for (sc_uint i = 0; i < requested_values->size(); i++)
{
sc_addr addr1 = (*requested_values)[i];
if (SC_ADDR_IS_EQUAL(addr, addr1))
return SC_TRUE;
}
return SC_FALSE;
}
bool is_sc_addr_in_segment_node_vector(sc_addr addr)
{
sc_uint32 n = segment_node_del.size();
for (sc_uint32 i = 0; i < n; i++)
{
if (SC_ADDR_IS_EQUAL(addr, segment_node_del[i]))
return true;
}
return false;
}
sc_bool sc_iterator_param_compare(sc_element *el, sc_addr addr, sc_iterator_param param)
{
g_assert(el != 0);
if (param.is_type)
return el->flags.type & param.type;
else
return SC_ADDR_IS_EQUAL(addr, param.addr);
return SC_FALSE;
}
sc_bool find_result_pair_for_const(sc_type_result *set, sc_addr const_element, sc_addr *result)
{
sc_type_result::iterator it;
for (it = set->begin() ; it != set->end(); it++)
{
sc_addr var = (*it).first;
sc_addr cnst = (*it).second;
if (SC_ADDR_IS_EQUAL(cnst, const_element))
{
*result = var;
return SC_TRUE;
}
}
return SC_FALSE;
}
scp_result ifCoin(scp_operand *param1, scp_operand *param2)
{
if (SC_FALSE == sc_memory_is_element(param1->addr))
{
return print_error("ifCoin", "Parameter 1 has no value");
}
if (SC_FALSE == sc_memory_is_element(param2->addr))
{
return print_error("ifCoin", "Parameter 2 has no value");
}
if (SC_ADDR_IS_EQUAL(param1->addr, param2->addr))
return SCP_RESULT_TRUE;
else
return SCP_RESULT_FALSE;
}
sc_result search_incident_vertexes(sc_addr graph, sc_addr arc, sc_addr_list **listVertex)
{
sc_iterator3 *it3;
sc_iterator5 *it5;
sc_type arc_type;
// sc_addr sc_graph_keynode_rrel;
if (sc_helper_check_arc(sc_graph_keynode_not_oriented_graph, graph, sc_type_arc_pos_const_perm))
arc_type = sc_type_edge_common;
else if (sc_helper_check_arc(sc_graph_keynode_oriented_graph, graph, sc_type_arc_pos_const_perm))
arc_type = sc_type_arc_common;
it5 = sc_iterator5_f_a_a_a_f_new(graph,
sc_type_arc_pos,
sc_type_node,
sc_type_arc_pos,
sc_graph_keynode_rrel_vertex);
while(sc_iterator5_next(it5) == SC_TRUE)
{
it3 = sc_iterator3_f_a_a_new(it5->results[2],
arc_type,
sc_type_node);
while(sc_iterator3_next(it3) == SC_TRUE)
{
if(SC_ADDR_IS_EQUAL(it3->results[1],arc))
{
*listVertex = sc_addr_list_append(*listVertex);
(*listVertex)->value = it3->results[0];
*listVertex = sc_addr_list_append(*listVertex);
(*listVertex)->value = it3->results[2];
}
}
}
sc_iterator5_free(it5);
sc_iterator3_free(it3);
return SC_RESULT_OK;
}
sc_addr create_wave(sc_addr cur_wave, sc_addr graph, sc_addr_list **not_checked_vertices)
{
sc_addr_list *cur_item;
sc_addr new_wave;
sc_iterator3 *it3 = sc_iterator3_f_a_a_new(cur_wave,
sc_type_arc_pos_const_perm,
sc_type_node | sc_type_const);
sc_type arc_type;
new_wave = sc_memory_node_new(sc_type_node | sc_type_const);
if (sc_helper_check_arc(sc_graph_keynode_not_oriented_graph, graph, sc_type_arc_pos_const_perm) == SC_TRUE)
arc_type = sc_type_edge_common;
else if(sc_helper_check_arc(sc_graph_keynode_oriented_graph, graph, sc_type_arc_pos_const_perm) == SC_TRUE)
arc_type = sc_type_arc_common;
while (sc_iterator3_next(it3) == SC_TRUE)
{
sc_addr cur_vertex = it3->results[2];
sc_iterator5 *it5 = sc_iterator5_f_a_a_a_f_new(cur_vertex,
arc_type | sc_type_const,
sc_type_node | sc_type_const,
sc_type_arc_pos_const_perm,
graph);
while (sc_iterator5_next(it5) == SC_TRUE)
{
cur_item = *not_checked_vertices;
do {
if (SC_ADDR_IS_EQUAL(cur_item->value, it5->results[2]) == SC_TRUE)
{
if (cur_item == *not_checked_vertices)
*not_checked_vertices = sc_addr_list_remove(*not_checked_vertices);
else cur_item = sc_addr_list_remove(cur_item);
sc_memory_arc_new(sc_type_arc_pos_const_perm, new_wave, it5->results[2]);
break;
}
} while((cur_item = sc_addr_list_next(cur_item)) != nullptr);
}
}
return new_wave;
}
sc_result agent_search_full_semantic_neighborhood(const sc_event *event, sc_addr arg)
{
sc_addr question, answer;
sc_iterator3 *it1, *it2, *it3, *it4, *it6;
sc_iterator5 *it5, *it_order, *it_order2;
sc_type el_type;
sc_bool sys_off = SC_TRUE;
sc_bool key_order_found = SC_FALSE;
if (!sc_memory_get_arc_end(arg, &question))
return SC_RESULT_ERROR_INVALID_PARAMS;
// check question type
if (sc_helper_check_arc(keynode_question_full_semantic_neighborhood, question, sc_type_arc_pos_const_perm) == SC_FALSE)
return SC_RESULT_ERROR_INVALID_TYPE;
answer = create_answer_node();
// get question argument
it1 = sc_iterator3_f_a_a_new(question, sc_type_arc_pos_const_perm, 0);
if (sc_iterator3_next(it1) == SC_TRUE)
{
if (IS_SYSTEM_ELEMENT(sc_iterator3_value(it1, 2)))
sys_off = SC_FALSE;
appendIntoAnswer(answer, sc_iterator3_value(it1, 2));
search_translation(sc_iterator3_value(it1, 2), answer, sys_off);
search_arc_components(sc_iterator3_value(it1, 2), answer, sys_off);
// iterate input arcs
it2 = sc_iterator3_a_a_f_new(0,
0,
sc_iterator3_value(it1, 2));
while (sc_iterator3_next(it2) == SC_TRUE)
{
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator3_value(it2, 0)) || IS_SYSTEM_ELEMENT(sc_iterator3_value(it2, 1))))
continue;
appendIntoAnswer(answer, sc_iterator3_value(it2, 0));
appendIntoAnswer(answer, sc_iterator3_value(it2, 1));
search_arc_components(sc_iterator3_value(it2, 0), answer, sys_off);
// iterate input arcs into found arc, to find relations
it3 = sc_iterator3_a_a_f_new(sc_type_node,
sc_type_arc_pos_const_perm,
sc_iterator3_value(it2, 1));
while (sc_iterator3_next(it3) == SC_TRUE)
{
sc_memory_get_element_type(sc_iterator3_value(it3, 0), &el_type);
if (!(el_type & (sc_type_node_norole | sc_type_node_role)))
continue;
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator3_value(it3, 1)) || IS_SYSTEM_ELEMENT(sc_iterator3_value(it3, 0))))
continue;
appendIntoAnswer(answer, sc_iterator3_value(it3, 0));
appendIntoAnswer(answer, sc_iterator3_value(it3, 1));
search_arc_components(sc_iterator3_value(it3, 0), answer, sys_off);
// search typical sc-neighborhood if necessary
if (SC_ADDR_IS_EQUAL(keynode_rrel_key_sc_element, sc_iterator3_value(it3, 0)))
{
search_typical_sc_neighborhood(sc_iterator3_value(it2, 0), answer, sys_off);
}
// check if it's a quasy binary relation
if (sc_helper_check_arc(keynode_quasybinary_relation, sc_iterator3_value(it3, 0), sc_type_arc_pos_const_perm) == SC_TRUE)
{
// iterate elements of relation
it4 = sc_iterator3_f_a_a_new(sc_iterator3_value(it2, 0), sc_type_arc_pos_const_perm, 0);
while (sc_iterator3_next(it4) == SC_TRUE)
{
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator3_value(it4, 1)) || IS_SYSTEM_ELEMENT(sc_iterator3_value(it4, 2))))
continue;
appendIntoAnswer(answer, sc_iterator3_value(it4, 1));
appendIntoAnswer(answer, sc_iterator3_value(it4, 2));
search_arc_components(sc_iterator3_value(it4, 2), answer, sys_off);
// iterate order relations between elements
it_order = sc_iterator5_f_a_a_a_a_new(sc_iterator3_value(it4, 2),
sc_type_arc_common | sc_type_const,
sc_type_node | sc_type_const,
sc_type_arc_pos_const_perm,
sc_type_node | sc_type_const);
while (sc_iterator5_next(it_order) == SC_TRUE)
{
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator5_value(it_order, 1)) || IS_SYSTEM_ELEMENT(sc_iterator5_value(it_order, 2))
|| IS_SYSTEM_ELEMENT(sc_iterator5_value(it_order, 3)) || IS_SYSTEM_ELEMENT(sc_iterator5_value(it_order, 4))))
continue;
if (SC_FALSE == sc_helper_check_arc(keynode_order_relation, sc_iterator5_value(it_order, 4), sc_type_arc_pos_const_perm))
continue;
if (SC_FALSE == sc_helper_check_arc(sc_iterator3_value(it2, 0), sc_iterator5_value(it_order, 2), sc_type_arc_pos_const_perm))
continue;
appendIntoAnswer(answer, sc_iterator5_value(it_order, 1));
appendIntoAnswer(answer, sc_iterator5_value(it_order, 2));
appendIntoAnswer(answer, sc_iterator5_value(it_order, 3));
appendIntoAnswer(answer, sc_iterator5_value(it_order, 4));
}
sc_iterator5_free(it_order);
// iterate roles of element in link
it6 = sc_iterator3_a_a_f_new(sc_type_node | sc_type_const,
sc_type_arc_pos_const_perm,
sc_iterator3_value(it4, 1));
while (sc_iterator3_next(it6) == SC_TRUE)
{
sc_memory_get_element_type(sc_iterator3_value(it6, 0), &el_type);
if (!(el_type & sc_type_node_role))
continue;
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator3_value(it6, 0))
|| IS_SYSTEM_ELEMENT(sc_iterator3_value(it6, 1))))
continue;
appendIntoAnswer(answer, sc_iterator3_value(it6, 0));
appendIntoAnswer(answer, sc_iterator3_value(it6, 1));
search_arc_components(sc_iterator3_value(it6, 0), answer, sys_off);
}
sc_iterator3_free(it6);
}
sc_iterator3_free(it4);
}
}
sc_iterator3_free(it3);
// search all parents in quasybinary relation
it5 = sc_iterator5_f_a_a_a_a_new(sc_iterator3_value(it2, 0),
sc_type_arc_common | sc_type_const,
sc_type_node | sc_type_const,
sc_type_arc_pos_const_perm,
sc_type_node | sc_type_const);
while (sc_iterator5_next(it5) == SC_TRUE)
{
// check if it's a quasy binary relation
if (sc_helper_check_arc(keynode_quasybinary_relation, sc_iterator5_value(it5, 4), sc_type_arc_pos_const_perm) == SC_TRUE)
{
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator5_value(it5, 1))
|| IS_SYSTEM_ELEMENT(sc_iterator5_value(it5, 2))
|| IS_SYSTEM_ELEMENT(sc_iterator5_value(it5, 3))
|| IS_SYSTEM_ELEMENT(sc_iterator5_value(it5, 4))))
continue;
appendIntoAnswer(answer, sc_iterator5_value(it5, 1));
appendIntoAnswer(answer, sc_iterator5_value(it5, 2));
appendIntoAnswer(answer, sc_iterator5_value(it5, 3));
appendIntoAnswer(answer, sc_iterator5_value(it5, 4));
search_arc_components(sc_iterator5_value(it5, 2), answer, sys_off);
}
}
sc_iterator5_free(it5);
// search translation for element
search_translation(sc_iterator3_value(it2, 0), answer, sys_off);
// search non-binary relation link
search_nonbinary_relation(sc_iterator3_value(it2, 0), answer, sys_off);
}
sc_iterator3_free(it2);
// iterate output arcs
it2 = sc_iterator3_f_a_a_new(sc_iterator3_value(it1, 2),
0,
0);
while (sc_iterator3_next(it2) == SC_TRUE)
{
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator3_value(it2, 1)) || IS_SYSTEM_ELEMENT(sc_iterator3_value(it2, 2))))
continue;
appendIntoAnswer(answer, sc_iterator3_value(it2, 1));
appendIntoAnswer(answer, sc_iterator3_value(it2, 2));
search_arc_components(sc_iterator3_value(it2, 2), answer, sys_off);
// iterate input arcs into found arc, to find relations
it3 = sc_iterator3_a_a_f_new(sc_type_node,
sc_type_arc_pos_const_perm,
sc_iterator3_value(it2, 1));
while (sc_iterator3_next(it3) == SC_TRUE)
{
sc_memory_get_element_type(sc_iterator3_value(it3, 0), &el_type);
if (!(el_type & (sc_type_node_norole | sc_type_node_role)))
continue;
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator3_value(it3, 1)) || IS_SYSTEM_ELEMENT(sc_iterator3_value(it3, 0))))
continue;
appendIntoAnswer(answer, sc_iterator3_value(it3, 0));
appendIntoAnswer(answer, sc_iterator3_value(it3, 1));
// search of key sc-elements order
if (SC_ADDR_IS_EQUAL(sc_iterator3_value(it3, 0), keynode_rrel_key_sc_element))
{
it_order2 = sc_iterator5_f_a_a_a_f_new(sc_iterator3_value(it2, 1),
sc_type_arc_common | sc_type_const,
sc_type_arc_pos_const_perm,
sc_type_arc_pos_const_perm,
keynode_nrel_key_sc_element_base_order);
while (sc_iterator5_next(it_order2) == SC_TRUE)
{
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator5_value(it_order2, 1)) || IS_SYSTEM_ELEMENT(sc_iterator5_value(it_order2, 3))))
continue;
appendIntoAnswer(answer, sc_iterator5_value(it_order2, 1));
appendIntoAnswer(answer, sc_iterator5_value(it_order2, 3));
if (SC_FALSE == key_order_found)
{
key_order_found = SC_TRUE;
appendIntoAnswer(answer, keynode_nrel_key_sc_element_base_order);
}
}
sc_iterator5_free(it_order2);
}
// search translation for element
search_translation(sc_iterator3_value(it3, 0), answer, sys_off);
}
sc_iterator3_free(it3);
// search translation for element
search_translation(sc_iterator3_value(it2, 2), answer, sys_off);
// check if element is an sc-link
if (SC_RESULT_OK == sc_memory_get_element_type(sc_iterator3_value(it2, 2), &el_type) &&
(el_type | sc_type_link))
{
// iterate input arcs for link
it3 = sc_iterator3_a_a_f_new(sc_type_node | sc_type_const,
sc_type_arc_pos_const_perm,
sc_iterator3_value(it2, 2));
while (sc_iterator3_next(it3) == SC_TRUE)
{
if (sc_helper_check_arc(keynode_languages, sc_iterator3_value(it3, 0), sc_type_arc_pos_const_perm) == SC_TRUE)
{
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator3_value(it3, 1)) || IS_SYSTEM_ELEMENT(sc_iterator3_value(it3, 0))))
continue;
appendIntoAnswer(answer, sc_iterator3_value(it3, 0));
appendIntoAnswer(answer, sc_iterator3_value(it3, 1));
search_arc_components(sc_iterator3_value(it3, 0), answer, sys_off);
}
}
sc_iterator3_free(it3);
}
}
sc_iterator3_free(it2);
}
sc_iterator3_free(it1);
connect_answer_to_question(question, answer);
finish_question(question);
return SC_RESULT_OK;
}
sc_bool check_coherence(sc_memory_context *context, sc_addr element, sc_addr sc_pattern, sc_addr checked_arc, sc_bool output, sc_type_result *result, sc_type_result *inp_result)
{
sc_addr addr1, addr2, temp;
sc_iterator3 *it_pattern_arc = sc_iterator3_f_a_a_new(context, element, 0, 0);
if (it_pattern_arc == null_ptr) {return SC_FALSE;}
while (SC_TRUE == sc_iterator3_next(it_pattern_arc))
{
addr2 = sc_iterator3_value(it_pattern_arc, 1);
if (SC_TRUE == sc_helper_check_arc(context, sc_pattern, addr2, sc_type_arc_pos_const_perm))
{
if (SC_TRUE == output && SC_ADDR_IS_EQUAL(checked_arc, addr2))
{
continue;
}
if (SC_TRUE == find_result_pair_for_var(result, addr2, &temp) &&
SC_FALSE == find_result_pair_for_var(inp_result, addr2, &temp))
{
sc_iterator3_free(it_pattern_arc);
return SC_FALSE;
}
}
}
sc_iterator3_free(it_pattern_arc);
it_pattern_arc = sc_iterator3_a_a_f_new(context, 0, 0, element);
if (it_pattern_arc == null_ptr) {return SC_FALSE;}
while (SC_TRUE == sc_iterator3_next(it_pattern_arc))
{
addr1 = sc_iterator3_value(it_pattern_arc, 0);
if (SC_ADDR_IS_EQUAL(addr1, sc_pattern)) continue;
addr2 = sc_iterator3_value(it_pattern_arc, 1);
if (SC_TRUE == sc_helper_check_arc(context, sc_pattern, addr2, sc_type_arc_pos_const_perm))
{
if (SC_FALSE == output && SC_ADDR_IS_EQUAL(checked_arc, addr2))
{
continue;
}
if (SC_TRUE == find_result_pair_for_var(result, addr2, &temp) &&
SC_FALSE == find_result_pair_for_var(inp_result, addr2, &temp))
{
sc_iterator3_free(it_pattern_arc);
return SC_FALSE;
}
}
}
sc_iterator3_free(it_pattern_arc);
sc_type element_type;
if (SC_RESULT_OK != sc_memory_get_element_type(context, element, &element_type)) {return SC_FALSE;}
if ((sc_type_node & element_type) != sc_type_node)
{
sc_addr end, begin;
if (SC_RESULT_OK != sc_memory_get_arc_begin(context, element, &begin)) {return SC_FALSE;}
if (SC_RESULT_OK != sc_memory_get_arc_end(context, element, &end)) {return SC_FALSE;}
if (SC_TRUE == check_coherence(context, begin, sc_pattern, element, SC_TRUE, result, inp_result) &&
SC_TRUE == check_coherence(context, end, sc_pattern, element, SC_FALSE, result, inp_result))
return SC_TRUE;
else
return SC_FALSE;
}
return SC_TRUE;
}
sc_bool _sc_iterator3_f_a_f_next(sc_iterator3 *it)
{
sc_addr arc_addr;
SC_ADDR_MAKE_EMPTY(arc_addr);
if (it->finished == SC_TRUE)
return SC_FALSE;
it->results[0] = it->params[0].addr;
it->results[2] = it->params[2].addr;
// try to find first input arc
if (SC_ADDR_IS_EMPTY(it->results[1]))
{
sc_element *el = 0;
STORAGE_CHECK_CALL(sc_storage_element_lock(it->ctx, it->params[2].addr, &el));
g_assert(el != null_ptr);
arc_addr = el->first_in_arc;
STORAGE_CHECK_CALL(sc_storage_element_unlock(it->ctx, it->params[2].addr));
}else
{
sc_element *el = 0;
STORAGE_CHECK_CALL(sc_storage_element_lock(it->ctx, it->results[1], &el));
g_assert(el != null_ptr);
arc_addr = el->arc.next_in_arc;
_sc_iterator_unref_element(it->ctx, el, it->results[1]);
STORAGE_CHECK_CALL(sc_storage_element_unlock(it->ctx, it->results[1]));
}
// trying to find input arc, that created before iterator, and wasn't deleted
while (SC_ADDR_IS_NOT_EMPTY(arc_addr))
{
sc_element *el = 0;
while (el == null_ptr)
STORAGE_CHECK_CALL(sc_storage_element_lock_try(it->ctx, arc_addr, s_max_iterator_lock_attempts, &el));
if (!sc_element_itref_add(sc_storage_get_element_meta(it->ctx, arc_addr)))
{
STORAGE_CHECK_CALL(sc_storage_element_unlock(it->ctx, arc_addr));
continue;
}
sc_addr next_in_arc = el->arc.next_in_arc;
if (sc_element_is_request_deletion(el) == SC_FALSE)
{
sc_type arc_type = el->flags.type;
sc_addr arc_begin = el->arc.begin;
sc_access_levels arc_access = el->flags.access_levels;
STORAGE_CHECK_CALL(sc_storage_element_unlock(it->ctx, arc_addr));
if (SC_ADDR_IS_EQUAL(it->params[0].addr, arc_begin) &&
sc_iterator_compare_type(arc_type, it->params[1].type) &&
sc_access_lvl_check_read(it->ctx->access_levels, arc_access)
)
{
// store found result
it->results[1] = arc_addr;
return SC_TRUE;
}
} else
{
_sc_iterator_unref_element(it->ctx, el, arc_addr);
STORAGE_CHECK_CALL(sc_storage_element_unlock(it->ctx, arc_addr));
}
// go to next arc
arc_addr = next_in_arc;
}
it->finished = SC_TRUE;
return SC_FALSE;
}
sc_bool system_sys_search_recurse(sc_memory_context *context, sc_addr sc_pattern, sc_type_hash *pattern, sc_addr curr_const_element, sc_addr curr_pattern_element, sc_type_result *inp_result, sc_type_result_vector *out_common_result, int level)
{
sc_addr addr1, addr2, temp, temp1;
int out_arc_count = 0;
sc_type_result_vector common_result;
sc_type_result_vector del_result;
sc_type_result inp_result_copy = *inp_result;
common_result.push_back(inp_result);
//Pattern arcs list
sc_addr_vector pattern_arc_set;
sc_iterator3 *it_pattern_arc = sc_iterator3_f_a_a_new(context, curr_pattern_element, 0, 0);
if (it_pattern_arc == null_ptr) {return SC_FALSE;}
while (SC_TRUE == sc_iterator3_next(it_pattern_arc))
{
addr2 = sc_iterator3_value(it_pattern_arc, 1);
if (pattern->find(SC_ADDR_LOCAL_TO_INT(addr2)) != pattern->end())
{
out_arc_count++;
pattern_arc_set.push_back(addr2);
}
}
sc_iterator3_free(it_pattern_arc);
it_pattern_arc = sc_iterator3_a_a_f_new(context, 0, 0, curr_pattern_element);
if (it_pattern_arc == null_ptr) {return SC_FALSE;}
while (SC_TRUE == sc_iterator3_next(it_pattern_arc))
{
addr1 = sc_iterator3_value(it_pattern_arc, 0);
if (SC_ADDR_IS_EQUAL(addr1, sc_pattern)) continue;
addr2 = sc_iterator3_value(it_pattern_arc, 1);
if (pattern->find(SC_ADDR_LOCAL_TO_INT(addr2)) != pattern->end())
{
pattern_arc_set.push_back(addr2);
}
}
sc_iterator3_free(it_pattern_arc);
sc_addr pattern_arc;
sc_addr const_arc;
sc_addr next_pattern_element;
sc_addr next_const_element;
sc_addr next_pattern_element_begin, next_pattern_element_end;
sc_addr next_const_element_begin, next_const_element_end;
sc_bool out_arc_flag = SC_TRUE;
sc_type_result_vector new_common_result;
sc_type_result_vector next_common_result;
sc_type_result_vector next_common_result_arc;
sc_type_result_vector next_common_result_begin;
sc_type_result_vector next_common_result_end;
sc_type_result_vector next_common_result_element;
sc_bool next_pattern_element_is_node = SC_FALSE;
sc_type next_pattern_element_type;
sc_type next_pattern_element_begin_type;
sc_type next_pattern_element_end_type;
sc_bool pattern_arc_is_const_or_has_value = SC_FALSE;
sc_bool pattern_is_const_or_has_value = SC_FALSE;
sc_bool pattern_begin_is_const_or_has_value = SC_FALSE;
sc_bool pattern_end_is_const_or_has_value = SC_FALSE;
//Pattern arcs loop
for (sc_uint i = 0; i < pattern_arc_set.size(); i++)
{
pattern_arc = pattern_arc_set[i];
out_arc_flag = SC_TRUE;
//!check pattern_arc type
sc_type pattern_arc_type;
if (sc_memory_get_element_type(context, pattern_arc, &pattern_arc_type) != SC_RESULT_OK)
continue;
if ((sc_type_const & pattern_arc_type) == sc_type_const)
continue;
pattern_arc_is_const_or_has_value = SC_FALSE;
pattern_is_const_or_has_value = SC_FALSE;
if (out_arc_count > 0)
{
if (SC_RESULT_OK != sc_memory_get_arc_end(context, pattern_arc, &next_pattern_element))
continue;
out_arc_count--;
}
else
{
if (SC_RESULT_OK != sc_memory_get_arc_begin(context, pattern_arc, &next_pattern_element))
continue;
out_arc_flag = SC_FALSE;
}
if (sc_memory_get_element_type(context, next_pattern_element, &next_pattern_element_type) != SC_RESULT_OK) {continue;}
if ((sc_type_node & next_pattern_element_type) == sc_type_node)
{
next_pattern_element_is_node = SC_TRUE;
}
else
{
next_pattern_element_is_node = SC_FALSE;
if (SC_RESULT_OK != sc_memory_get_arc_begin(context, next_pattern_element, &next_pattern_element_begin)) {continue;}
if (SC_RESULT_OK != sc_memory_get_arc_end(context, next_pattern_element, &next_pattern_element_end)) {continue;}
}
if (pattern->find(SC_ADDR_LOCAL_TO_INT(next_pattern_element)) == pattern->end())
{
continue;
}
if (next_pattern_element_is_node == SC_FALSE)
{
if (pattern->find(SC_ADDR_LOCAL_TO_INT(next_pattern_element_begin)) == pattern->end())
{
continue;
}
if (pattern->find(SC_ADDR_LOCAL_TO_INT(next_pattern_element_end)) == pattern->end())
{
continue;
}
}
sc_type_result::iterator arc_it = inp_result_copy.find(pattern_arc);
if (arc_it != inp_result_copy.end())
{
const_arc = (*arc_it).second;
pattern_arc_is_const_or_has_value = SC_TRUE;
if (out_arc_flag == SC_TRUE)
{
if (SC_RESULT_OK != sc_memory_get_arc_end(context, const_arc, &next_const_element))
continue;
}
else
{
if (SC_RESULT_OK != sc_memory_get_arc_begin(context, const_arc, &next_const_element))
continue;
}
}
//!check next_pattern_element type
if ((sc_type_const & next_pattern_element_type) == sc_type_const)
{
if (pattern_arc_is_const_or_has_value == SC_TRUE)
{
if (!SC_ADDR_IS_EQUAL(next_const_element, next_pattern_element))
{
continue;
}
}
else
{
next_const_element = next_pattern_element;
}
pattern_is_const_or_has_value = SC_TRUE;
}
else
{
sc_type_result::iterator it = inp_result_copy.find(next_pattern_element);
if (it != inp_result_copy.end())
{
if (pattern_arc_is_const_or_has_value == SC_TRUE)
{
if (!SC_ADDR_IS_EQUAL(next_const_element, (*it).second))
{
continue;
}
}
else
{
next_const_element = (*it).second;
}
pattern_is_const_or_has_value = SC_TRUE;
}
}
if (next_pattern_element_is_node == SC_FALSE)
{
pattern_begin_is_const_or_has_value = SC_FALSE;
pattern_end_is_const_or_has_value = SC_FALSE;
if (sc_memory_get_element_type(context, next_pattern_element_begin, &next_pattern_element_begin_type) != SC_RESULT_OK) {continue;}
if (sc_memory_get_element_type(context, next_pattern_element_end, &next_pattern_element_end_type) != SC_RESULT_OK) {continue;}
if (SC_TRUE == pattern_arc_is_const_or_has_value || SC_TRUE == pattern_is_const_or_has_value)
{
if (SC_RESULT_OK != sc_memory_get_arc_begin(context, next_const_element, &next_const_element_begin)) {continue;}
if (SC_RESULT_OK != sc_memory_get_arc_end(context, next_const_element, &next_const_element_end)) {continue;}
}
//!check next_pattern_element_begin type
if ((sc_type_const & next_pattern_element_begin_type) == sc_type_const)
{
if (SC_TRUE == pattern_arc_is_const_or_has_value || SC_TRUE == pattern_is_const_or_has_value)
{
if (!SC_ADDR_IS_EQUAL(next_const_element_begin, next_pattern_element_begin))
{
continue;
}
}
else
{
next_const_element_begin = next_pattern_element_begin;
}
pattern_begin_is_const_or_has_value = SC_TRUE;
}
else
{
sc_type_result::iterator it = inp_result_copy.find(next_pattern_element_begin);
if (it != inp_result_copy.end())
{
if (SC_TRUE == pattern_arc_is_const_or_has_value || SC_TRUE == pattern_is_const_or_has_value)
{
if (!SC_ADDR_IS_EQUAL(next_const_element_begin, (*it).second))
{
continue;
}
}
else
{
next_const_element_begin = (*it).second;
}
pattern_begin_is_const_or_has_value = SC_TRUE;
}
}
//!check next_pattern_element_end type
if ((sc_type_const & next_pattern_element_end_type) == sc_type_const)
{
if (SC_TRUE == pattern_arc_is_const_or_has_value || SC_TRUE == pattern_is_const_or_has_value)
{
if (!SC_ADDR_IS_EQUAL(next_const_element_end, next_pattern_element_end))
{
continue;
}
}
else
{
next_const_element_end = next_pattern_element_end;
}
pattern_end_is_const_or_has_value = SC_TRUE;
}
else
{
sc_type_result::iterator it = inp_result_copy.find(next_pattern_element_end);
if (it != inp_result_copy.end())
{
if (SC_TRUE == pattern_arc_is_const_or_has_value || SC_TRUE == pattern_is_const_or_has_value)
{
if (!SC_ADDR_IS_EQUAL(next_const_element_end, (*it).second))
{
continue;
}
}
else
{
next_const_element_end = (*it).second;
}
pattern_end_is_const_or_has_value = SC_TRUE;
}
}
}
//!const arc loop
sc_addr_vector const_arc_set;
if (pattern_arc_is_const_or_has_value == SC_FALSE)
{
sc_iterator3 *it_const_arc;
sc_type const_arc_type = ((~sc_type_var & pattern_arc_type) | sc_type_const);
if (out_arc_flag == SC_TRUE)
{
if (pattern_is_const_or_has_value == SC_TRUE)
{
it_const_arc = sc_iterator3_f_a_f_new(context, curr_const_element, const_arc_type, next_const_element);
}
else
{
sc_type next_const_element_type = ((~sc_type_var & next_pattern_element_type) | sc_type_const);
if ((sc_type_node & next_pattern_element_type) == sc_type_node)
{
next_const_element_type = next_const_element_type & sc_type_link;
}
it_const_arc = sc_iterator3_f_a_a_new(context, curr_const_element, const_arc_type, next_const_element_type);
}
}
else
{
if (pattern_is_const_or_has_value == SC_TRUE)
{
it_const_arc = sc_iterator3_f_a_f_new(context, next_const_element, const_arc_type, curr_const_element);
}
else
{
sc_type next_const_element_type = ((~sc_type_var & next_pattern_element_type) | sc_type_const);
if ((sc_type_node & next_pattern_element_type) == sc_type_node)
{
next_const_element_type = next_const_element_type & sc_type_link;
}
it_const_arc = sc_iterator3_a_a_f_new(context, next_const_element_type, const_arc_type, curr_const_element);
}
}
while (SC_TRUE == sc_iterator3_next(it_const_arc))
{
if (out_arc_flag == SC_FALSE)
{
addr1 = sc_iterator3_value(it_const_arc, 0);
if (SC_ADDR_IS_EQUAL(addr1, sc_pattern))
continue;
}
addr2 = sc_iterator3_value(it_const_arc, 1);
const_arc_set.push_back(addr2);
}
sc_iterator3_free(it_const_arc);
}
else
{
const_arc_set.push_back(const_arc);
}
for (sc_uint j = 0; j < const_arc_set.size(); j++)
{
const_arc = const_arc_set[j];
if (pattern_arc_is_const_or_has_value == SC_FALSE)
{
if (out_arc_flag == SC_TRUE)
{
if (SC_RESULT_OK != sc_memory_get_arc_end(context, const_arc, &next_const_element))
continue;
}
else
{
if (SC_RESULT_OK != sc_memory_get_arc_begin(context, const_arc, &next_const_element))
continue;
}
}
//!TODO Optimize
if (SC_FALSE == next_pattern_element_is_node)
{
sc_addr next_const_element_begin1, next_const_element_end1;
if (SC_RESULT_OK != sc_memory_get_arc_begin(context, next_const_element, &next_const_element_begin1)) {continue;}
if (SC_RESULT_OK != sc_memory_get_arc_end(context, next_const_element, &next_const_element_end1)) {continue;}
if (SC_TRUE == pattern_begin_is_const_or_has_value && SC_ADDR_IS_NOT_EQUAL(next_const_element_begin, next_const_element_begin1))
{
continue;
}
if (SC_TRUE == pattern_end_is_const_or_has_value && SC_ADDR_IS_NOT_EQUAL(next_const_element_end, next_const_element_end1))
{
continue;
}
next_const_element_begin = next_const_element_begin1;
next_const_element_end = next_const_element_end1;
}
//!Results loop
for (sc_uint k = 0; k < common_result.size(); k++)
{
sc_type_result *result = common_result[k];
if (pattern_arc_is_const_or_has_value == SC_FALSE)
{
if (SC_TRUE == find_result_pair_for_const(result, const_arc, &temp))
continue;
if (SC_FALSE == pattern_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_const(result, next_const_element, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_pattern_element))
{
continue;
}
if (SC_FALSE == next_pattern_element_is_node)
{
if (SC_FALSE == pattern_begin_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_const(result, next_const_element_begin, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_pattern_element_begin))
{
continue;
}
if (SC_FALSE == pattern_end_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_const(result, next_const_element_end, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_pattern_element_end))
{
continue;
}
}
if (SC_TRUE == find_result_pair_for_var(result, pattern_arc, &temp))
{
//!Gen new result
if (SC_FALSE == check_coherence(context, next_pattern_element, sc_pattern, pattern_arc, !out_arc_flag, result, &inp_result_copy))
{
continue;
}
sc_type_result *new_result = new sc_type_result();
(*new_result) = (*result);
new_common_result.push_back(new_result);
result = new_result;
result->erase(pattern_arc);
if (pattern_is_const_or_has_value == SC_FALSE)
{
result->erase(next_pattern_element);
}
if (SC_FALSE == next_pattern_element_is_node)
{
if (pattern_begin_is_const_or_has_value == SC_FALSE)
{
result->erase(next_pattern_element_begin);
}
if (pattern_end_is_const_or_has_value == SC_FALSE)
{
result->erase(next_pattern_element_end);
}
}
}
else
{
//! TODO Add flags to not add already existing elements
if (SC_FALSE == pattern_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_var(result, next_pattern_element, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_const_element))
{
continue;
}
if (SC_FALSE == next_pattern_element_is_node)
{
if (SC_FALSE == pattern_begin_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_var(result, next_pattern_element_begin, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_const_element_begin))
{
continue;
}
if (SC_FALSE == pattern_end_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_var(result, next_pattern_element_end, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_const_element_end))
{
continue;
}
}
}
//!Genering pair for 2nd element
result->insert(sc_addr_pair(pattern_arc, const_arc));
//!Genering pair for 3rd element
if (pattern_is_const_or_has_value == SC_FALSE)
{
result->insert(sc_addr_pair(next_pattern_element, next_const_element));
}
//! Generating pair for next pattern element begin and end
if (SC_FALSE == next_pattern_element_is_node)
{
if (pattern_begin_is_const_or_has_value == SC_FALSE)
{
result->insert(sc_addr_pair(next_pattern_element_begin, next_const_element_begin));
}
if (pattern_end_is_const_or_has_value == SC_FALSE)
{
result->insert(sc_addr_pair(next_pattern_element_end, next_const_element_end));
}
}
}
else
{
if (SC_TRUE == find_result_pair_for_const(result, const_arc, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, pattern_arc))
{
continue;
}
if (SC_TRUE == find_result_pair_for_var(result, pattern_arc, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, const_arc))
{
continue;
}
if (SC_FALSE == pattern_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_const(result, next_const_element, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_pattern_element))
{
continue;
}
if (SC_FALSE == next_pattern_element_is_node)
{
if (SC_FALSE == pattern_begin_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_const(result, next_const_element_begin, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_pattern_element_begin))
{
continue;
}
if (SC_FALSE == pattern_end_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_const(result, next_const_element_end, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_pattern_element_end))
{
continue;
}
}
if (SC_FALSE == pattern_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_var(result, next_pattern_element, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_const_element))
{
continue;
}
if (SC_FALSE == next_pattern_element_is_node)
{
if (SC_FALSE == pattern_begin_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_var(result, next_pattern_element_begin, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_const_element_begin))
{
continue;
}
if (SC_FALSE == pattern_end_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_var(result, next_pattern_element_end, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_const_element_end))
{
continue;
}
}
//!Genering pair for 3rd element
if (pattern_is_const_or_has_value == SC_FALSE)
{
result->insert(sc_addr_pair(next_pattern_element, next_const_element));
}
//! Generating pair for next pattern element begin and end
if (SC_FALSE == next_pattern_element_is_node)
{
if (pattern_begin_is_const_or_has_value == SC_FALSE)
{
result->insert(sc_addr_pair(next_pattern_element_begin, next_const_element_begin));
}
if (pattern_end_is_const_or_has_value == SC_FALSE)
{
result->insert(sc_addr_pair(next_pattern_element_end, next_const_element_end));
}
}
}
sc_type_result *arc_result = new sc_type_result();
(*arc_result) = (*result);
del_result.push_back(result);
pattern->erase(SC_ADDR_LOCAL_TO_INT(pattern_arc));
pattern->erase(SC_ADDR_LOCAL_TO_INT(next_pattern_element));
if (next_pattern_element_is_node == SC_FALSE)
{
pattern->erase(SC_ADDR_LOCAL_TO_INT(next_pattern_element_begin));
pattern->erase(SC_ADDR_LOCAL_TO_INT(next_pattern_element_end));
}
system_sys_search_recurse(context, sc_pattern, pattern, const_arc, pattern_arc,
arc_result, &next_common_result_arc, level + 1);
for (sc_uint kk = 0; kk < next_common_result_arc.size(); kk++)
{
sc_type_result *element_result = next_common_result_arc[kk];
system_sys_search_recurse(context, sc_pattern, pattern, next_const_element, next_pattern_element,
element_result, &next_common_result_element, level + 1);
if (SC_FALSE == next_pattern_element_is_node)
{
//! Recurse for begin element
for (sc_uint kk_begin = 0; kk_begin < next_common_result_element.size(); kk_begin++)
{
sc_type_result *begin_result = next_common_result_element[kk_begin];
system_sys_search_recurse(context, sc_pattern, pattern, next_const_element_begin, next_pattern_element_begin,
begin_result, &next_common_result_begin, level + 1);
//! Recurse for end element
for (sc_uint kk_end = 0; kk_end < next_common_result_begin.size(); kk_end++)
{
sc_type_result *end_result = next_common_result_begin[kk_end];
system_sys_search_recurse(context, sc_pattern, pattern, next_const_element_end, next_pattern_element_end,
end_result, &next_common_result_end, level + 1);
next_common_result.insert(next_common_result.end(),
next_common_result_end.begin(), next_common_result_end.end());
next_common_result_end.clear();
}
next_common_result_begin.clear();
}
next_common_result_element.clear();
}
else
{
next_common_result.insert(next_common_result.end(),
next_common_result_element.begin(), next_common_result_element.end());
next_common_result_element.clear();
}
}
pattern->insert(sc_hash_pair(SC_ADDR_LOCAL_TO_INT(pattern_arc), pattern_arc));
pattern->insert(sc_hash_pair(SC_ADDR_LOCAL_TO_INT(next_pattern_element), next_pattern_element));
if (next_pattern_element_is_node == SC_FALSE)
{
pattern->insert(sc_hash_pair(SC_ADDR_LOCAL_TO_INT(next_pattern_element_begin), next_pattern_element_begin));
pattern->insert(sc_hash_pair(SC_ADDR_LOCAL_TO_INT(next_pattern_element_end), next_pattern_element_end));
}
out_common_result->insert(out_common_result->end(), next_common_result.begin(), next_common_result.end());
new_common_result.insert(new_common_result.end(), next_common_result.begin(), next_common_result.end());
next_common_result.clear();
next_common_result_arc.clear();
}
}//const loop
common_result.insert(common_result.begin(), new_common_result.begin(), new_common_result.end());
new_common_result.clear();
remove_all_elements(&del_result, &common_result);
remove_all_elements(&del_result, out_common_result);
free_result_vector(&del_result);
}//pattern loop
out_common_result->insert(out_common_result->end(), common_result.begin(), common_result.end());
common_result.clear();
cantorize_result_vector(out_common_result);
return SC_TRUE;
}
bool ScAddr::operator == (ScAddr const & other) const
{
return SC_ADDR_IS_EQUAL(m_realAddr, other.m_realAddr);
}
void search_typical_sc_neighborhood(sc_addr elem, sc_addr answer, sc_bool sys_off)
{
sc_iterator3 *it1, *it0;
sc_iterator5 *it5;
sc_bool found = SC_FALSE;
// search for keynode_typical_sc_neighborhood
it0 = sc_iterator3_a_a_f_new(sc_type_node | sc_type_const,
sc_type_arc_pos_const_perm,
elem);
while (sc_iterator3_next(it0) == SC_TRUE)
{
if (SC_ADDR_IS_EQUAL(sc_iterator3_value(it0, 0), keynode_typical_sc_neighborhood))
{
found = SC_TRUE;
// iterate input arcs for elem
it1 = sc_iterator3_f_a_a_new(elem,
sc_type_arc_pos_const_perm,
0);
while (sc_iterator3_next(it1) == SC_TRUE)
{
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator3_value(it1, 1)) || IS_SYSTEM_ELEMENT(sc_iterator3_value(it1, 2))))
continue;
appendIntoAnswer(answer, sc_iterator3_value(it1, 1));
appendIntoAnswer(answer, sc_iterator3_value(it1, 2));
}
sc_iterator3_free(it1);
appendIntoAnswer(answer, sc_iterator3_value(it0, 1));
appendIntoAnswer(answer, sc_iterator3_value(it0, 0));
continue;
}
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator3_value(it0, 0)) || IS_SYSTEM_ELEMENT(sc_iterator3_value(it0, 1))))
continue;
it5 = sc_iterator5_f_a_f_a_f_new(keynode_sc_neighborhood,
sc_type_arc_common | sc_type_const,
sc_iterator3_value(it0, 0),
sc_type_arc_pos_const_perm,
keynode_nrel_inclusion);
if (sc_iterator5_next(it5) == SC_TRUE)
{
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator5_value(it5, 1)) || IS_SYSTEM_ELEMENT(sc_iterator5_value(it5, 3))))
continue;
appendIntoAnswer(answer, sc_iterator3_value(it0, 0));
appendIntoAnswer(answer, sc_iterator3_value(it0, 1));
appendIntoAnswer(answer, sc_iterator5_value(it5, 1));
appendIntoAnswer(answer, sc_iterator5_value(it5, 3));
}
sc_iterator5_free(it5);
}
sc_iterator3_free(it0);
if (found == SC_TRUE)
{
appendIntoAnswer(answer, keynode_typical_sc_neighborhood);
}
}
sc_bool system_sys_search_recurse(sc_addr sc_pattern, sc_type_hash pattern, sc_addr curr_const_element, sc_addr curr_pattern_element, sc_type_result *inp_result, sc_type_result_vector *out_common_result, int element_number)
{
sc_type input_element_type;
if (sc_memory_get_element_type(curr_pattern_element, &input_element_type) != SC_RESULT_OK) {return SC_FALSE;}
if (element_number == 2 && (sc_type_node & input_element_type) != sc_type_node)
{
//!Input element is arc
sc_addr const_element, pattern_element, temp, end_pattern_element, end_const_element;
sc_type pattern_element_type, end_pattern_element_type;
sc_memory_get_arc_begin(curr_const_element, &const_element);
sc_memory_get_arc_begin(curr_pattern_element, &pattern_element);
sc_memory_get_arc_end(curr_const_element, &end_const_element);
sc_memory_get_arc_end(curr_pattern_element, &end_pattern_element);
if (sc_memory_get_element_type(pattern_element, &pattern_element_type) != SC_RESULT_OK) {return SC_TRUE;}
if ((sc_type_const & pattern_element_type) == sc_type_const)
{
if (SC_ADDR_IS_NOT_EQUAL(const_element, pattern_element))
{
inp_result->erase(curr_pattern_element);
return SC_TRUE;
}
}
else if (SC_TRUE == find_result_pair_for_var(inp_result, pattern_element, &temp))
{
if (SC_ADDR_IS_NOT_EQUAL(const_element, temp))
{
inp_result->erase(curr_pattern_element);
return SC_TRUE;
}
}
if (sc_memory_get_element_type(end_pattern_element, &end_pattern_element_type) != SC_RESULT_OK) {return SC_TRUE;}
if ((sc_type_const & end_pattern_element_type) == sc_type_const)
{
if (SC_ADDR_IS_NOT_EQUAL(end_const_element, end_pattern_element))
{
inp_result->erase(curr_pattern_element);
return SC_TRUE;
}
}
else if (SC_TRUE == find_result_pair_for_var(inp_result, end_pattern_element, &temp))
{
if (SC_ADDR_IS_NOT_EQUAL(end_const_element, temp))
{
inp_result->erase(curr_pattern_element);
return SC_TRUE;
}
}
if (SC_ADDR_IS_NOT_EQUAL(const_element, pattern_element))
{
inp_result->insert(sc_addr_pair(pattern_element, const_element));
}
pattern.insert(sc_hash_pair(SC_ADDR_LOCAL_TO_INT(curr_pattern_element), curr_pattern_element));
system_sys_search_recurse(sc_pattern, pattern, const_element, pattern_element, inp_result, out_common_result, 2);
return SC_TRUE;
}
sc_addr addr1, addr2, temp, temp1;
int out_arc_count = 0;
sc_type_result_vector common_result;
sc_type_result_vector del_result;
sc_type_result inp_result_copy = *inp_result;
common_result.push_back(inp_result);
//Pattern arcs list
sc_addr_vector pattern_arc_set;
sc_iterator3 *it_pattern_arc = sc_iterator3_f_a_a_new(curr_pattern_element, 0, 0);
if (it_pattern_arc == nullptr) {return SC_FALSE;}
while (SC_TRUE == sc_iterator3_next(it_pattern_arc))
{
addr2 = sc_iterator3_value(it_pattern_arc, 1);
if (pattern.find(SC_ADDR_LOCAL_TO_INT(addr2)) != pattern.end())
{
out_arc_count++;
pattern_arc_set.push_back(addr2);
}
}
sc_iterator3_free(it_pattern_arc);
it_pattern_arc = sc_iterator3_a_a_f_new(0, 0, curr_pattern_element);
if (it_pattern_arc == nullptr) {return SC_FALSE;}
while (SC_TRUE == sc_iterator3_next(it_pattern_arc))
{
addr1 = sc_iterator3_value(it_pattern_arc, 0);
if (SC_ADDR_IS_EQUAL(addr1, sc_pattern)) continue;
addr2 = sc_iterator3_value(it_pattern_arc, 1);
if (pattern.find(SC_ADDR_LOCAL_TO_INT(addr2)) != pattern.end())
{
pattern_arc_set.push_back(addr2);
}
}
sc_iterator3_free(it_pattern_arc);
sc_addr pattern_arc;
sc_addr const_arc;
sc_addr next_pattern_element;
sc_addr next_const_element;
sc_bool out_arc_flag = SC_TRUE;
sc_type_result_vector new_common_result;
sc_type_result_vector next_common_result;
sc_type_result_vector next_common_result_arc;
sc_type_result_vector next_common_result1;
sc_bool pattern_arc_is_const_or_has_value = SC_FALSE;
sc_bool pattern_is_const_or_has_value = SC_FALSE;
//Pattern arcs loop
for (sc_uint i = 0; i < pattern_arc_set.size(); i++)
{
pattern_arc = pattern_arc_set[i];
out_arc_flag = SC_TRUE;
//!check pattern_arc type
sc_type pattern_arc_type;
if (sc_memory_get_element_type(pattern_arc, &pattern_arc_type) != SC_RESULT_OK)
continue;
if ((sc_type_const & pattern_arc_type) == sc_type_const)
continue;
pattern_arc_is_const_or_has_value = SC_FALSE;
pattern_is_const_or_has_value = SC_FALSE;
if (out_arc_count > 0)
{
if (SC_RESULT_OK != sc_memory_get_arc_end(pattern_arc, &next_pattern_element))
continue;
out_arc_count--;
}
else
{
if (SC_RESULT_OK != sc_memory_get_arc_begin(pattern_arc, &next_pattern_element))
continue;
out_arc_flag = SC_FALSE;
}
if (pattern.find(SC_ADDR_LOCAL_TO_INT(next_pattern_element)) == pattern.end())
{
continue;
}
sc_type_result::iterator arc_it = inp_result_copy.find(pattern_arc);
if (arc_it != inp_result_copy.end())
{
const_arc = (*arc_it).second;
pattern_arc_is_const_or_has_value = SC_TRUE;
if (out_arc_flag == SC_TRUE)
{
if (SC_RESULT_OK != sc_memory_get_arc_end(const_arc, &next_const_element))
continue;
}
else
{
if (SC_RESULT_OK != sc_memory_get_arc_begin(const_arc, &next_const_element))
continue;
}
}
//!check next_pattern_element type
sc_type next_pattern_element_type;
if (sc_memory_get_element_type(next_pattern_element, &next_pattern_element_type) != SC_RESULT_OK) {continue;}
if ((sc_type_const & next_pattern_element_type) == sc_type_const)
{
if (pattern_arc_is_const_or_has_value == SC_TRUE)
{
if (!SC_ADDR_IS_EQUAL(next_const_element, next_pattern_element))
{
continue;
}
}
else
{
next_const_element = next_pattern_element;
}
pattern_is_const_or_has_value = SC_TRUE;
}
else
{
sc_type_result::iterator it = inp_result_copy.find(next_pattern_element);
if (it != inp_result_copy.end())
{
if (pattern_arc_is_const_or_has_value == SC_TRUE)
{
if (!SC_ADDR_IS_EQUAL(next_const_element, (*it).second))
{
continue;
}
}
else
{
next_const_element = (*it).second;
}
pattern_is_const_or_has_value = SC_TRUE;
}
}
pattern.erase(SC_ADDR_LOCAL_TO_INT(next_pattern_element));
//!const arc loop
sc_addr_vector const_arc_set;
if (pattern_arc_is_const_or_has_value == SC_FALSE)
{
sc_iterator3 *it_const_arc;
sc_type const_arc_type = ((~sc_type_var & pattern_arc_type) | sc_type_const);
if (out_arc_flag == SC_TRUE)
{
if (pattern_is_const_or_has_value == SC_TRUE)
{
it_const_arc = sc_iterator3_f_a_f_new(curr_const_element, const_arc_type, next_const_element);
}
else
{
sc_type next_const_element_type = ((~sc_type_var & next_pattern_element_type) | sc_type_const);
it_const_arc = sc_iterator3_f_a_a_new(curr_const_element, const_arc_type, next_const_element_type);
}
}
else
{
if (pattern_is_const_or_has_value == SC_TRUE)
{
it_const_arc = sc_iterator3_f_a_f_new(next_const_element, const_arc_type, curr_const_element);
}
else
{
sc_type next_const_element_type = ((~sc_type_var & next_pattern_element_type) | sc_type_const);
it_const_arc = sc_iterator3_a_a_f_new(next_const_element_type, const_arc_type, curr_const_element);
}
}
while (SC_TRUE == sc_iterator3_next(it_const_arc))
{
if (out_arc_flag == SC_FALSE)
{
addr1 = sc_iterator3_value(it_const_arc, 0);
if (SC_ADDR_IS_EQUAL(addr1, sc_pattern))
continue;
}
addr2 = sc_iterator3_value(it_const_arc, 1);
const_arc_set.push_back(addr2);
}
sc_iterator3_free(it_const_arc);
}
else
{
const_arc_set.push_back(const_arc);
}
//printf("ELEMENT %u|%u CONST ARCS COUNT:%d\n", curr_const_element.seg, curr_const_element.offset, const_arc_set.size());
for (sc_uint j = 0; j < const_arc_set.size(); j++)
{
const_arc = const_arc_set[j];
if (pattern_arc_is_const_or_has_value == SC_FALSE)
{
if (out_arc_flag == SC_TRUE)
{
if (SC_RESULT_OK != sc_memory_get_arc_end(const_arc, &next_const_element))
continue;
}
else
{
if (SC_RESULT_OK != sc_memory_get_arc_begin(const_arc, &next_const_element))
continue;
}
}
if (pattern_is_const_or_has_value == SC_FALSE && pattern.find(SC_ADDR_LOCAL_TO_INT(next_const_element)) != pattern.end())
{
continue;
}
//!Results loop
for (sc_uint k = 0; k < common_result.size(); k++)
{
sc_type_result *result = common_result[k];
sc_bool gen_arc = SC_FALSE;
if (pattern_arc_is_const_or_has_value == SC_FALSE)
{
if (SC_TRUE == find_result_pair_for_const(result, const_arc, &temp))
continue;
if (SC_TRUE == find_result_pair_for_var(result, pattern_arc, &temp))
{
//!Gen new result
if (SC_FALSE == pattern_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_const(result, next_const_element, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_pattern_element))
{
continue;
}
sc_type_result *new_result = new sc_type_result();
//class_count++;
(*new_result) = (*result);
new_common_result.push_back(new_result);
result = new_result;
result->erase(pattern_arc);
if (pattern_is_const_or_has_value == SC_FALSE)
{
result->erase(next_pattern_element);
}
}
gen_arc = SC_TRUE;
}
//!Genering pair for 3rd element
if (pattern_is_const_or_has_value == SC_FALSE
&& SC_FALSE == find_result_pair_for_var(result, next_pattern_element, &temp))
{
//!Genering pair for 2nd element
if (gen_arc == SC_TRUE)
{
result->insert(sc_addr_pair(pattern_arc, const_arc));
pattern.erase(SC_ADDR_LOCAL_TO_INT(pattern_arc));
}
result->insert(sc_addr_pair(next_pattern_element, next_const_element));
pattern.erase(SC_ADDR_LOCAL_TO_INT(next_pattern_element));
}
else
{
//!Genering pair for 2nd element
if (gen_arc == SC_TRUE)
{
result->insert(sc_addr_pair(pattern_arc, const_arc));
pattern.erase(SC_ADDR_LOCAL_TO_INT(pattern_arc));
}
}
sc_type_result *recurse_result = new sc_type_result();
(*recurse_result) = (*result);
del_result.push_back(result);
system_sys_search_recurse(sc_pattern, pattern, const_arc, pattern_arc,
recurse_result, &next_common_result_arc, 1);
for (sc_uint kk = 0; kk < next_common_result_arc.size(); kk++)
{
sc_type_result *element_result = next_common_result_arc[kk];
system_sys_search_recurse(sc_pattern, pattern, next_const_element, next_pattern_element,
element_result, &next_common_result1, 2);
if (!next_common_result1.empty())
{
next_common_result.insert(next_common_result.end(),
next_common_result1.begin(), next_common_result1.end());
next_common_result1.clear();
}
else
{
next_common_result.push_back(element_result);
}
}
pattern.insert(sc_hash_pair(SC_ADDR_LOCAL_TO_INT(pattern_arc), pattern_arc));
pattern.insert(sc_hash_pair(SC_ADDR_LOCAL_TO_INT(next_pattern_element), next_pattern_element));
out_common_result->insert(out_common_result->end(), next_common_result.begin(), next_common_result.end());
new_common_result.insert(new_common_result.end(), next_common_result.begin(), next_common_result.end());
cantorize_result_vector(&new_common_result);
next_common_result.clear();
next_common_result_arc.clear();
}
}//const loop
common_result.insert(common_result.begin(), new_common_result.begin(), new_common_result.end());
new_common_result.clear();
remove_all_elements(&del_result, &common_result);
remove_all_elements(&del_result, out_common_result);
free_result_vector(&del_result);
}//pattern loop
out_common_result->insert(out_common_result->end(), common_result.begin(), common_result.end());
common_result.clear();
cantorize_result_vector(out_common_result);
return SC_TRUE;
}
// --------------------------------------------------
sc_result agent_append_idtf(const sc_event *event, sc_addr arg)
{
sc_addr arc, el, link, n;
sc_stream *content = 0;
sc_uint8 *data = 0;
sc_uint32 data_len = 0, read_bytes = 0;
redisReply * reply = null_ptr;
if (sc_memory_get_arc_end(s_default_ctx, arg, &arc) != SC_RESULT_OK)
return SC_RESULT_ERROR;
if (sc_memory_get_arc_begin(s_default_ctx, arg, &n) != SC_RESULT_OK)
return SC_RESULT_ERROR;
// get element
if (sc_memory_get_arc_begin(s_default_ctx, arc, &el) != SC_RESULT_OK)
return SC_RESULT_ERROR;
if (sc_helper_check_arc(s_default_ctx, keynode_system_element, el, sc_type_arc_pos_const_perm) == SC_TRUE)
return SC_RESULT_OK;
// get sc-link
if (sc_memory_get_arc_end(s_default_ctx, arc, &link) != SC_RESULT_OK)
return SC_RESULT_ERROR;
// get content of sc-link
if (sc_memory_get_link_content(s_default_ctx, link, &content) != SC_RESULT_OK)
return SC_RESULT_ERROR;
// get length of data
if (sc_stream_get_length(content, &data_len) != SC_RESULT_OK)
{
sc_stream_free(content);
return SC_RESULT_ERROR;
}
data = g_malloc0(data_len + 1);
if (sc_stream_read_data(content, data, data_len, &read_bytes) != SC_RESULT_OK || read_bytes != data_len)
{
sc_stream_free(content);
g_free(data);
return SC_RESULT_ERROR;
}
sc_result res = SC_RESULT_OK;
sc_addr el_addr = el;
if (SC_ADDR_IS_EQUAL(n, keynode_nrel_idtf))
el_addr = link;
reply = do_sync_redis_command(redisCtx, "SET idtf:%s:%s %b",
SC_ADDR_IS_EQUAL(n, keynode_nrel_main_idtf) ? str_main_idtf_postfix : (SC_ADDR_IS_EQUAL(n, keynode_nrel_idtf) ? str_idtf_postfix : str_sys_idtf_postfix),
data, &el_addr, sizeof(el_addr));
if (reply == 0 || reply->type == REDIS_REPLY_ERROR)
res = SC_RESULT_ERROR;
if (reply)
freeReplyObject(reply);
sc_stream_free(content);
g_free(data);
return res;
}
bool TestFindConnComp::check_find_conn_comp()
{
assert(SC_ADDR_IS_NOT_EMPTY(mGraphAddr));
sc_memory_arc_new(sc_type_arc_pos_const_perm, sc_graph_keynode_not_oriented_graph, mGraphAddr);
sc_addr v1, v2, v3, v4, arc1, arc2, conn_comp_set;
sc_iterator3 *it3;
bool res = false;
if (sc_graph_create_vertex(mGraphAddr, &v1) != SC_RESULT_OK)
return false;
if (sc_graph_create_vertex(mGraphAddr, &v2) != SC_RESULT_OK)
return false;
if (sc_graph_create_vertex(mGraphAddr, &v3) != SC_RESULT_OK)
return false;
if (sc_graph_create_vertex(mGraphAddr, &v4) != SC_RESULT_OK)
return false;
if (sc_graph_create_arc(mGraphAddr, v1, v2, &arc1) != SC_RESULT_OK)
return false;
if (sc_graph_create_arc(mGraphAddr, v2, v3, &arc2) != SC_RESULT_OK)
return false;
if (sc_graph_find_conn_comp(mGraphAddr, &conn_comp_set) != SC_RESULT_OK)
return false;
it3 = sc_iterator3_f_a_a_new(conn_comp_set,
sc_type_arc_pos_const_perm,
sc_type_node);
while (sc_iterator3_next(it3) == SC_TRUE)
{
sc_iterator3 *vert_it3 = sc_iterator3_f_a_a_new(it3->results[2],
sc_type_arc_pos_const_perm,
sc_type_node);
int count = 0;
res = true;
while (sc_iterator3_next(vert_it3) == SC_TRUE)
count++;
sc_iterator3_free(vert_it3);
vert_it3 = sc_iterator3_f_a_a_new(it3->results[2],
sc_type_arc_pos_const_perm,
sc_type_node);
if (count == 3) {
sc_addr vert1, vert2, vert3;
sc_iterator3_next(vert_it3);
vert1 = vert_it3->results[2];
sc_iterator3_next(vert_it3);
vert2 = vert_it3->results[2];
sc_iterator3_next(vert_it3);
vert3 = vert_it3->results[2];
if (sc_iterator3_next(vert_it3) == SC_TRUE)
return false;
if (!SC_ADDR_IS_EQUAL(vert1, v1) &&
!SC_ADDR_IS_EQUAL(vert1, v2) &&
!SC_ADDR_IS_EQUAL(vert1, v3) )
return false;
if (!SC_ADDR_IS_EQUAL(vert2, v1) &&
!SC_ADDR_IS_EQUAL(vert2, v2) &&
!SC_ADDR_IS_EQUAL(vert2, v3) )
return false;
if (!SC_ADDR_IS_EQUAL(vert3, v1) &&
!SC_ADDR_IS_EQUAL(vert3, v2) &&
!SC_ADDR_IS_EQUAL(vert3, v3) )
return false;
if (SC_ADDR_IS_EQUAL(vert1, vert2) ||
SC_ADDR_IS_EQUAL(vert2, vert3) ||
SC_ADDR_IS_EQUAL(vert1, vert3) )
return false;
}
else if (count == 1)
{
sc_addr vert;
sc_iterator3_next(vert_it3);
vert = vert_it3->results[2];
if (sc_iterator3_next(vert_it3) == SC_TRUE)
return false;
if (!SC_ADDR_IS_EQUAL(vert, v4))
return false;
}
else return false;
sc_iterator3_free(vert_it3);
}
sc_iterator3_free(it3);
return res;
}
sc_result agent_search_links_of_relation_connected_with_element(const sc_event *event, sc_addr arg)
{
sc_addr question, answer, param_elem, param_rel;
sc_iterator3 *it1, *it2, *it3, *it4;
sc_iterator5 *it5, *it_order;
sc_type el_type;
sc_bool sys_off = SC_TRUE;
sc_bool param_elem_found = SC_FALSE, param_rel_found = SC_FALSE, found = SC_FALSE;
if (!sc_memory_get_arc_end(arg, &question))
return SC_RESULT_ERROR_INVALID_PARAMS;
// check question type
if (sc_helper_check_arc(keynode_question_search_links_of_relation_connected_with_element, question, sc_type_arc_pos_const_perm) == SC_FALSE)
return SC_RESULT_ERROR_INVALID_TYPE;
answer = create_answer_node();
// get question arguments
it5 = sc_iterator5_f_a_a_a_a_new(question,
sc_type_arc_pos_const_perm,
0,
sc_type_arc_pos_const_perm,
sc_type_node | sc_type_const);
while (sc_iterator5_next(it5) == SC_TRUE)
{
if (SC_ADDR_IS_EQUAL(sc_iterator5_value(it5, 4), keynode_rrel_1))
{
param_elem = sc_iterator5_value(it5, 2);
param_elem_found = SC_TRUE;
continue;
}
if (SC_ADDR_IS_EQUAL(sc_iterator5_value(it5, 4), keynode_rrel_2))
{
param_rel = sc_iterator5_value(it5, 2);
param_rel_found = SC_TRUE;
continue;
}
}
sc_iterator5_free(it5);
if (param_elem_found == SC_FALSE || param_rel_found == SC_FALSE)
{
return SC_RESULT_ERROR;
}
appendIntoAnswer(answer, param_elem);
if (IS_SYSTEM_ELEMENT(param_elem) || IS_SYSTEM_ELEMENT(param_rel))
sys_off = SC_FALSE;
if (SC_TRUE == sc_helper_check_arc(keynode_quasybinary_relation, param_rel, sc_type_arc_pos_const_perm))
{
// Search subclasses in quasybinary relation
// Iterate input arcs of quasybinary relation
it5 = sc_iterator5_a_a_f_a_f_new(sc_type_const,
sc_type_const | sc_type_arc_common,
param_elem,
sc_type_arc_pos_const_perm,
param_rel);
while (sc_iterator5_next(it5) == SC_TRUE)
{
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator5_value(it5, 0))
|| IS_SYSTEM_ELEMENT(sc_iterator5_value(it5, 1))
|| IS_SYSTEM_ELEMENT(sc_iterator5_value(it5, 3))))
continue;
found = SC_TRUE;
appendIntoAnswer(answer, sc_iterator5_value(it5, 0));
appendIntoAnswer(answer, sc_iterator5_value(it5, 1));
appendIntoAnswer(answer, sc_iterator5_value(it5, 3));
search_arc_components(sc_iterator5_value(it5, 0), answer, sys_off);
// Iterate subclasses in quasybinary relation
it1 = sc_iterator3_f_a_a_new(sc_iterator5_value(it5, 0),
sc_type_arc_pos_const_perm,
sc_type_const | sc_type_node);
while (sc_iterator3_next(it1) == SC_TRUE)
{
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator3_value(it1, 1))
|| IS_SYSTEM_ELEMENT(sc_iterator3_value(it1, 2))))
continue;
appendIntoAnswer(answer, sc_iterator3_value(it1, 1));
appendIntoAnswer(answer, sc_iterator3_value(it1, 2));
search_arc_components(sc_iterator3_value(it1, 2), answer, sys_off);
// iterate order relations between elements
it_order = sc_iterator5_f_a_a_a_a_new(sc_iterator3_value(it1, 2),
sc_type_arc_common | sc_type_const,
sc_type_node | sc_type_const,
sc_type_arc_pos_const_perm,
sc_type_node | sc_type_const);
while (sc_iterator5_next(it_order) == SC_TRUE)
{
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator5_value(it_order, 1)) || IS_SYSTEM_ELEMENT(sc_iterator5_value(it_order, 2))
|| IS_SYSTEM_ELEMENT(sc_iterator5_value(it_order, 3)) || IS_SYSTEM_ELEMENT(sc_iterator5_value(it_order, 4))))
continue;
if (SC_FALSE == sc_helper_check_arc(keynode_order_relation, sc_iterator5_value(it_order, 4), sc_type_arc_pos_const_perm))
continue;
if (SC_FALSE == sc_helper_check_arc(sc_iterator5_value(it5, 0), sc_iterator5_value(it_order, 2), sc_type_arc_pos_const_perm))
continue;
appendIntoAnswer(answer, sc_iterator5_value(it_order, 1));
appendIntoAnswer(answer, sc_iterator5_value(it_order, 2));
appendIntoAnswer(answer, sc_iterator5_value(it_order, 3));
appendIntoAnswer(answer, sc_iterator5_value(it_order, 4));
}
sc_iterator5_free(it_order);
// iterate roles of element in link
it2 = sc_iterator3_a_a_f_new(sc_type_node | sc_type_const,
sc_type_arc_pos_const_perm,
sc_iterator3_value(it1, 1));
while (sc_iterator3_next(it2) == SC_TRUE)
{
sc_memory_get_element_type(sc_iterator3_value(it2, 0), &el_type);
if (!(el_type & sc_type_node_role))
continue;
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator3_value(it2, 0))
|| IS_SYSTEM_ELEMENT(sc_iterator3_value(it2, 1))))
continue;
appendIntoAnswer(answer, sc_iterator3_value(it2, 0));
appendIntoAnswer(answer, sc_iterator3_value(it2, 1));
}
sc_iterator3_free(it2);
}
sc_iterator3_free(it1);
}
sc_iterator5_free(it5);
// Iterate input arcs of quasybinary relation
it1 = sc_iterator3_a_a_f_new(sc_type_const | sc_type_node,
sc_type_arc_pos_const_perm,
param_elem);
while (sc_iterator3_next(it1) == SC_TRUE)
{
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator3_value(it1, 0))
|| IS_SYSTEM_ELEMENT(sc_iterator3_value(it1, 1))))
continue;
// search all parents in quasybinary relation
it5 = sc_iterator5_f_a_a_a_f_new(sc_iterator3_value(it1, 0),
sc_type_arc_common | sc_type_const,
sc_type_node | sc_type_const,
sc_type_arc_pos_const_perm,
param_rel);
if (sc_iterator5_next(it5) == SC_TRUE)
{
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator5_value(it5, 1))
|| IS_SYSTEM_ELEMENT(sc_iterator5_value(it5, 2))
|| IS_SYSTEM_ELEMENT(sc_iterator5_value(it5, 3))))
continue;
appendIntoAnswer(answer, sc_iterator5_value(it5, 1));
appendIntoAnswer(answer, sc_iterator5_value(it5, 2));
appendIntoAnswer(answer, sc_iterator5_value(it5, 3));
search_arc_components(sc_iterator5_value(it5, 2), answer, sys_off);
appendIntoAnswer(answer, sc_iterator3_value(it1, 0));
appendIntoAnswer(answer, sc_iterator3_value(it1, 1));
search_arc_components(sc_iterator3_value(it1, 0), answer, sys_off);
}
sc_iterator5_free(it5);
}
sc_iterator3_free(it1);
}
else
{
// Iterate output arcs of given relation
it5 = sc_iterator5_f_a_a_a_f_new(param_elem,
sc_type_const,
sc_type_const,
sc_type_arc_pos_const_perm,
param_rel);
while (sc_iterator5_next(it5) == SC_TRUE)
{
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator5_value(it5, 1))
|| IS_SYSTEM_ELEMENT(sc_iterator5_value(it5, 2))
|| IS_SYSTEM_ELEMENT(sc_iterator5_value(it5, 3))))
continue;
found = SC_TRUE;
appendIntoAnswer(answer, sc_iterator5_value(it5, 1));
appendIntoAnswer(answer, sc_iterator5_value(it5, 2));
appendIntoAnswer(answer, sc_iterator5_value(it5, 3));
search_arc_components(sc_iterator5_value(it5, 2), answer, sys_off);
}
sc_iterator5_free(it5);
// Iterate input arcs of given relation
it5 = sc_iterator5_a_a_f_a_f_new(sc_type_const,
sc_type_const,
param_elem,
sc_type_arc_pos_const_perm,
param_rel);
while (sc_iterator5_next(it5) == SC_TRUE)
{
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator5_value(it5, 0))
|| IS_SYSTEM_ELEMENT(sc_iterator5_value(it5, 1))
|| IS_SYSTEM_ELEMENT(sc_iterator5_value(it5, 3))))
continue;
appendIntoAnswer(answer, sc_iterator5_value(it5, 0));
appendIntoAnswer(answer, sc_iterator5_value(it5, 1));
appendIntoAnswer(answer, sc_iterator5_value(it5, 3));
search_arc_components(sc_iterator5_value(it5, 0), answer, sys_off);
}
sc_iterator5_free(it5);
// Iterate input arcs for input element
it1 = sc_iterator3_a_a_f_new(sc_type_const,
sc_type_arc_pos_const_perm,
param_elem);
while (sc_iterator3_next(it1) == SC_TRUE)
{
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator3_value(it1, 0))
|| IS_SYSTEM_ELEMENT(sc_iterator3_value(it1, 1))))
continue;
// Iterate input arcs for input element
it2 = sc_iterator3_f_a_f_new(param_rel,
sc_type_arc_pos_const_perm,
sc_iterator3_value(it1, 0));
if (sc_iterator3_next(it2) == SC_TRUE)
{
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator3_value(it2, 1))))
continue;
appendIntoAnswer(answer, sc_iterator3_value(it2, 1));
appendIntoAnswer(answer, sc_iterator3_value(it1, 0));
// Iterate elements of fonnd link of given relation
it3 = sc_iterator3_f_a_a_new(sc_iterator3_value(it1, 0),
sc_type_arc_pos_const_perm,
sc_type_const);
while (sc_iterator3_next(it3) == SC_TRUE)
{
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator3_value(it3, 1))
|| IS_SYSTEM_ELEMENT(sc_iterator3_value(it3, 2))))
continue;
appendIntoAnswer(answer, sc_iterator3_value(it3, 1));
appendIntoAnswer(answer, sc_iterator3_value(it3, 2));
search_arc_components(sc_iterator3_value(it3, 2), answer, sys_off);
// Iterate role relations
it4 = sc_iterator3_a_a_f_new(sc_type_const | sc_type_node,
sc_type_arc_pos_const_perm,
sc_iterator3_value(it3, 1));
while (sc_iterator3_next(it4) == SC_TRUE)
{
if (sys_off == SC_TRUE && (IS_SYSTEM_ELEMENT(sc_iterator3_value(it4, 0))
|| IS_SYSTEM_ELEMENT(sc_iterator3_value(it4, 1))))
continue;
appendIntoAnswer(answer, sc_iterator3_value(it4, 0));
appendIntoAnswer(answer, sc_iterator3_value(it4, 1));
search_arc_components(sc_iterator3_value(it4, 0), answer, sys_off);
}
sc_iterator3_free(it4);
}
sc_iterator3_free(it3);
}
sc_iterator3_free(it2);
}
sc_iterator3_free(it1);
}
if (found == SC_TRUE)
{
appendIntoAnswer(answer, param_rel);
}
connect_answer_to_question(question, answer);
finish_question(question);
return SC_RESULT_OK;
}
gboolean events_table_equal_func(gconstpointer a, gconstpointer b)
{
const sc_addr *addr1 = (const sc_addr*)a;
const sc_addr *addr2 = (const sc_addr*)b;
return SC_ADDR_IS_EQUAL(*addr1, *addr2);
}
