namemapper.cpp

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

/***
 *** See the file "L2_RTI_EO1/disclaimers-and-notices-L2.txt" for 
 *** information on usage and redistribution of this file, 
 *** and for a DISCLAIMER OF ALL WARRANTIES.
 ***/
#include "NameMapper.h"                  // this class
#include "conflict_db/assignable.h"      // for class Assignable
#include "debuggers/domain.h"            // for class Domain
#include "debuggers/livingstone_debug.h" // for class Livingstone_debug
#include "transition/transitioned.h"     // for class Transitioned

//Peter Robinson QSS Group Modifications
//Method: NameMapper::getTransitionedName(const unsigned int transitionedIndex) 
//        returns modename without conversion to componentname



/* Initialize a const reference to the Transition System */

NameMapper::NameMapper(/* const */ T_system& ts,
		       /* const */ Tracker_debug& trackerDebugger,
		       /* const */ L2_string_map& stringMap) :
  transitionSystem(ts),
  trackerDebugger(trackerDebugger),
  stringMap(stringMap)
{ }

NameMapper::NameMapper(/* const */ Livingstone_debug& livingstone) :
  transitionSystem(livingstone.get_tracker()->get_t_system()),
  trackerDebugger( *(livingstone.get_debugger()) ),
  stringMap( *(livingstone.get_string_mapping()))
{ }

/* There is nothing to release */

NameMapper::~NameMapper() { }

const MBA_string NameMapper::UNKNOWN_COMMAND("Command not found");
const MBA_string NameMapper::UNKNOWN_VARIABLE("VAriable not found");
const MBA_string NameMapper::UNKNOWN_VARIABLE_VALUE("unknown");
const MBA_string NameMapper::UNKNOWN_OBSERVABLE("Observable not found");
const MBA_string NameMapper::UNKNOWN_TRANSITIONED("Transitioned not found");
const MBA_string NameMapper::UNKNOWN_DOMAIN("Domain not found");

/** Command index -> pointer to Command object */

/* const */ Assignable*
NameMapper::indexToCommand(const unsigned int commandIndex) /* const */
{ return getTransitionSystem().get_command(commandIndex); }

/**  Observable index -> pointer to Observable object */

/* const */ Assignable*
NameMapper::indexToObservable(const unsigned int observableIndex) /* const */
{ return getTransitionSystem().get_observable(observableIndex); }

/** Transitioned index -> pointer to Transitioned object */


/* const */ Variable*
NameMapper::myindexToVariable(const unsigned int variableIndex) /* const */
{ return getTransitionSystem().get_present_variable(variableIndex); }


/* const */ Transitioned*
NameMapper::indexToTransitioned(const unsigned int transitionedIndex) /* const */
{ return getTransitionSystem().get_transitioned(transitionedIndex); }

/** Variable index -> Variable name string */

const MBA_string
NameMapper::getVariableName(const unsigned int variableIndex) /* const */
{
  /* const */ Variable * const myvariable = myindexToVariable(variableIndex);
  if (NULL == myvariable) {
    return UNKNOWN_VARIABLE;
  } else {
    //MOdified for report.
    return getTrackerDebugger().get_var_name(*myvariable);
  }
}

/** (Variable index, value index) -> value name string */

const MBA_string
NameMapper::getVariableValueName(const unsigned int variableIndex,
				 const unsigned int valueIndex) /* const */
{
  /* const */ Variable * const myvariable = myindexToVariable(variableIndex);
  if (NULL == myvariable) {
    return UNKNOWN_VARIABLE;
  } else {
    const Domain * const domain = getStringMap().get_variable_domain(*myvariable);
    if (NULL == domain) {
      return UNKNOWN_DOMAIN;
    } else {
      return domain->value(valueIndex);
    }
    


  }
}

/** Command index -> Command name string */

const MBA_string
NameMapper::getCommandName(const unsigned int commandIndex) /* const */
{ 
  /* const */ Assignable * const command = indexToCommand(commandIndex);
  if (NULL == command) {
    return UNKNOWN_COMMAND;
  } else {
    return getTrackerDebugger().get_var_name(*command);
  }
}

/** (Command index, value index) -> value name string */

const MBA_string
NameMapper::getCommandValueName(const unsigned int commandIndex,
				const unsigned int valueIndex) /* const */ {
  /* const */ Assignable * const command = indexToCommand(commandIndex);
  if (NULL == command) {
    return UNKNOWN_COMMAND;
  } else {
    const Domain * const domain = getStringMap().get_variable_domain(*command);
    if (NULL == domain) {
      return UNKNOWN_DOMAIN;
    } else {
      return domain->value(valueIndex);
    }
  }
}

/** Observable index -> Observable name string */

const MBA_string
NameMapper::getObservableName(const unsigned int observableIndex) /* const */
{
  /* const */ Assignable * const observable = indexToObservable(observableIndex);
  if (NULL == observable) {
    return UNKNOWN_OBSERVABLE;
  } else {
    return getTrackerDebugger().get_var_name(*observable);
  }
}

/** (Observable index, value index) -> value name string */

const MBA_string
NameMapper::getObservableValueName(const unsigned int observableIndex,
				   const unsigned int valueIndex) /* const */
{
  /* const */ Assignable * const observable = indexToObservable(observableIndex);
  if (NULL == observable) {
    return UNKNOWN_OBSERVABLE;
  } else {
    const Domain * const domain = getStringMap().get_variable_domain(*observable);
    if (NULL == domain) {
      return UNKNOWN_DOMAIN;
    } else {
      const MBA_string observation_value = domain->value(valueIndex);
      //return domain->value(valueIndex);
      
      if (observation_value == ""){
	//cout << " For value " 
        //   << observation_value 
        //   << "check to see if it is empty" 
	//   << observation_value.empty() 
	//   << "." << endl;
	return UNKNOWN_VARIABLE_VALUE;
      }     
      else {
	return observation_value;
	  };
    };
  };
}

/** Transitioned index -> Transitioned name string */

const MBA_string
NameMapper::getTransitionedName(const unsigned int transitionedIndex) /* const */
{
  /* const */ Transitioned * const transitioned = indexToTransitioned(transitionedIndex);
  if (NULL == transitioned) {
    return UNKNOWN_TRANSITIONED;
  } else {
    //MOdified for report.
    //cout << "Is this index " << transitionedIndex
    // << " a transition variable " 
    // <<  getTransitionSystem().is_transitioned(transitionedIndex) 
    // << endl;
    return getTrackerDebugger().get_var_name(*transitioned);
  }
}

/** (Transitioned index, value index) -> value name string */

const MBA_string
NameMapper::getTransitionedValueName(const unsigned int transitionedIndex,
				     const unsigned int valueIndex) /* const */
{
  /* const */ Transitioned * const transitioned = indexToTransitioned(transitionedIndex);
  if (NULL == transitioned) {
    return UNKNOWN_TRANSITIONED;
  } else {
    //Put back if trouble.
    Assumption* variable = transitioned->get_zenith();
    //Variable* variable = transitioned->get_zenith();
    const Domain * const domain = getStringMap().get_variable_domain(*variable);
    if (NULL == domain) {
      return UNKNOWN_DOMAIN;
    } else {
      //Replace back if doesn't work.

      //const MBA_string* value_names = getStringMap().get_variable_values(*variable);
      //cout << endl;
      //cout <<"Var index " << transitionedIndex 
      //<< " Compare old and new : " << domain->value(valueIndex)
      //<< " " << (value_names[valueIndex]).c_str() 
      //<< endl;
      return domain->value(valueIndex);
    }
  }
}

/*
 * Since MBA_string doesn't contain substring operators, do this with null-terminated char arrays.
 */

const MBA_string
NameMapper::modeNameToComponentName(const MBA_string& modeName) {
  const char *modeNameCharArray = modeName.c_str();
  const int modeNameLength = strlen(modeNameCharArray);
  const int componentNameLength = modeNameLength - strlen(".mode");
  char* componentNameCharArray = new char[componentNameLength + 1];
  strncpy(componentNameCharArray, modeNameCharArray, componentNameLength);
  componentNameCharArray[componentNameLength] = 0;
  // Who deletes this object?
  MBA_string *componentName = new MBA_string(componentNameCharArray);
  delete [] componentNameCharArray;
  return *componentName;
}