Element Class Reference

Detailed Description

Definition at line 143 of file FGXMLElement.h.

Inheritance diagram for Element:

Collaboration diagram for Element:

Public Member Functions
	Element (const std::string &nm)
	Constructor.
	~Element (void)
	Destructor.
void	AddAttribute (const std::string &name, const std::string &value)
	Stores an attribute belonging to this element.
void	AddChildElement (Element *el)
	Adds a child element to the list of children stored for this element.
void	AddData (std::string d)
	Stores data belonging to this element.
void	ChangeName (const std::string &_name)
double	DisperseValue (Element *e, double val, const std::string &supplied_units="", const std::string &target_units="")
Element *	FindElement (const std::string &el="")
	Searches for a specified element.
FGColumnVector3	FindElementTripletConvertTo (const std::string &target_units)
	Composes a 3-element column vector for the supplied location or orientation.
std::string	FindElementValue (const std::string &el="")
	Searches for the named element and returns the string data belonging to it.
bool	FindElementValueAsBoolean (const std::string &el="")
	Searches for the named element and returns the data belonging to it as a bool.
double	FindElementValueAsNumber (const std::string &el="")
	Searches for the named element and returns the data belonging to it as a number.
double	FindElementValueAsNumberConvertFromTo (const std::string &el, const std::string &supplied_units, const std::string &target_units)
	Searches for the named element and converts and returns the data belonging to it.
double	FindElementValueAsNumberConvertTo (const std::string &el, const std::string &target_units)
	Searches for the named element and converts and returns the data belonging to it.
Element *	FindNextElement (const std::string &el="")
	Searches for the next element as specified.
std::string	GetAttributeValue (const std::string &key)
	Retrieves an attribute.
double	GetAttributeValueAsNumber (const std::string &key)
	Retrieves an attribute value as a double precision real number.
double	GetDataAsNumber (void)
	Converts the element data to a number.
std::string	GetDataLine (unsigned int i=0)
	Gets a line of data belonging to an element.
Element *	GetElement (unsigned int el=0)
	Returns a pointer to the element requested by index.
const std::string &	GetFileName (void) const
	Returns the name of the file in which the element has been read.
int	GetLineNumber (void) const
	Returns the line number at which the element has been defined.
const std::string &	GetName (void) const
	Retrieves the element name.
Element *	GetNextElement (void)
	Returns a pointer to the next element in the list.
unsigned int	GetNumDataLines (void)
	Returns the number of lines of data stored.
unsigned int	GetNumElements (const std::string &element_name)
	Returns the number of named child elements for this element.
unsigned int	GetNumElements (void)
	Returns the number of child elements for this element.
Element *	GetParent (void)
	Returns a pointer to the parent of an element.
bool	HasAttribute (const std::string &key)
	Determines if an element has the supplied attribute.
void	MergeAttributes (Element *el)
	Merges the attributes of the current element with another element.
void	Print (unsigned int level=0)
	Prints the element.
std::string	ReadFrom (void) const
	Return a string that contains a description of the location where the current XML element was read from.
bool	SetAttributeValue (const std::string &key, const std::string &value)
	Modifies an attribute.
void	SetFileName (const std::string &name)
	Set the name of the file in which the element has been read.
void	SetLineNumber (int line)
	Set the line number at which the element has been read.
void	SetParent (Element *p)
	This function sets the value of the parent class attribute to the supplied Element pointer.

Constructor & Destructor Documentation

Element()

Element

(

const std::string &

nm

)

Constructor.

Parameters

nm	the name of this element (if given)

Definition at line 54 of file FGXMLElement.cpp.

{
  name   = nm;
  parent = 0L;
  element_index = 0;
  line_number = -1;
 
  if (!converterIsInitialized) {
    converterIsInitialized = true;
    // convert ["from"]["to"] = factor, so: from * factor = to
    // Length
    convert["M"]["FT"] = 3.2808399;
    convert["FT"]["M"] = 1.0/convert["M"]["FT"];
    convert["CM"]["FT"] = 0.032808399;
    convert["FT"]["CM"] = 1.0/convert["CM"]["FT"];
    convert["KM"]["FT"] = 3280.8399;
    convert["FT"]["KM"] = 1.0/convert["KM"]["FT"];
    convert["FT"]["IN"] = 12.0;
    convert["IN"]["FT"] = 1.0/convert["FT"]["IN"];
    convert["IN"]["M"] = convert["IN"]["FT"] * convert["FT"]["M"];
    convert["M"]["IN"] = convert["M"]["FT"] * convert["FT"]["IN"];
    // Area
    convert["M2"]["FT2"] = convert["M"]["FT"]*convert["M"]["FT"];
    convert["FT2"]["M2"] = 1.0/convert["M2"]["FT2"];
    convert["CM2"]["FT2"] = convert["CM"]["FT"]*convert["CM"]["FT"];
    convert["FT2"]["CM2"] = 1.0/convert["CM2"]["FT2"];
    convert["M2"]["IN2"] = convert["M"]["IN"]*convert["M"]["IN"];
    convert["IN2"]["M2"] = 1.0/convert["M2"]["IN2"];
    convert["FT2"]["IN2"] = 144.0;
    convert["IN2"]["FT2"] = 1.0/convert["FT2"]["IN2"];
    // Volume
    convert["IN3"]["CC"] = 16.387064;
    convert["CC"]["IN3"] = 1.0/convert["IN3"]["CC"];
    convert["FT3"]["IN3"] = 1728.0;
    convert["IN3"]["FT3"] = 1.0/convert["FT3"]["IN3"];
    convert["M3"]["FT3"] = 35.3146667;
    convert["FT3"]["M3"] = 1.0/convert["M3"]["FT3"];
    convert["LTR"]["IN3"] = 61.0237441;
    convert["IN3"]["LTR"] = 1.0/convert["LTR"]["IN3"];
    convert["GAL"]["FT3"] = 0.133681;
    convert["FT3"]["GAL"] = 1.0/convert["GAL"]["FT3"];
    convert["IN3"]["GAL"] = convert["IN3"]["FT3"]*convert["FT3"]["GAL"];
    convert["LTR"]["GAL"] = convert["LTR"]["IN3"]*convert["IN3"]["GAL"];
    convert["M3"]["GAL"] = 1000.*convert["LTR"]["GAL"];
    convert["CC"]["GAL"] = convert["CC"]["IN3"]*convert["IN3"]["GAL"];
    // Mass & Weight
    convert["LBS"]["KG"] = 0.45359237;
    convert["KG"]["LBS"] = 1.0/convert["LBS"]["KG"];
    convert["SLUG"]["KG"] = 14.59390;
    convert["KG"]["SLUG"] = 1.0/convert["SLUG"]["KG"];
    // Moments of Inertia
    convert["SLUG*FT2"]["KG*M2"] = 1.35594;
    convert["KG*M2"]["SLUG*FT2"] = 1.0/convert["SLUG*FT2"]["KG*M2"];
    // Angles
    convert["RAD"]["DEG"] = 180.0/M_PI;
    convert["DEG"]["RAD"] = 1.0/convert["RAD"]["DEG"];
    // Angular rates
    convert["RAD/SEC"]["DEG/SEC"] = convert["RAD"]["DEG"];
    convert["DEG/SEC"]["RAD/SEC"] = 1.0/convert["RAD/SEC"]["DEG/SEC"];
    // Spring force
    convert["LBS/FT"]["N/M"] = 14.5939;
    convert["N/M"]["LBS/FT"] = 1.0/convert["LBS/FT"]["N/M"];
    // Damping force
    convert["LBS/FT/SEC"]["N/M/SEC"] = 14.5939;
    convert["N/M/SEC"]["LBS/FT/SEC"] = 1.0/convert["LBS/FT/SEC"]["N/M/SEC"];
    // Damping force (Square Law)
    convert["LBS/FT2/SEC2"]["N/M2/SEC2"] = 47.880259;
    convert["N/M2/SEC2"]["LBS/FT2/SEC2"] = 1.0/convert["LBS/FT2/SEC2"]["N/M2/SEC2"];
    // Power
    convert["WATTS"]["HP"] = 0.001341022;
    convert["HP"]["WATTS"] = 1.0/convert["WATTS"]["HP"];
    // Force
    convert["N"]["LBS"] = 0.22482;
    convert["LBS"]["N"] = 1.0/convert["N"]["LBS"];
    // Velocity
    convert["KTS"]["FT/SEC"] = 1.6878098571;
    convert["FT/SEC"]["KTS"] = 1.0/convert["KTS"]["FT/SEC"];
    convert["M/S"]["FT/S"] = 3.2808399;
    convert["M/S"]["KTS"] = convert["M/S"]["FT/S"]/convert["KTS"]["FT/SEC"];
    convert["M/SEC"]["FT/SEC"] = 3.2808399;
    convert["FT/S"]["M/S"] = 1.0/convert["M/S"]["FT/S"];
    convert["M/SEC"]["FT/SEC"] = 3.2808399;
    convert["FT/SEC"]["M/SEC"] = 1.0/convert["M/SEC"]["FT/SEC"];
    convert["KM/SEC"]["FT/SEC"] = 3280.8399;
    convert["FT/SEC"]["KM/SEC"] = 1.0/convert["KM/SEC"]["FT/SEC"];
    // Torque
    convert["FT*LBS"]["N*M"] = 1.35581795;
    convert["N*M"]["FT*LBS"] = 1/convert["FT*LBS"]["N*M"];
    // Valve
    convert["M4*SEC/KG"]["FT4*SEC/SLUG"] = convert["M"]["FT"]*convert["M"]["FT"]*
      convert["M"]["FT"]*convert["M"]["FT"]/convert["KG"]["SLUG"];
    convert["FT4*SEC/SLUG"]["M4*SEC/KG"] =
      1.0/convert["M4*SEC/KG"]["FT4*SEC/SLUG"];
    // Pressure
    convert["INHG"]["PSF"] = 70.7180803;
    convert["PSF"]["INHG"] = 1.0/convert["INHG"]["PSF"];
    convert["ATM"]["INHG"] = 29.9246899;
    convert["INHG"]["ATM"] = 1.0/convert["ATM"]["INHG"];
    convert["PSI"]["INHG"] = 2.03625437;
    convert["INHG"]["PSI"] = 1.0/convert["PSI"]["INHG"];
    convert["INHG"]["PA"] = 3386.0; // inches Mercury to pascals
    convert["PA"]["INHG"] = 1.0/convert["INHG"]["PA"];
    convert["LBS/FT2"]["N/M2"] = 14.5939/convert["FT"]["M"];
    convert["N/M2"]["LBS/FT2"] = 1.0/convert["LBS/FT2"]["N/M2"];
    convert["LBS/FT2"]["PA"] = convert["LBS/FT2"]["N/M2"];
    convert["PA"]["LBS/FT2"] = 1.0/convert["LBS/FT2"]["PA"];
    // Mass flow
    convert["KG/MIN"]["LBS/MIN"] = convert["KG"]["LBS"];
    convert["KG/SEC"]["LBS/SEC"] = convert["KG"]["LBS"];
    convert ["N/SEC"]["LBS/SEC"] = 0.224808943;
    convert ["LBS/SEC"]["N/SEC"] = 1.0/convert ["N/SEC"]["LBS/SEC"];
    // Fuel Consumption
    convert["LBS/HP*HR"]["KG/KW*HR"] = 0.6083;
    convert["KG/KW*HR"]["LBS/HP*HR"] = 1.0/convert["LBS/HP*HR"]["KG/KW*HR"];
    // Density
    convert["KG/L"]["LBS/GAL"] = 8.3454045;
    convert["LBS/GAL"]["KG/L"] = 1.0/convert["KG/L"]["LBS/GAL"];
    // Gravitational
    convert["FT3/SEC2"]["M3/SEC2"] = convert["FT3"]["M3"];
    convert["M3/SEC2"]["FT3/SEC2"] = convert["M3"]["FT3"];
 
    // Length
    convert["M"]["M"] = 1.00;
    convert["KM"]["KM"] = 1.00;
    convert["FT"]["FT"] = 1.00;
    convert["IN"]["IN"] = 1.00;
    // Area
    convert["M2"]["M2"] = 1.00;
    convert["FT2"]["FT2"] = 1.00;
    // Volume
    convert["IN3"]["IN3"] = 1.00;
    convert["CC"]["CC"] = 1.0;
    convert["M3"]["M3"] = 1.0;
    convert["FT3"]["FT3"] = 1.0;
    convert["LTR"]["LTR"] = 1.0;
    convert["GAL"]["GAL"] = 1.0;
    // Mass & Weight
    convert["KG"]["KG"] = 1.00;
    convert["LBS"]["LBS"] = 1.00;
    // Moments of Inertia
    convert["KG*M2"]["KG*M2"] = 1.00;
    convert["SLUG*FT2"]["SLUG*FT2"] = 1.00;
    // Angles
    convert["DEG"]["DEG"] = 1.00;
    convert["RAD"]["RAD"] = 1.00;
    // Angular rates
    convert["DEG/SEC"]["DEG/SEC"] = 1.00;
    convert["RAD/SEC"]["RAD/SEC"] = 1.00;
    // Spring force
    convert["LBS/FT"]["LBS/FT"] = 1.00;
    convert["N/M"]["N/M"] = 1.00;
    // Damping force
    convert["LBS/FT/SEC"]["LBS/FT/SEC"] = 1.00;
    convert["N/M/SEC"]["N/M/SEC"] = 1.00;
    // Damping force (Square law)
    convert["LBS/FT2/SEC2"]["LBS/FT2/SEC2"] = 1.00;
    convert["N/M2/SEC2"]["N/M2/SEC2"] = 1.00;
    // Power
    convert["HP"]["HP"] = 1.00;
    convert["WATTS"]["WATTS"] = 1.00;
    // Force
    convert["N"]["N"] = 1.00;
    // Velocity
    convert["FT/SEC"]["FT/SEC"] = 1.00;
    convert["KTS"]["KTS"] = 1.00;
    convert["M/S"]["M/S"] = 1.0;
    convert["M/SEC"]["M/SEC"] = 1.0;
    convert["KM/SEC"]["KM/SEC"] = 1.0;
    // Torque
    convert["FT*LBS"]["FT*LBS"] = 1.00;
    convert["N*M"]["N*M"] = 1.00;
    // Valve
    convert["M4*SEC/KG"]["M4*SEC/KG"] = 1.0;
    convert["FT4*SEC/SLUG"]["FT4*SEC/SLUG"] = 1.0;
    // Pressure
    convert["PSI"]["PSI"] = 1.00;
    convert["PSF"]["PSF"] = 1.00;
    convert["INHG"]["INHG"] = 1.00;
    convert["ATM"]["ATM"] = 1.0;
    convert["PA"]["PA"] = 1.0;
    convert["N/M2"]["N/M2"] = 1.00;
    convert["LBS/FT2"]["LBS/FT2"] = 1.00;
    // Mass flow
    convert["LBS/SEC"]["LBS/SEC"] = 1.00;
    convert["KG/MIN"]["KG/MIN"] = 1.0;
    convert["LBS/MIN"]["LBS/MIN"] = 1.0;
    convert["N/SEC"]["N/SEC"] = 1.0;
    // Fuel Consumption
    convert["LBS/HP*HR"]["LBS/HP*HR"] = 1.0;
    convert["KG/KW*HR"]["KG/KW*HR"] = 1.0;
    // Density
    convert["KG/L"]["KG/L"] = 1.0;
    convert["LBS/GAL"]["LBS/GAL"] = 1.0;
    // Gravitational
    convert["FT3/SEC2"]["FT3/SEC2"] = 1.0;
    convert["M3/SEC2"]["M3/SEC2"] = 1.0;
    // Electrical
    convert["VOLTS"]["VOLTS"] = 1.0;
    convert["OHMS"]["OHMS"] = 1.0;
    convert["AMPERES"]["AMPERES"] = 1.0;
  }
}

~Element()

~Element

(

void

)

Destructor.

Definition at line 259 of file FGXMLElement.cpp.

{
  for (unsigned int i = 0; i < children.size(); ++i)
    children[i]->SetParent(0);
}

Here is the call graph for this function:

Member Function Documentation

AddAttribute()

void AddAttribute	(	const std::string &	name,
		const std::string &	value
	)

Stores an attribute belonging to this element.

Parameters

name	The string name of the attribute.
value	The string value of the attribute.

Definition at line 727 of file FGXMLElement.cpp.

{
  attributes[name] = value;
}

Here is the caller graph for this function:

AddChildElement()

void AddChildElement ( Element *  el )

inline

Adds a child element to the list of children stored for this element.

Parameters

el	Child element to add.

Definition at line 345 of file FGXMLElement.h.

{children.push_back(el);}

Here is the caller graph for this function:

AddData()

void AddData

(

std::string

d

)

Stores data belonging to this element.

Parameters

d	the data to store.

Definition at line 734 of file FGXMLElement.cpp.

{
  string::size_type string_start = d.find_first_not_of(" \t");
  if (string_start != string::npos && string_start > 0) {
    d.erase(0,string_start);
  }
  data_lines.push_back(d);
}

ChangeName()

void ChangeName ( const std::string &  _name )

inline

Definition at line 180 of file FGXMLElement.h.

{ name = _name; }

DisperseValue()

double DisperseValue	(	Element *	e,
		double	val,
		const std::string &	supplied_units = "",
		const std::string &	target_units = ""
	)

Definition at line 656 of file FGXMLElement.cpp.

{
  double value=val;
 
  bool disperse = false;
  try {
    char* num = getenv("JSBSIM_DISPERSE");
    if (num) {
      disperse = (atoi(num) == 1);  // set dispersions
    }
  } catch (...) {                   // if error set to false
    disperse = false;
    std::cerr << "Could not process JSBSIM_DISPERSE environment variable: Assumed NO dispersions." << endl;
  }
 
  if (e->HasAttribute("dispersion") && disperse) {
    double disp = e->GetAttributeValueAsNumber("dispersion");
    if (!supplied_units.empty()) disp *= convert[supplied_units][target_units];
    string attType = e->GetAttributeValue("type");
    RandomNumberGenerator generator;
 
    if (attType == "gaussian" || attType == "gaussiansigned") {
      double grn = generator.GetNormalRandomNumber();
      if (attType == "gaussian")
        value = val + disp*grn;
      else // Assume gaussiansigned
        value = (val + disp*grn)*FGJSBBase::sign(grn);
    } else if (attType == "uniform" || attType == "uniformsigned") {
      double urn = generator.GetUniformRandomNumber();
      if (attType == "uniform")
        value = val + disp * urn;
      else // Assume uniformsigned
        value = (val + disp * urn)*FGJSBBase::sign(urn);
    } else {
      std::stringstream s;
      s << ReadFrom() << "Unknown dispersion type" << attType;
      cerr << s.str() << endl;
      throw domain_error(s.str());
    }
 
  }
  return value;
}

FindElement()

Element * FindElement

(

const std::string &

el = ""

)

Searches for a specified element.

Finds the first element that matches the supplied string, or simply the first element if no search string is supplied. This function call resets the internal element counter to the first element.

Parameters

el	the search string (empty string by default).

Returns

a pointer to the first element that matches the supplied search string.

Definition at line 396 of file FGXMLElement.cpp.

{
  if (el.empty() && children.size() >= 1) {
    element_index = 1;
    return children[0];
  }
  for (unsigned int i=0; i<children.size(); i++) {
    if (el == children[i]->GetName()) {
      element_index = i+1;
      return children[i];
    }
  }
  element_index = 0;
  return 0L;
}

Here is the call graph for this function:

Here is the caller graph for this function:

FindElementTripletConvertTo()

FGColumnVector3 FindElementTripletConvertTo

(

const std::string &

target_units

)

Composes a 3-element column vector for the supplied location or orientation.

This function processes a LOCATION or ORIENTATION construct, returning a filled-out 3-element column vector containing the X, Y, Z or ROLL, PITCH, YAW elements found in the supplied element. If one of the mentioned components is not found, that component is set to zero and a warning message is printed. All three elements should be supplied.

Parameters

target_units

the string representing the native units used by JSBSim to which the value returned will be converted.

Returns

a column vector object built from the LOCATION or ORIENT components.

Definition at line 596 of file FGXMLElement.cpp.

{
  FGColumnVector3 triplet;
  Element* item;
  double value=0.0;
  string supplied_units = GetAttributeValue("unit");
 
  if (!supplied_units.empty()) {
    if (convert.find(supplied_units) == convert.end()) {
      std::stringstream s;
      s << ReadFrom() << "Supplied unit: \"" << supplied_units
        << "\" does not exist (typo?).";
      cerr << s.str() << endl;
      throw invalid_argument(s.str());
    }
    if (convert[supplied_units].find(target_units) == convert[supplied_units].end()) {
      std::stringstream s;
      s << ReadFrom() << "Supplied unit: \"" << supplied_units
        << "\" cannot be converted to " << target_units;
      cerr << s.str() << endl;
      throw invalid_argument(s.str());
    }
  }
 
  item = FindElement("x");
  if (!item) item = FindElement("roll");
  if (item) {
    value = item->GetDataAsNumber();
    if (!supplied_units.empty()) value *= convert[supplied_units][target_units];
    triplet(1) = DisperseValue(item, value, supplied_units, target_units);
  } else {
    triplet(1) = 0.0;
  }
 
 
  item = FindElement("y");
  if (!item) item = FindElement("pitch");
  if (item) {
    value = item->GetDataAsNumber();
    if (!supplied_units.empty()) value *= convert[supplied_units][target_units];
    triplet(2) = DisperseValue(item, value, supplied_units, target_units);
  } else {
    triplet(2) = 0.0;
  }
 
  item = FindElement("z");
  if (!item) item = FindElement("yaw");
  if (item) {
    value = item->GetDataAsNumber();
    if (!supplied_units.empty()) value *= convert[supplied_units][target_units];
    triplet(3) = DisperseValue(item, value, supplied_units, target_units);
  } else {
    triplet(3) = 0.0;
  }
 
  return triplet;
}

Here is the call graph for this function:

Here is the caller graph for this function:

FindElementValue()

string FindElementValue

(

const std::string &

el = ""

)

Searches for the named element and returns the string data belonging to it.

This function allows the data belonging to a named element to be returned as a string. If no element is found, the empty string is returned. If no argument is supplied, the data string for the first element is returned.

Parameters

el	the name of the element being searched for (the empty string by default)

Returns

the data value for the named element as a string, or the empty string if the element cannot be found.

Definition at line 475 of file FGXMLElement.cpp.

{
  Element* element = FindElement(el);
  if (element) {
    return element->GetDataLine();
  } else {
    return "";
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

FindElementValueAsBoolean()

bool FindElementValueAsBoolean

(

const std::string &

el = ""

)

Searches for the named element and returns the data belonging to it as a bool.

This function allows the data belonging to a named element to be returned as a bool. If no element is found, false is returned. If no argument is supplied, the data for the first element is returned.

Parameters

el	the name of the element being searched for (the empty string by default)

Returns

the data value for the named element as a bool, or false if the data is missing. Zero will be false, while any other number will be true.

Definition at line 453 of file FGXMLElement.cpp.

{
  Element* element = FindElement(el);
  if (element) {
    // check value as an ordinary number
    double value = element->GetDataAsNumber();
 
    // now check how it should return data
    if (value == 0) {
      return false;
    } else {
      return true;
    }
  } else {
    cerr << ReadFrom() << "Attempting to get non-existent element " << el << " ;returning false"
         << endl;
    return false;
  }
}

Here is the call graph for this function:

FindElementValueAsNumber()

double FindElementValueAsNumber

(

const std::string &

el = ""

)

Searches for the named element and returns the data belonging to it as a number.

This function allows the data belonging to a named element to be returned as a double. If no element is found, HUGE_VAL is returned. If no argument is supplied, the data for the first element is returned.

Parameters

el	the name of the element being searched for (the empty string by default)

Returns

the data value for the named element as a double, or HUGE_VAL if the data is missing.

Definition at line 436 of file FGXMLElement.cpp.

{
  Element* element = FindElement(el);
  if (element) {
    double value = element->GetDataAsNumber();
    value = DisperseValue(element, value);
    return value;
  } else {
    std::stringstream s;
    s << ReadFrom() << "Attempting to get non-existent element " << el;
    cerr << s.str() << endl;
    throw length_error(s.str());
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

FindElementValueAsNumberConvertFromTo()

double FindElementValueAsNumberConvertFromTo	(	const std::string &	el,
		const std::string &	supplied_units,
		const std::string &	target_units
	)

Searches for the named element and converts and returns the data belonging to it.

This function allows the data belonging to a named element to be returned as a double. If no element is found, HUGE_VAL is returned. If no argument is supplied, the data for the first element is returned. Additionally, this function converts the value from the units specified in the supplied_units parameter to the units specified in the target_units parameter. JSBSim itself, as specified by the target_units parameter. The currently allowable unit conversions are seen in the source file FGXMLElement.cpp. Also, see above in the main documentation for this class.

Parameters

el	the name of the element being searched for (the empty string by default)
supplied_units	the string representing the units of the value as supplied by the config file.
target_units	the string representing the native units used by JSBSim to which the value returned will be converted.

Returns

the unit-converted data value for the named element as a double, or HUGE_VAL if the data is missing.

Definition at line 554 of file FGXMLElement.cpp.

{
  Element* element = FindElement(el);
 
  if (!element) {
    std::stringstream s;
    s << ReadFrom() << "Attempting to get non-existent element " << el;
    cerr << s.str() << endl;
    throw length_error(s.str());
  }
 
  if (!supplied_units.empty()) {
    if (convert.find(supplied_units) == convert.end()) {
      std::stringstream s;
      s << element->ReadFrom() << "Supplied unit: \"" << supplied_units
        << "\" does not exist (typo?).";
      cerr << s.str() << endl;
      throw invalid_argument(s.str());
    }
    if (convert[supplied_units].find(target_units) == convert[supplied_units].end()) {
      std::stringstream s;
      s << element->ReadFrom() << "Supplied unit: \"" << supplied_units
        << "\" cannot be converted to " << target_units;
      cerr << s.str() << endl;
      throw invalid_argument(s.str());
    }
  }
 
  double value = element->GetDataAsNumber();
  if (!supplied_units.empty()) {
    value *= convert[supplied_units][target_units];
  }
 
  value = DisperseValue(element, value, supplied_units, target_units);
 
  return value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

FindElementValueAsNumberConvertTo()

double FindElementValueAsNumberConvertTo	(	const std::string &	el,
		const std::string &	target_units
	)

Searches for the named element and converts and returns the data belonging to it.

This function allows the data belonging to a named element to be returned as a double. If no element is found, HUGE_VAL is returned. If no argument is supplied, the data for the first element is returned. Additionally, this function converts the value from the units specified in the config file (via the UNITS="" attribute in the element definition) to the native units used by JSBSim itself, as specified by the target_units parameter. The currently allowable unit conversions are seen in the source file FGXMLElement.cpp. Also, see above in the main documentation for this class.

Parameters

el	the name of the element being searched for (the empty string by default)
target_units	the string representing the native units used by JSBSim to which the value returned will be converted.

Returns

the unit-converted data value for the named element as a double, or HUGE_VAL if the data is missing.

Definition at line 487 of file FGXMLElement.cpp.

{
  Element* element = FindElement(el);
 
  if (!element) {
    std::stringstream s;
    s << ReadFrom() << "Attempting to get non-existent element " << el;
    cerr << s.str() << endl;
    throw length_error(s.str());
  }
 
  string supplied_units = element->GetAttributeValue("unit");
 
  if (!supplied_units.empty()) {
    if (convert.find(supplied_units) == convert.end()) {
      std::stringstream s;
      s << element->ReadFrom() << "Supplied unit: \"" << supplied_units
        << "\" does not exist (typo?).";
      cerr << s.str() << endl;
      throw invalid_argument(s.str());
    }
    if (convert[supplied_units].find(target_units) == convert[supplied_units].end()) {
      std::stringstream s;
      s << element->ReadFrom() << "Supplied unit: \"" << supplied_units
        << "\" cannot be converted to " << target_units;
      cerr << s.str() << endl;
      throw invalid_argument(s.str());
    }
  }
 
  double value = element->GetDataAsNumber();
 
  // Sanity check for angular values
  if ((supplied_units == "RAD") && (fabs(value) > 2 * M_PI)) {
    cerr << element->ReadFrom() << element->GetName() << " value "
         << value << " RAD is outside the range [ -2*M_PI RAD ; +2*M_PI RAD ]"
         << endl;
  }
  if ((supplied_units == "DEG") && (fabs(value) > 360.0)) {
    cerr << element->ReadFrom() << element->GetName() << " value "
         << value << " DEG is outside the range [ -360 DEG ; +360 DEG ]"
         << endl;
  }
 
 
  if (!supplied_units.empty()) {
    value *= convert[supplied_units][target_units];
  }
 
  if ((target_units == "RAD") && (fabs(value) > 2 * M_PI)) {
    cerr << element->ReadFrom() << element->GetName() << " value "
         << value << " RAD is outside the range [ -2*M_PI RAD ; +2*M_PI RAD ]"
         << endl;
  }
  if ((target_units == "DEG") && (fabs(value) > 360.0)) {
    cerr << element->ReadFrom() << element->GetName() << " value "
         << value << " DEG is outside the range [ -360 DEG ; +360 DEG ]"
         << endl;
  }
 
  value = DisperseValue(element, value, supplied_units, target_units);
 
  return value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

FindNextElement()

Element * FindNextElement

(

const std::string &

el = ""

)

Searches for the next element as specified.

This function would be called after FindElement() is first called (in order to reset the internal counter). If no argument is supplied (or the empty string) a pointer to the very next element is returned. Otherwise, the next occurence of the named element is returned. If the end of the list is reached, 0 is returned.

Parameters

el	the name of the next element to find.

Returns

the pointer to the found element, or 0 if no appropriate element us found.

Definition at line 414 of file FGXMLElement.cpp.

{
  if (el.empty()) {
    if (element_index < children.size()) {
      return children[element_index++];
    } else {
      element_index = 0;
      return 0L;
    }
  }
  for (unsigned int i=element_index; i<children.size(); i++) {
    if (el == children[i]->GetName()) {
      element_index = i+1;
      return children[i];
    }
  }
  element_index = 0;
  return 0L;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetAttributeValue()

string GetAttributeValue

(

const std::string &

key

)

Retrieves an attribute.

Parameters

key	specifies the attribute key to retrieve the value of.

Returns

the key value (as a string), or the empty string if no such attribute exists.

Definition at line 267 of file FGXMLElement.cpp.

{
  if (HasAttribute(attr))  return attributes[attr];
  else                     return ("");
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetAttributeValueAsNumber()

double GetAttributeValueAsNumber

(

const std::string &

key

)

Retrieves an attribute value as a double precision real number.

Parameters

key	specifies the attribute key to retrieve the value of.

Returns

the key value (as a number), or the HUGE_VAL if no such attribute exists.

Definition at line 286 of file FGXMLElement.cpp.

{
  string attribute = GetAttributeValue(attr);
 
  if (attribute.empty()) {
    std::stringstream s;
    s << ReadFrom() << "Expecting numeric attribute value, but got no data";
    cerr << s.str() << endl;
    throw length_error(s.str());
  }
  else {
    double number=0;
    try {
      number = atof_locale_c(attribute);
    } catch (InvalidNumber& e) {
      std::stringstream s;
      s << ReadFrom() << e.what();
      cerr << s.str() << endl;
      throw BaseException(s.str());
    }
 
    return (number);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetDataAsNumber()

double GetDataAsNumber

(

void

)

Converts the element data to a number.

This function attempts to convert the first (and presumably only) line of data "owned" by the element into a real number. If there is not exactly one line of data owned by the element, then HUGE_VAL is returned.

Returns

the numeric value of the data owned by the element.

Definition at line 348 of file FGXMLElement.cpp.

{
  if (data_lines.size() == 1) {
    double number=0;
    try {
      number = atof_locale_c(data_lines[0]);
    } catch (InvalidNumber& e) {
      std::stringstream s;
      s << ReadFrom() << e.what();
      cerr << s.str() << endl;
      throw BaseException(s.str());
    }
 
    return number;
  } else if (data_lines.empty()) {
    std::stringstream s;
    s << ReadFrom() << "Expected numeric value, but got no data";
    cerr << s.str() << endl;
    throw length_error(s.str());
  } else {
    cerr << ReadFrom() << "Attempting to get single data value in element "
         << "<" << name << ">" << endl
         << " from multiple lines:" << endl;
    for(unsigned int i=0; i<data_lines.size(); ++i)
      cerr << data_lines[i] << endl;
    std::stringstream s;
    s << ReadFrom() << "Attempting to get single data value in element "
      << "<" << name << ">"
      << " from multiple lines (" << data_lines.size() << ").";
    throw length_error(s.str());
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetDataLine()

string GetDataLine

(

unsigned int

i = 0

)

Gets a line of data belonging to an element.

Parameters

i	the index of the data line to return (0 by default).

Returns

a string representing the data line requested, or the empty string if none exists.

Definition at line 340 of file FGXMLElement.cpp.

{
  if (!data_lines.empty()) return data_lines[i];
  else return string("");
}

Here is the caller graph for this function:

GetElement()

Element * GetElement

(

unsigned int

el = 0

)

Returns a pointer to the element requested by index.

This function also resets an internal counter to the index, so that subsequent calls to GetNextElement() will return the following elements sequentially, until the last element is reached. At that point, GetNextElement() will return NULL.

Parameters

el	the index of the requested element (0 by default)

Returns

a pointer to the Element, or 0 if no valid element exists.

Definition at line 313 of file FGXMLElement.cpp.

{
  if (children.size() > el) {
    element_index = el;
    return children[el];
  }
  else {
    element_index = 0;
    return 0L;
  }
}

Here is the caller graph for this function:

GetFileName()

const std::string & GetFileName ( void  ) const

inline

Returns the name of the file in which the element has been read.

Returns

the file name

Definition at line 235 of file FGXMLElement.h.

{ return file_name; }

Here is the caller graph for this function:

GetLineNumber()

int GetLineNumber ( void  ) const

inline

Returns the line number at which the element has been defined.

Returns

the line number

Definition at line 230 of file FGXMLElement.h.

{ return line_number; }

Here is the caller graph for this function:

GetName()

const std::string & GetName ( void  ) const

inline

Retrieves the element name.

Returns

the element name, or the empty string if no name has been set.

Definition at line 179 of file FGXMLElement.h.

{return name;}

Here is the caller graph for this function:

GetNextElement()

Element * GetNextElement

(

void

)

Returns a pointer to the next element in the list.

The function GetElement() must be called first to be sure that this function will return the correct element. The call to GetElement() resets the internal counter to zero. Subsequent calls to GetNextElement() return a pointer to subsequent elements in the list. When the final element is reached, 0 is returned.

Returns

a pointer to the next Element in the sequence, or 0 if no valid Element is present.

Definition at line 327 of file FGXMLElement.cpp.

{
  if (children.size() > element_index+1) {
    element_index++;
    return children[element_index];
  } else {
    element_index = 0;
    return 0L;
  }
}

Here is the caller graph for this function:

GetNumDataLines()

unsigned int GetNumDataLines ( void  )

inline

Returns the number of lines of data stored.

Definition at line 189 of file FGXMLElement.h.

{return (unsigned int)data_lines.size();}

Here is the caller graph for this function:

GetNumElements() [1/2]

unsigned int GetNumElements

(

const std::string &

element_name

)

Returns the number of named child elements for this element.

Definition at line 383 of file FGXMLElement.cpp.

{
  unsigned int number_of_elements=0;
  Element* el=FindElement(element_name);
  while (el) {
    number_of_elements++;
    el=FindNextElement(element_name);
  }
  return number_of_elements;
}

Here is the call graph for this function:

GetNumElements() [2/2]

unsigned int GetNumElements ( void  )

inline

Returns the number of child elements for this element.

Definition at line 192 of file FGXMLElement.h.

{return (unsigned int)children.size();}

Here is the caller graph for this function:

GetParent()

Element * GetParent ( void  )

inline

Returns a pointer to the parent of an element.

Returns

a pointer to the parent Element, or 0 if this is the top level Element.

Definition at line 225 of file FGXMLElement.h.

{return parent;}

Here is the caller graph for this function:

HasAttribute()

bool HasAttribute ( const std::string &  key )

inline

Determines if an element has the supplied attribute.

Parameters

key	specifies the attribute key to retrieve the value of.

Returns

true or false.

Definition at line 155 of file FGXMLElement.h.

{return attributes.find(key) != attributes.end();}

Here is the caller graph for this function:

MergeAttributes()

void MergeAttributes

(

Element *

el

)

Merges the attributes of the current element with another element.

The attributes from the current element override the element that is passed as a parameter. In other words if the two elements have an attribute with the same name, the attribute from the current element is kept and the corresponding attribute of the other element is ignored.

Parameters

el	element with which the current element will merge its attributes.

Definition at line 758 of file FGXMLElement.cpp.

{
  map<string, string>::iterator it;
 
  for (it=el->attributes.begin(); it != el->attributes.end(); ++it) {
    if (attributes.find(it->first) == attributes.end())
      attributes[it->first] = it->second;
    else {
      if (FGJSBBase::debug_lvl > 0 && (attributes[it->first] != it->second))
        cout << el->ReadFrom() << " Attribute '" << it->first << "' is overridden in file "
             << GetFileName() << ": line " << GetLineNumber() << endl
             << " The value '" << attributes[it->first] << "' will be used instead of '"
             << it->second << "'." << endl;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Print()

void Print

(

unsigned int

level = 0

)

Prints the element.

Prints this element and calls the Print routine for child elements.

Parameters

d	The tab level. A level corresponds to a single space.

Definition at line 703 of file FGXMLElement.cpp.

{
  unsigned int i, spaces;
 
  level+=2;
  for (spaces=0; spaces<=level; spaces++) cout << " "; // format output
  cout << "Element Name: " << name;
 
  map<string, string>::iterator it;
  for (it = attributes.begin(); it != attributes.end(); ++it)
    cout << "  " << it->first << " = " << it->second;
 
  cout << endl;
  for (i=0; i<data_lines.size(); i++) {
    for (spaces=0; spaces<=level; spaces++) cout << " "; // format output
    cout << data_lines[i] << endl;
  }
  for (i=0; i<children.size(); i++) {
    children[i]->Print(level);
  }
}

ReadFrom()

string ReadFrom

(

void

)

const

Return a string that contains a description of the location where the current XML element was read from.

Returns

a string describing the file name and line number where the element was read.

Definition at line 745 of file FGXMLElement.cpp.

{
  ostringstream message;
 
  message << endl
          << "In file " << GetFileName() << ": line " << GetLineNumber()
          << endl;
 
  return message.str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetAttributeValue()

bool SetAttributeValue	(	const std::string &	key,
		const std::string &	value
	)

Modifies an attribute.

Parameters

key	specifies the attribute key to modify the value of.
value	new key value (as a string).

Returns

false if it did not find any attribute with the requested key, true otherwise.

Definition at line 275 of file FGXMLElement.cpp.

{
  bool ret = HasAttribute(key);
  if (ret)
    attributes[key] = value;
 
  return ret;
}

Here is the call graph for this function:

SetFileName()

void SetFileName ( const std::string &  name )

inline

Set the name of the file in which the element has been read.

Parameters

name

file name

Definition at line 369 of file FGXMLElement.h.

{ file_name = name; }

SetLineNumber()

void SetLineNumber ( int  line )

inline

Set the line number at which the element has been read.

Parameters

line	line number.

Definition at line 364 of file FGXMLElement.h.

{ line_number = line; }

SetParent()

void SetParent ( Element *  p )

inline

This function sets the value of the parent class attribute to the supplied Element pointer.

Parameters

p	pointer to the parent Element.

Definition at line 341 of file FGXMLElement.h.

{parent = p;}

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• FGXMLElement.h
• FGXMLElement.cpp