reporter.cpp

一个非常好的人工智能开发工具开源软件

  send(message);

  // Initialize the Assignement index
  d_assignmentIndex = 0;
  // Packets are enqueued after processing the Candidate
  if (!(d_candidateIndex < MAX_NUMBER_OF_CANDIDATES)) {
     char message[MAX_MSG_LENGTH];
     sprintf(message, "In beginCandidate, candidate index %d equals or exceeds MAX_NUMBER_OF_CANDIDATES\n", 
                       d_candidateIndex);
     ExceptionAction::ReporterFailure(message);
  }
  // Add this Candidate to the telemetry packet
  d_l2ResultMsg.candidateSetData.numberOfCandidates++;
  CandidateData& candidateData =
    d_l2ResultMsg.candidateSetData.candidates[d_candidateIndex];
  candidateData.candidateId = candidateIndex;
  candidateData.numberOfAssignments = 0; // will be incremented
}


void Reporter::endCandidate() {
  // report
  char message[MAX_MSG_LENGTH];
  sprintf(message, "%i", REP_END_CANDIDATE);
  send(message);

  // If Candidates weren't being truncated, test whether the Candidate array
  // is full. If so, send the packet and re-initialize.

  // Reset the Assignment index
  d_assignmentIndex = 0;
}


unsigned long Reporter::encodeAssignment(unsigned int variableID,
					 unsigned int valueIndex,
					 unsigned int weight) {
  unsigned long encodedAssignment = 0;
  const bool success =
    setCandidateModeVariableId(&encodedAssignment, variableID) &&
    setCandidateModeVariableValue(&encodedAssignment, valueIndex) &&
    setCandidateAssignmentRank(&encodedAssignment, weight);
  if (!success) {
     char message[MAX_MSG_LENGTH];
     sprintf(message, "encodeAssignment for variableID %d, valueIndex %d, weight %d\n", 
                       variableID, valueIndex, weight);
     ExceptionAction::ReporterFailure(message);
  }
  return encodedAssignment;
}


unsigned short Reporter::encodeModeAssignment(unsigned int variableID,
					      unsigned int valueIndex) {
  unsigned short encodedModeAssignment = 0;
  const bool success =
    setModeVariableValue(&encodedModeAssignment, valueIndex) &&
    setModeVariableId(&encodedModeAssignment, variableID);
  if (!success) {
     char message[MAX_MSG_LENGTH];
     sprintf(message, "encodeModeAssignment for variableID %d, valueIndex %d\n", 
                       variableID, valueIndex);
     ExceptionAction::ReporterFailure(message);
  }
  return encodedModeAssignment;
}


void Reporter::packetizeAssignment(unsigned timeStep,
				   unsigned variableID,
				   unsigned valueIndex,
				   unsigned weight) {
  // Truncate Candidates and Assignments
  if (d_candidateIndex < MAX_NUMBER_OF_CANDIDATES &&
      d_assignmentIndex < MAX_NUMBER_OF_ASSIGNMENTS) {
    // The offset of the Candidate in the array
    const unsigned candidateIndex =
      d_l2ResultMsg.candidateSetData.numberOfCandidates - 1;
    // The element in the array
    CandidateData& candidateData =
      d_l2ResultMsg.candidateSetData.candidates[candidateIndex];
    // Increment the packet's Assignment count
    candidateData.numberOfAssignments++;

    // If Assignments weren't being truncated, test whether the Assignment
    // array is full. If so, wrap into the next Candidate.

    // The offset of the Assignment in the array
    const unsigned assignmentIndex = candidateData.numberOfAssignments - 1;
    // Start building a new CandidateAssignment struct to keep the names short
    CandidateAssignment candidateAssignment;
    // Set the variableID-valueIndex pair, encoded into one long int
    candidateAssignment.encodedCandidateAssignment =
      encodeAssignment(variableID, valueIndex, weight);
    // Set the time step
    candidateAssignment.timeStep = timeStep;
    // Copy the struct into the packet
    candidateData.candidateAssignments[assignmentIndex] = candidateAssignment;
  }
}


void Reporter::assignment(const Assignment& assignment) {
  // report
  // The Assignment's Variable
  const Variable* const pVariable = assignment.get_variable();
  // The Variable's time step
  const unsigned timeStep = pVariable->get_time_step();
  // The Variable's index
  const unsigned variableID = pVariable->get_id();
  // The Assignment's value index for the Variable
  const unsigned valueIndex = assignment.get_index();
  // The Assignment's rank
  const unsigned weight = assignment.get_weight();
  // Build the logger message
  char message[MAX_MSG_LENGTH];
  sprintf(message, "%i%s%i%s%i%s%i%s%i",
	  REP_ASSIGNMENT,
	  SEPARATOR, timeStep,
	  SEPARATOR, variableID,
	  SEPARATOR, valueIndex,
	  SEPARATOR, weight);
  // Send the message to the logger
  send(message);

  // Place the Assignment data into the telemetry packet
  packetizeAssignment(timeStep, variableID, valueIndex, weight);
}


void Reporter::assumption(unsigned timeStep,
			  unsigned variableID,
			  unsigned valueIndex,
			  VariableType variableType) {
  // report
  char message[MAX_MSG_LENGTH];
  sprintf(message, "%i%s%i%s%i%s%i%s%i",
	  REP_ASSUMPTION,
	  SEPARATOR, timeStep,
	  SEPARATOR, variableID,
	  SEPARATOR, valueIndex,
	  SEPARATOR, variableType);
  send(message);
}


void Reporter::findCandidates() {
  // no report
  // trace
  Logging::log(Logging::L2_SCRIPT, "fc");
}


void Reporter::reportFullState() {
  // A no-op
}


void Reporter::send(const char* message) {
  Logging::log(Logging::L2_LOG, message);
}


void Reporter::stateVariableAssignment(const Assignment& assignment) {
  const unsigned valueIndex = assignment.get_index();
  // The Trajectory represents the set of truncated Assignments
  const Trajectory& trajectory =
    d_livingstone.get_tracker()->get_t_system().get_trajectory(valueIndex);
  for (Trajectory::iterator it = trajectory.begin(); it != trajectory.end();
       ++it) {
    // A Trajectory::Part is a truncated Assignment
    const Trajectory::Parts& parts = *it;
    // report
    // Build the logger message
    char message[MAX_MSG_LENGTH];
    sprintf(message, "%i%s%i%s%i%s%i%s%i",
	    REP_START_STATE,
	    SEPARATOR, parts.get_time(),
	    SEPARATOR, parts.get_id(),
	    SEPARATOR, parts.get_index(),
	    SEPARATOR, parts.get_rank());
    // Send the message to the logger
    send(message);

    // Place the Assignment data into the telemetry packet
    packetizeAssignment(parts.get_time(),
			parts.get_id(),
			parts.get_index(),
			parts.get_rank());
  }
}


VariableType Reporter::variableType(const Variable& variable) {
  if      (variable.is_observable())     { return VT_OBSERVABLE; }
  else if (variable.is_command())        { return VT_COMMANDED; }
  else if (variable.is_assumption())     { return VT_ASSUMPTION; }
  else if (variable.is_state_variable()) { return VT_STATE_VARIABLE; }
  else if (variable.is_transition())     { return VT_TRANSITION; }
  else if (variable.is_assignable())     { return VT_ASSIGNABLE; }
  else if (variable.is_transitioned())   { return VT_TRANSITIONED; }
  else                                   { return VT_DEPENDENT; }
}


/*
 * Initializing consists in setting the message type, setting the time stamp,
 * zeroing the Candidate count.
 */
void
Reporter::initializeL2ResultMsg(int seconds, int nanosec, bool candidate) {
  memset(&d_l2ResultMsg, 0, sizeof(L2ResultMsg));
  d_l2ResultMsg.msgType = (candidate ? CANDIDATE_MSG : MODE_MSG);
  d_l2ResultMsg.time.seconds = seconds;
  d_l2ResultMsg.time.nanosec = nanosec;
  if (candidate) {
    // Use L2ResultMsg::candidateSetData of union
    d_l2ResultMsg.candidateSetData.candidateSetId = 0; // what is this?
    d_l2ResultMsg.candidateSetData.numberOfCandidates = 0; // will increment
  } else {
    // Use L2ResultMsg::modeData of union
    d_l2ResultMsg.modeData.numberOfModeAssignments = 0; // will increment
  }
}


void Reporter::sendPacketToSCL() {
  Logging::sendToTelemetry(d_l2ResultMsg);
}


bool Reporter::modesEnumerated() const { return d_modeCount > 0; }


void Reporter::enumerateModes() {
  // Initialized in constructor; this function called at most once
  if (!(d_modeCount == 0)) {
     char message[MAX_MSG_LENGTH];
     sprintf(message, "enumerateModes has %d modes at initialization (should be zero).\n", d_modeCount);
     ExceptionAction::ReporterFailure(message);
  }
  T_system& t_system = d_livingstone.get_tracker()->get_t_system();
  for (Slist<Variable*>::iterator it = t_system.begin_variables();
       it != t_system.end_variables(); ++it) {
    const Variable* const pVariable = *it;
    if (pVariable->is_transitioned()) {
      if (d_modeCount < MAX_NUMBER_OF_MODES) {
	AVP& avp = d_sentModeAssignments[d_modeCount++];
	avp.variableID = pVariable->get_id();
	avp.valueIndex = -1; // unassigned
      } else {
	// Overflow action?
      }
    }
  }
  // If there are no modes, there is no model
  if (!(d_modeCount > 0)) {
     char message[MAX_MSG_LENGTH];
     sprintf(message, "enumerateModes has %d modes. If there are no modes, there is no model.\n", d_modeCount);
     ExceptionAction::ReporterFailure(message);
  }

}


ostream& operator<<(ostream& os, const L2ResultMsg& l2ResultMsg) {
  os << "msgType = "      << l2ResultMsg.msgType << endl;
  os << "time.seconds = " << l2ResultMsg.time.seconds << endl;
  os << "time.nanosec = " << l2ResultMsg.time.nanosec << endl;
  switch (l2ResultMsg.msgType) {
  case CANDIDATE_MSG:
    os << "candidateSetData.candidateSetId = " <<
      l2ResultMsg.candidateSetData.candidateSetId << endl;
    os << "candidateSetData.numberOfCandidates = " <<
      l2ResultMsg.candidateSetData.numberOfCandidates << endl;
    for (unsigned i = 0; i < l2ResultMsg.candidateSetData.numberOfCandidates;
	 i++) {
      const CandidateData& candidateData =
	l2ResultMsg.candidateSetData.candidates[i];
      os << "candidateSetData.candidate[" << i << "].candidateId = " <<
	candidateData.candidateId << endl;
      os << "candidateSetData.candidate[" << i << "].numberOfAssignments = " <<
	candidateData.numberOfAssignments << endl;
      for (unsigned j = 0; j < candidateData.numberOfAssignments; j++) {
	const CandidateAssignment& candidateAssignment =
	  candidateData.candidateAssignments[j];
	os << "candidateSetData.candidate[" << i << "].candidateAssignments["
	   << j << "].encodedCandidateAssignment = "
	   << candidateAssignment.encodedCandidateAssignment << endl;
	os << "candidateSetData.candidate[" << i << "].candidateAssignments["
	   << j << "].timeStep = " << candidateAssignment.timeStep << endl;
      }
    }
    break;
  case MODE_MSG:
    os << "modeData.numberOfModeAssignments = " <<
      l2ResultMsg.modeData.numberOfModeAssignments << endl;
    for (unsigned i = 0; i < l2ResultMsg.modeData.numberOfModeAssignments;
	 i++) {
      const short encodedModeAssignment =
	l2ResultMsg.modeData.encodedModeAssignments[i];
      os << "modeData.encodedModeAssignments[" << i << "] = " <<
	encodedModeAssignment << endl;
    }
    break;
  default:
    os << "Invalid msgType" << endl;
  }
  return os;
}