C++ Answer::GetVariableMap方法代码示例

std::list<Argument*> KnowledgeBase::Ask(const Argument& arg,
                                        bool checkForDoubles)
{
  std::list<Argument*> out;

  // get answer
  Answer *ans = GetAnswer(arg, VariableMap(), std::set<size_t>());
  // get all the valid substitution and add them to list

  if(!checkForDoubles)
  {
    while(ans->next())
    {
      Argument* temp = Unify::GetSubstitutedArgument(&arg, ans->GetVariableMap());
      out.push_back(temp);
    }
  }
  else
  {
    std::set<std::string> str_ans;
    while(ans->next())
    {
      Argument* temp = Unify::GetSubstitutedArgument(&arg, ans->GetVariableMap());
      std::stringstream stream;
      stream << *temp;

      //SymbolDecodeStream sds(symbol_table);
      //sds << *temp << endl;

      if(str_ans.find(stream.str()) == str_ans.end())
      {
        out.push_back(temp);
        str_ans.insert(stream.str());
      }
      else delete temp;
    }
  }
  // delete answer
  delete ans;

  return out;
}

void KIFFlattener::FlattenRelation(const DGraphNode* n,
                                   const KnowledgeBase& all_kb,
                                   const std::set<size_t>& state_independent,
                                   KnowledgeBase& m_kb,
                                   std::list<Clause>& f_clauses,
                                   std::list<Fact>& f_facts)
{
  //compute signature of relation
  const size_t& sig = n->id;

  // get all the facts and clauses associated with this signature
  const KnowledgeBase::FactList* facts = all_kb.GetFacts(sig);
  const KnowledgeBase::ClauseList* p_clauses = all_kb.GetClauses(sig);

  if(p_clauses == NULL)
  {
    if(facts != NULL)
      for(KnowledgeBase::FactList::const_iterator it = facts->begin();
                                                      it != facts->end();it++)
      {
        f_facts.push_back(*it);
        m_kb.Tell(*it);
      }
    return;
  }

  const KnowledgeBase::ClauseList& clauses = *p_clauses;

  // to store the heads of the flattened clauses
  // these will be added later to temporary knowledge base
  list<Argument*> f_heads;

  // start flattening clauses
  for(list<Clause>::const_iterator it = clauses.begin();it != clauses.end();it++)
  {
    // if the clause is already ground add it directly
    // add its head to heads list
    if((*it).IsGround())
    {
      Clause* to_add = new Clause(*it);
      f_clauses.push_back(*to_add);
      f_heads.push_back(to_add->head);
      to_add->head = NULL;
      delete to_add;
      continue;
    }

    // pre-process the clause
    // adjust the extra variables which are present in body but not head
    // adjust 'not' relation appropriately
    Clause* p_clause = ProcessClause(*it, state_independent);

    // add the processed clause temporarily to knowledge base
    size_t c_index = m_kb.Tell(*p_clause);

    VariableMap h_v_map;
    Argument* question = SpecialArgCopy2(p_clause->head, h_v_map);

    // after adding the head of the clause will be the question to ask
    Answer* ans = m_kb.GetAnswer(*question, VariableMap(), set<size_t>());


    while(ans->next())
    {
      VariableMap ans_v_map = ans->GetVariableMap();
      for(auto va : h_v_map)
        ans_v_map.insert(va);

      // compute the answer with substitution
      Clause* to_add = Unify::GetSubstitutedClause(&(*it), ans_v_map);

      // remove all the occurrences of data relations
      Clause* temp = RemoveDataFromClause(to_add, state_independent);

      // check whether clause can be converted to fact after data relations removal
      if(temp == NULL)
      {
        Argument* h = to_add->head;
        to_add->head = NULL;
        delete to_add;
        f_facts.push_back(*h);
        f_facts.back().loc = (*it).loc;
        f_facts.back().isLocation = (*it).isLocation;
        f_heads.push_back(h);
      }
      else
      {
        f_clauses.push_back(*temp);
        f_clauses.back().loc = (*it).loc;
        f_clauses.back().isLocation = (*it).isLocation;
        f_heads.push_back(temp->head);
        temp->head = NULL;
        delete temp;
      }
    }

    // delete answer
    delete ans;

    // erase the temporary knowledge from knowledge base
//.........这里部分代码省略.........