liboaa.c

来自「SRI international 发布的OAA框架软件」· C语言 代码 · 共 1,973 行 · 第 1/5 页

 * Store cached solutionsin the oaa_cache table.
 */
int oaa_assert_cache(ICLTerm *goal, ICLTerm *solutions) {
  if(oaa_cache == NULL) {
    oaa_cache = dict_new(oaa_compare_terms, (void *)icl_FreeTermSingle);
  }
  dict_put_nonunique(oaa_cache, (void *)icl_CopyTerm(goal), (void *)solutions);
  return TRUE;
}

/**
 * Retrieves the cached solutions without retracting them.
 */
int oaa_retrieve_cache(ICLTerm *goal, ICLTerm **solutions) {
  if(oaa_cache != NULL) {
    *solutions = (ICLTerm *)dict_get(oaa_cache, (void *)goal);
    if(*solutions != NULL) {
      return TRUE;
    }
  }
  return FALSE;
}

/**
 * Retract all cached solutions with goals that unify with the
 * parameter.
 */
int oaa_retractall_cache(ICLTerm *goal) {

  if(oaa_cache != NULL) {
    int    num_found = 0;
    int    i = 0;
    void **values = dict_remove_all(oaa_cache, goal, &num_found);

    if (values != NULL) {
      for (i=0; i<num_found; i++) {
        free((values[i]));
      }
      free(values);
      return TRUE;
    }
  }
  return FALSE;
}

/**
 * Retrieves all the cached solutions without retracting them.
 */
int oaa_retrieve_all_cache(ICLTerm *goal, ICLTerm **solutions) {
  int i = 0, n = 0, inited = FALSE, res = FALSE;
  if(oaa_cache != NULL) {
    /* loop through cache table */
    for(i=0, n=oaa_cache->size; i<n; i++) {
      ICLTerm *test_goal = oaa_cache->key[i];
      /* compare keys */
      if(!(oaa_cache->compar)((void *)goal, (void *)test_goal)) {
        ICLTerm *tmpsoln = oaa_cache->value[i];
        /* add tmpsoln to solutions list */
        if(inited)
          icl_AddToList(*solutions, tmpsoln, TRUE);
        else {
          *solutions = icl_NewList(icl_NewCons(tmpsoln, NULL));
          inited = TRUE;
        }
        res = TRUE;
      }
    }
  }
  return res;
}

/**
 * Retract the first cached solutions associated with this goal.
 */
int oaa_retract_cache(ICLTerm *goal, ICLTerm **solutions) {
  if(oaa_cache != NULL) {
    *solutions = (ICLTerm *)dict_remove(oaa_cache, (void *)goal);
    if(*solutions != NULL) {
      return TRUE;
    }
  }
  return FALSE;
}

/**
 * Store a list of events with an associated id.
 */
int oaa_assert_waiting_for(ICLTerm *id, ICLTerm *event_list) {
  if(oaa_waiting_for == NULL)
    oaa_waiting_for = dict_new(oaa_compare_terms, (void *)icl_FreeTermSingle);
  dict_put(oaa_waiting_for, (void *)icl_CopyTerm(id), (void *)event_list);
  return TRUE;
}

/**
 * Retrieves the event list for a particular id without retracting it.
 */
int oaa_retrieve_waiting_for(ICLTerm *id, ICLTerm **event_list) {
  if(oaa_waiting_for != NULL) {
    *event_list = (ICLTerm *)dict_get(oaa_waiting_for, (void *)id);
    if(*event_list != NULL) {
      return TRUE;
    }
  }
  return FALSE;
}

/**
 * Retrieves all event lists for a particular id term.
 */
int oaa_retrieve_all_waiting_for(ICLTerm *id, ICLTerm **event_list) {
  int res = FALSE, inited = FALSE, i = 0, n = 0;
  if(oaa_waiting_for != NULL) {
    for(i=0, n=oaa_waiting_for->size; i<n; i++) {
      ICLTerm *test_id = oaa_waiting_for->key[i];
      /* compare keys */
      if((oaa_waiting_for->compar)((void *)id, (void *)test_id)) {
        ICLTerm *tmpel = oaa_waiting_for->value[i];
        /* add tmpel to events list */
        if(inited) {
          icl_AppendCopy(*event_list, tmpel);
        }
        else {
          *event_list = icl_CopyTerm(tmpel);
          inited = TRUE;
        }
        res = TRUE;
      }
    }
  }
  return res;
}


/**
 * Retract the first event list associated with this id.
 */
int oaa_retract_waiting_for(ICLTerm *id, ICLTerm **event_list) {
  if(oaa_waiting_for != NULL) {
    *event_list = (ICLTerm *)dict_remove(oaa_waiting_for, (void *)id);
    if(*event_list != NULL) {
      return TRUE;
    }
  }
  return FALSE;
}

/**
 * Store an event.
 */
int oaa_assert_waiting_event(ICLTerm *event){
  if(oaa_waiting_event == NULL) {
    oaa_waiting_event = dict_new(oaa_compare_terms, (void *)icl_FreeTermSingle);
  }
  /* store term under both key and value */
  dict_put(oaa_waiting_event, (void *)icl_CopyTerm(event), (void *)icl_CopyTerm(event));
  return TRUE;
}

/**
 * Retrieves all waiting events.
 */
int oaa_retrieve_all_waiting_events(ICLTerm **event_list) {
  int i = 0, n = 0;
  *event_list = icl_NewList(NULL);
  if(oaa_waiting_event != NULL) {
    for(i=0, n=oaa_waiting_event->size; i<n; i++) {
      ICLTerm *event = oaa_waiting_event->value[i];
      /* add event to events list */
      icl_AddToList(*event_list, icl_CopyTerm(event), TRUE);
    }
  }
  return TRUE;
}


/**
 * Retract the first event list associated with this id.
 */
int oaa_retract_waiting_event(ICLTerm *event) {
  ICLTerm *retracted = NULL;
  if(oaa_waiting_event != NULL) {
    retracted = (ICLTerm *)dict_remove(oaa_waiting_event, (void *)event);
    if(retracted != NULL) {
      icl_Free(retracted);
      return TRUE;
    }
  }
  return FALSE;
}

/**
 * Initializes and returns value for oaa_built_in_solvables_term
 */
ICLTerm * oaa_built_in_solvables()
{
  if (oaa_built_in_solvables_term == NULL) {
    oaa_built_in_solvables_term =
      icl_NewTermFromString(oaa_built_in_solvables_str);
  }

  return oaa_built_in_solvables_term;
}


/*****************************************************************************
 * Forward function declarations
 *****************************************************************************/

EXTERN void icl_param_standard_form(ICLTerm *param, ICLListType **SList);
EXTERN int icl_param_default(ICLTerm *param, ICLTerm **result);
EXTERN void icl_perm_standard_form(ICLTerm *perm, ICLTerm **Standard);
EXTERN int icl_perm_default(ICLTerm *perm, ICLTerm **result);
EXTERN int icl_address_to_id(ICLTerm* inFullAddress, ICLTerm** result);
EXTERN int icl_standardize_address(ICLTerm *Addr, ICLTerm **StandardAddr);
EXTERN int icl_standardize_solvables(ICLTerm *ShorthandSolvables, ICLTerm **StandardSolvables);
EXTERN int icl_readable_solvables(ICLTerm *StandardSolvables, ICLTerm **ShorthandSolvables);
EXTERN int icl_readable_solvable(ICLTerm *StandardSolvable, ICLTerm **ShorthandSolvable);
EXTERN int oaa_goal_in_solvables(ICLTerm *Goal, ICLTerm *Solvables, ICLTerm **MatchedSolvable);
EXTERN int oaa_call_callback(char* callback_id, ICLTerm *goal, ICLTerm *params, ICLTerm* solutions);
EXTERN int oaa_sort_and_get_event(ICLTerm *EventList, int LowestPriority, ICLTerm **Event, ICLTerm **Params);
EXTERN int oaa_extract_event(ICLTerm *raw_event, ICLTerm **content, ICLTerm **params);

EXTERN int oaa_class(char *class);
EXTERN char *oaa_name_string(void);
EXTERN int oaa_Id(ICLTerm **Id);
EXTERN ICLTerm *perm_default_list();
EXTERN ICLTerm *param_default_list();
EXTERN int oaa_priority_compare(ICLTerm *Elt1, ICLTerm *Elt2);
EXTERN int oaa_extract_event_param(ICLTerm *event, char *param,
                                   ICLTerm **result);
EXTERN int oaa_choose_event(int LowestPriority, ICLTerm *EventList,
                            ICLTerm **Event);
EXTERN int oaa_read_all_events(double TimeOut, ICLListType **Events,
                               int *FlushPriority);
EXTERN int oaa_select_event(double timeout, ICLTerm **event);
EXTERN int oaa_flush_events(ICLTerm **original_events, int flush_priority);
EXTERN int oaa_data_in_solvables(ICLTerm *Clause, ICLTerm *Solvables,
                                 ICLTerm *Perm, ICLTerm **MatchedSolvable);
EXTERN int oaa_distribute_perms(ICLTerm *solvables, ICLTerm *common_perms,
                                ICLTerm **new_solvables);
EXTERN int oaa_distribute_params(ICLTerm *solvables, ICLTerm *common_params,
                                 ICLTerm **new_solvables);

EXTERN int oaa_declare_aux(char *mode, ICLTerm *solvables, ICLTerm *params,
                           ICLTerm **declared_solvables);
EXTERN int icl_standardize_addressee(ICLTerm *Addr, ICLTerm **StandardAddr);
EXTERN int oaa_address_to_comm_id(ICLTerm *inAddress, char **commId);
EXTERN char* new_goal_id();
EXTERN char* new_trigger_id();
EXTERN int select_elements(ICLTerm *list, int (*test_function)(ICLTerm*),
                           ICLTerm** result);
EXTERN int oaa_handle_user_event(ICLTerm *event,  ICLTerm *params,
                                 ICLTerm **solutions);
EXTERN int oaa_exec_event(ICLTerm *goal, ICLTerm *params, ICLTerm **solutions);
EXTERN int oaa_cont_solve(ICLTerm* goal_id, ICLTerm *goal,
                          ICLTerm *global_params, ICLTerm **solutions,
                          ICLTerm **out_params);
EXTERN ICLTerm *remove_element(ICLTerm *elt, ICLTerm *list, ICLTerm **rest);
EXTERN int oaa_cont_poll_until_all_events(ICLTerm *event_list, ICLTerm *event,
                                          ICLTerm *params, int priority,
                                          ICLTerm **solutions);
EXTERN int oaa_handle_ev_update_data(ICLTerm *goal, ICLTerm *params);

EXTERN int oaa_ComTraceMsg(char *format_string, ...);
EXTERN int oaa_flush_notification(ICLTerm *raw_event);
EXTERN int oaa_event_param(ICLTerm *event, ICLTerm *param);
EXTERN int oaa_get_flush_notify(ICLTerm *event, ICLTerm **notify_event);
EXTERN int oaa_translate_incoming_event(ICLTerm *raw_event_in, ICLTerm **raw_event_out);
EXTERN int oaa_unwrap_event(ICLTerm *in_event, char **connection_id, ICLTerm **out_event);
EXTERN int oaa_from_param(ICLTerm *event);
EXTERN int oaa_content_fac_id(ICLTerm *content, ICLTerm **id);
EXTERN int oaa_is_parent_fac_id(char *connection_id, ICLTerm **id);
EXTERN int oaa_is_oaa_id(char *connection_id, ICLTerm **id);
EXTERN int oaa_remove_data_owned_by(ICLTerm *id);
EXTERN int oaa_handle_ev_update_trigger(ICLTerm *goal, ICLTerm *params);
EXTERN int oaa_handle_ev_solve(ICLTerm *goal, ICLTerm *params, ICLTerm **solutions);
EXTERN int oaa_handle_ev_solved(ICLTerm *goal, ICLTerm *params);
EXTERN int oaa_add_data_local(ICLTerm *clause1, ICLTerm *params);
EXTERN int oaa_remove_data_local(ICLTerm *clause1, ICLTerm *params);
EXTERN int oaa_replace_data_local(ICLTerm *clause1_in, ICLTerm *params);
EXTERN int oaa_Inform(ICLTerm *type_info, char *format_string, ICLTerm *args);
EXTERN int oaa_solve_local(ICLTerm *full_goal, ICLTerm *params, ICLTerm **solutions);
EXTERN int oaa_turn_on_debug();
EXTERN int oaa_turn_off_debug();
EXTERN int predicate_skeleton(ICLTerm *goal, ICLTerm **skeleton);
EXTERN int oaa_is_waiting_for(ICLTerm *event);
EXTERN int oaa_translate_outgoing_event(ICLTerm *event, ICLTerm *dest_id,
                                        ICLTerm **new_event);
EXTERN int oaa_poll_until_event(ICLTerm *event, ICLTerm **solution);
EXTERN int oaa_declare_local(char *mode, ICLTerm *solvable0, ICLTerm *params,
                             ICLTerm **returned_solvables);
EXTERN int solvables_to_be_added(ICLTerm *solvables, ICLTerm *current,
                                 ICLTerm **ok_solvables);
EXTERN int solvables_to_be_removed(ICLTerm *solvables, ICLTerm *current,
                                   ICLTerm **ok_solvables);
EXTERN int oaa_remove_solvables_data(ICLTerm *solvables);
EXTERN int icl_subtract(ICLTerm *list1, ICLTerm *list2, ICLTerm **result);
EXTERN int replace_element(ICLTerm *elt, ICLTerm *old_list, ICLTerm *new,
                           ICLTerm **new_list);
EXTERN int oaa_update(char *mode, ICLTerm *clause, ICLTerm *initial_params,
                      ICLTerm **out_params);
EXTERN int oaa_retractall(ICLTerm *clause, ICLTerm *owner, ICLTerm *callback);
EXTERN int retract_all(ICLTerm *clause);
EXTERN int oaa_data_owner(ICLTerm *params, ICLTerm **owner);
EXTERN int oaa_asserta(ICLTerm *clause, ICLTerm *owner, ICLTerm *callback);
EXTERN int oaa_assertz(ICLTerm *clause, ICLTerm *owner, ICLTerm *callback);
EXTERN int oaa_retract(ICLTerm *clause, ICLTerm *owner, ICLTerm *callback);
EXTERN int oaa_replace_all(ICLTerm *clause1, ICLTerm *clause2, ICLTerm *owner,
                           ICLTerm *callback);
EXTERN int oaa_poll_until_event_priority(ICLTerm *event, int priority,
                                         ICLTerm **solutions);
EXTERN int oaa_poll_until_all_events(ICLTerm *event_list, int priority,
                                     ICLTerm **solutions);
EXTERN int oaa_grab_waiting_event(ICLTerm *event_list, ICLTerm **event);
EXTERN int replace_all(ICLTerm *clause1, ICLTerm *clause2);

// added for direct_connect
static int ensure_direct_connection(ICLTerm *AgentAddress, char **ConnectionId);
static int isClientConnection(char *ConnectionId);
static char* new_direct_connection_id(void);
static int oaa_cont_solve_direct(ICLTerm* goal_id,
                                 ICLTerm *goal,
                                 ICLTerm *SingleAgentAddress,
                                 ICLTerm *global_params,
                                 ICLTerm **solutions,
                                 ICLTerm **out_params);
static int oaa_cont_plan(ICLTerm* goal_id,
                         ICLTerm *templateGoal,
                         ICLTerm *actualGoal,
                         ICLTerm *global_params,
                         ICLTerm **solutions,
                         ICLTerm **out_params);
static int oaa_get_single_address_from_plan(ICLTerm *ev_planned_term,
                                            ICLTerm **SingleAgentAddress);
static int oaa_handshake(char *ConnectionId, char *InitialAgentName, ICLTerm *Params);

/*****************************************************************************
 * Initialization and connection functions
 *****************************************************************************/


/** * Retrieve local host name.
 * returns: NULL if can't calculate host
 ****************************************************************************/
char *getlocalhostname(void) {
  char buf[MAXHOSTNAMELEN + 1];
  if (gethostname(buf, MAXHOSTNAMELEN) == 0) { /* success! */
    return(strdup(buf));
  }
  else return(NULL);
}


/**
 * Once a comm link is established, either as a client to a Facilitator
 * or as a server for other agents, oaa_Register will setup and registration
 * information for this agent.
 * <p>The following information is stored about the current connection,
 *   accessible through com_GetInfo(ConnectionId, Info):</p>
 *<ul>
 *       <li>oaa_name(Name)  : the name of the current agent</li>
 *       <li>oaa_id(Id)      : the Id for the agent</li>
 *       <li>connection(C)   : system-level communications handle
 *                           (e.g., socket number)</li>
 *</ul>
 *<p>if connecting as client, this is also available:</p>
 *<ul>
 *       <li>fac_id(Id)      : the Facilitator's Id</li>
 *       <li>fac_name(Name)  : the Facilitator's name</li>
 *       <li>fac_lang(L)     : the Facilitator's language</li>
 *       <li>fac_version(V)  : the version of the Facilitator's agent library</li>
 *</ul>
 *<p>In addition, the following predicates are written to parent Facilitator,
 *   or locally if the ConnectionId is a server connection:<p>
 *
 *<ul>
 *       <li>agent_host(Id, Name, Host)</li>
 *</ul>
 *
 *<p>Solvables are also written using oaa_Declare().</p>
 *
 * @param ConnectionId the symbolic connection Id (client or server connection)
 * @param AgentName  the name of the agent
 * @param Solvables solvable list
 *
 */
EXPORT_MSCPP
int EXPORT_BORLAND
oaa_Register(char *ConnectionId, char *AgentName, ICLTerm *Solvables)
{
  ICLTerm *Params = NULL;
  ICLTerm *t1   = NULL;
  ICLTerm *t2   = NULL;
  ICLTerm *t3   = NULL;