[Avida-SVN] r1739 - in development: documentation source/analyze source/tools
ofria at myxo.css.msu.edu
ofria at myxo.css.msu.edu
Sat Jun 30 20:13:18 PDT 2007
Author: ofria
Date: 2007-06-30 23:13:17 -0400 (Sat, 30 Jun 2007)
New Revision: 1739
Modified:
development/documentation/analyze.html
development/source/analyze/cAnalyze.cc
development/source/analyze/cAnalyze.h
development/source/tools/cFlexVar.h
development/source/tools/tDataEntryCommand.h
development/source/tools/tList.h
Log:
Added a new FILTER command to analyze mode. With this command, you can filter down the genotypes
in the batch by any metric of your choice. For example, if you do:
FILTER fitness >= 1.5
This will limit the genotypes to those with a fitness of at least 1.5. You can base this on any
value available in the DETAIL command. So if you only want those organisms that can perform EQU,
you would do:
FILTER task.8 > 0
..and there you have it.
I've also updated the documentation to reflect this new command.
Other stuff:
Trimmed back further on the use of tDataCommand templates, replacing them with the more general
cFlexVar where possible.
Fixed member variables in cFlexVar to begin with m_ to match the coding standard for Avida.
Changed analyze command "TRUNCATELINEAGE" to "TRUNCATE_LINEAGE". Old version still works, but is
depricated.
Modified: development/documentation/analyze.html
===================================================================
--- development/documentation/analyze.html 2007-06-30 18:33:07 UTC (rev 1738)
+++ development/documentation/analyze.html 2007-07-01 03:13:17 UTC (rev 1739)
@@ -209,6 +209,14 @@
each trace as they would experience during an actual Avida run. By default,
the same inputs are provided every time to organisms in analysis mode.
</dd>
+<dt><strong>FILTER [<span class="cmdarg">stat</span>] [<span class="cmdarg">relation</span>] [<span class="cmdarg">test_value</span>] [<span class="cmdargopt">batch=current</span>]</strong></dt>
+<dd>
+ Perform the given test on all genotypes and Remove all those that do not pass. Stat indicates which
+ metric you want to compare, relation is the test to perform (==, !=, <, >, <=, or >=), and
+ test_value is the value to compare it to. For example <br>
+ <tt>FILTER fitness >= 1.5</tt><br>
+ will save only those genotypes with a fitness greater than or equal to 1.5.
+</dd>
<dt><strong>FIND_GENOTYPE [<span class="cmdargopt">type='num_cpus' ...</span>]</strong></dt>
<dd>
Remove all genotypes but the one selected. Type indicates which
Modified: development/source/analyze/cAnalyze.cc
===================================================================
--- development/source/analyze/cAnalyze.cc 2007-06-30 18:33:07 UTC (rev 1738)
+++ development/source/analyze/cAnalyze.cc 2007-07-01 03:13:17 UTC (rev 1739)
@@ -1021,6 +1021,82 @@
//////////////// Reduction....
+void cAnalyze::CommandFilter(cString cur_string)
+{
+ // First three arguments are: setting, relation, comparison
+ // Fourth argument is optional batch.
+
+ const int num_args = cur_string.CountNumWords();
+ cString stat_name = cur_string.PopWord();
+ cString relation = cur_string.PopWord();
+ cString test_value = cur_string.PopWord();
+
+ // Get the dynamic command to look up the stat we need.
+ tDataEntryCommand<cAnalyzeGenotype> * stat_command = GetGenotypeDataCommand(stat_name);
+
+
+ // Check for various possible errors before moving on...
+ bool error_found = false;
+ if (num_args < 3 || num_args > 4) {
+ cerr << "Error: Incorrect argument count." << endl;
+ error_found = true;
+ }
+
+ if (stat_command == NULL) {
+ cerr << "Error: Unknown stat '" << stat_name << "'" << endl;
+ error_found = true;
+ }
+
+ // Check relationship types. rel_ok[0] = less_ok; rel_ok[1] = same_ok; rel_ok[2] = gtr_ok
+ tArray<bool> rel_ok(3, false);
+ if (relation == "==") { rel_ok[1] = true; }
+ else if (relation == "!=") { rel_ok[0] = true; rel_ok[2] = true; }
+ else if (relation == "<") { rel_ok[0] = true; }
+ else if (relation == ">") { rel_ok[2] = true; }
+ else if (relation == "<=") { rel_ok[0] = true; rel_ok[1] = true; }
+ else if (relation == ">=") { rel_ok[1] = true; rel_ok[2] = true; }
+ else {
+ cerr << "Error: Unknown relation '" << relation << "'" << endl;
+ error_found = true;
+ }
+
+ if (error_found == true) {
+ cerr << "Format: FILTER [stat] [relation] [value] [batch=current]" << endl;
+ cerr << "Example: FILTER fitness >= 10.0" << endl;
+ if (exit_on_error) exit(1);
+ if (stat_command != NULL) delete stat_command;
+ return;
+ }
+
+
+ // If we made it this far, we're going ahead with the command...
+
+ if (m_world->GetVerbosity() >= VERBOSE_ON) {
+ cout << "Filtering batch " << cur_batch << " to genotypes where "
+ << stat_name << " " << relation << " " << test_value << endl;
+ }
+
+
+ // Loop through the genotypes and remove the entries that don't match.
+ tListIterator<cAnalyzeGenotype> batch_it(batch[cur_batch].List());
+ cAnalyzeGenotype * cur_genotype = NULL;
+ while ((cur_genotype = batch_it.Next()) != NULL) {
+ const cFlexVar value = stat_command->GetValue(cur_genotype);
+ int compare = 1 + CompareFlexStat(value, test_value);
+
+ // Check if we should eliminate this genotype...
+ if (rel_ok[compare] == false) {
+ delete batch_it.Remove();
+ }
+ }
+ delete stat_command;
+
+
+ // Adjust the flags on this batch
+ batch[cur_batch].SetLineage(false);
+ batch[cur_batch].SetAligned(false);
+}
+
void cAnalyze::FindGenotype(cString cur_string)
{
// If no arguments are passed in, just find max num_cpus.
@@ -1913,7 +1989,7 @@
int compare_type = data_command->GetCompareType();
compare = CompareFlexStat(cur_value, prev_value, compare_type);
}
- HTMLPrintStat(data_command, fp, compare);
+ HTMLPrintStat(cur_value, fp, compare, data_command->GetHtmlCellFlags(), data_command->GetNull());
}
else { // if (format_type == FILE_TYPE_TEXT) {
fp << data_command->GetValue() << " ";
@@ -2101,7 +2177,7 @@
cur_command->SetTarget(genotype);
genotype->SetSpecialArgs(cur_command->GetArgs());
if (file_type == FILE_TYPE_HTML) {
- HTMLPrintStat(cur_command, fp);
+ HTMLPrintStat(cur_command->GetValue(), fp, 0, cur_command->GetHtmlCellFlags(), cur_command->GetNull());
}
else { // if (file_type == FILE_TYPE_TEXT) {
fp << cur_command->GetValue() << " ";
@@ -2128,8 +2204,7 @@
// A filename and min and max batches must be included.
if (cur_string.CountNumWords() < 3) {
- cerr << "Error: must include filename, and min and max batch numbers."
- << endl;
+ cerr << "Error: must include filename, and min and max batch numbers." << endl;
if (exit_on_error) exit(1);
}
@@ -4546,7 +4621,8 @@
// cause landscaping to be triggered in a context that causes a crash,
// notably, if you don't provide any column parameters to MapTasks.. @JEB
if (file_type == FILE_TYPE_HTML) {
- HTMLPrintStat(data_command, fp, compare, !(data_command->HasArg("blank")));
+ HTMLPrintStat(test_value, fp, compare, data_command->GetHtmlCellFlags(), data_command->GetNull(),
+ !(data_command->HasArg("blank")));
}
else fp << test_value << " ";
@@ -7770,14 +7846,18 @@
// The following function will print a cell in a table with a background color based on a comparison
-// with its parent (the result of which is passed in as the 'compare' argument.
- void cAnalyze::HTMLPrintStat(tDataEntryCommand<cAnalyzeGenotype> * command, std::ostream& fp,
- int compare, bool print_text)
+// with its parent (the result of which is passed in as the 'compare' argument). The cell_flags argument
+// includes any other information you want in the <td> tag; 'null_text' is the text you want to replace a
+// zero with (sometime "none" or "N/A"); and 'print_text' is a bool asking if the text should be included at
+// all, or just the background color.
+
+void cAnalyze::HTMLPrintStat(const cFlexVar & value, std::ostream& fp, int compare,
+ const cString & cell_flags, const cString & null_text, bool print_text)
{
- fp << "<td " << command->GetHtmlCellFlags() << " ";
+ fp << "<td " << cell_flags << " ";
if (compare == COMPARE_RESULT_OFF) {
fp << "bgcolor=\"#" << m_world->GetConfig().COLOR_NEG2.Get() << "\">";
- if (print_text == true) fp << command->GetNull() << " ";
+ if (print_text == true) fp << null_text << " ";
else fp << " ";
return;
}
@@ -7792,7 +7872,7 @@
exit(0);
}
- if (print_text == true) fp << command->GetValue() << " ";
+ if (print_text == true) fp << value << " ";
else fp << " ";
}
@@ -7945,13 +8025,36 @@
}
+// Find a data entry bassed on a keywrod.
+tDataEntryCommand<cAnalyzeGenotype> * cAnalyze::GetGenotypeDataCommand(const cString & stat_entry)
+{
+ // Make sure we have all of the possibilities loaded...
+ SetupGenotypeDataList();
+
+ // Get the name from the beginning of the entry; everything else is arguments.
+ cString arg_list = stat_entry;
+ cString stat_name = arg_list.Pop(':');
+
+ // Create an iterator to scan the genotype data list for the current entry.
+ tListIterator< tDataEntryBase<cAnalyzeGenotype> > genotype_data_it(genotype_data_list);
+
+ while (genotype_data_it.Next() != (void *) NULL) {
+ if (genotype_data_it.Get()->GetName() == stat_name) {
+ return new tDataEntryCommand<cAnalyzeGenotype>(genotype_data_it.Get(), arg_list);
+ }
+ }
+
+ return NULL;
+}
+
+
// Pass in the arguments for a command and fill out the entries in list
// format....
void cAnalyze::LoadGenotypeDataList(cStringList arg_list,
tList< tDataEntryCommand<cAnalyzeGenotype> > & output_list)
{
- // For the moment, just put everything into the output list.
+ // Make sure we have all of the possibilities loaded...
SetupGenotypeDataList();
// If no args were given, load all of the stats.
@@ -8038,6 +8141,7 @@
AddLibraryDef("LOAD", &cAnalyze::LoadFile);
// Reduction commands...
+ AddLibraryDef("FILTER", &cAnalyze::CommandFilter);
AddLibraryDef("FIND_GENOTYPE", &cAnalyze::FindGenotype);
AddLibraryDef("FIND_ORGANISM", &cAnalyze::FindOrganism);
AddLibraryDef("FIND_LINEAGE", &cAnalyze::FindLineage);
@@ -8046,7 +8150,8 @@
AddLibraryDef("SAMPLE_ORGANISMS", &cAnalyze::SampleOrganisms);
AddLibraryDef("SAMPLE_GENOTYPES", &cAnalyze::SampleGenotypes);
AddLibraryDef("KEEP_TOP", &cAnalyze::KeepTopGenotypes);
- AddLibraryDef("TRUNCATELINEAGE", &cAnalyze::TruncateLineage);
+ AddLibraryDef("TRUNCATELINEAGE", &cAnalyze::TruncateLineage); // Depricate!
+ AddLibraryDef("TRUNCATE_LINEAGE", &cAnalyze::TruncateLineage);
// Direct output commands...
AddLibraryDef("PRINT", &cAnalyze::CommandPrint);
Modified: development/source/analyze/cAnalyze.h
===================================================================
--- development/source/analyze/cAnalyze.h 2007-06-30 18:33:07 UTC (rev 1738)
+++ development/source/analyze/cAnalyze.h 2007-07-01 03:13:17 UTC (rev 1739)
@@ -166,18 +166,17 @@
void ProcessCommands(tList<cAnalyzeCommand> & clist);
// Helper functions for printing to HTML files...
- void HTMLPrintStat(tDataEntryCommand<cAnalyzeGenotype> * command, std::ostream& fp, int compare=0,
- bool print_text=true);
+ void HTMLPrintStat(const cFlexVar & value, std::ostream& fp, int compare=0,
+ const cString & cell_flags="align=center", const cString & null_text="0", bool print_text=true);
int CompareFlexStat(const cFlexVar & org_stat, const cFlexVar & parent_stat, int compare_type=FLEX_COMPARE_MAX);
// Deal with genotype data list (linking keywords to stats)
void SetupGenotypeDataList();
- void LoadGenotypeDataList(cStringList arg_list,
- tList< tDataEntryCommand<cAnalyzeGenotype> > & output_list);
+ tDataEntryCommand<cAnalyzeGenotype> * GetGenotypeDataCommand(const cString & stat_entry);
+ void LoadGenotypeDataList(cStringList arg_list, tList< tDataEntryCommand<cAnalyzeGenotype> > & output_list);
void AddLibraryDef(const cString & name, void (cAnalyze::*_fun)(cString));
- void AddLibraryDef(const cString & name,
- void (cAnalyze::*_fun)(cString, tList<cAnalyzeCommand> &));
+ void AddLibraryDef(const cString & name, void (cAnalyze::*_fun)(cString, tList<cAnalyzeCommand> &));
cAnalyzeCommandDefBase * FindAnalyzeCommandDef(const cString & name);
void SetupCommandDefLibrary();
bool FunctionRun(const cString & fun_name, cString args);
@@ -212,6 +211,7 @@
void LoadFile(cString cur_string);
// Reduction
+ void CommandFilter(cString cur_string);
void FindGenotype(cString cur_string);
void FindOrganism(cString cur_string);
void FindLineage(cString cur_string);
Modified: development/source/tools/cFlexVar.h
===================================================================
--- development/source/tools/cFlexVar.h 2007-06-30 18:33:07 UTC (rev 1738)
+++ development/source/tools/cFlexVar.h 2007-07-01 03:13:17 UTC (rev 1739)
@@ -75,24 +75,24 @@
// Internal class for managing int type......
class cFlexVar_Int : public cFlexVar_Base {
private:
- int value;
+ int m_value;
public:
- cFlexVar_Int(int in_val) : value(in_val) { ; }
+ cFlexVar_Int(int in_val) : m_value(in_val) { ; }
~cFlexVar_Int() { ; }
- int AsInt() const { return value; }
- char AsChar() const { return (char) value; }
- double AsDouble() const { return (double) value; }
- void SetString(cString & in_str) const { in_str.Set("%d", value); }
+ int AsInt() const { return m_value; }
+ char AsChar() const { return (char) m_value; }
+ double AsDouble() const { return (double) m_value; }
+ void SetString(cString & in_str) const { in_str.Set("%d", m_value); }
eFlexType GetType() const { return TYPE_INT; }
- void Print(std::ostream& out) const { out << value; }
+ void Print(std::ostream& out) const { out << m_value; }
-#define CREATE_FLEX_VAR_INT_MATH_OP(OP, RETURN_TYPE) \
- RETURN_TYPE operator OP (int in_var) const { return value OP in_var; } \
- RETURN_TYPE operator OP (char in_var) const { return value OP (int) in_var; } \
- RETURN_TYPE operator OP (double in_var) const { return ((double) value) OP in_var; } \
- RETURN_TYPE operator OP (const cString & in_var) const { return ((double) value) OP in_var.AsDouble(); }
+#define CREATE_FLEX_VAR_INT_MATH_OP(OP, RETURN_TYPE) \
+ RETURN_TYPE operator OP (int in_var) const { return m_value OP in_var; } \
+ RETURN_TYPE operator OP (char in_var) const { return m_value OP (int) in_var; } \
+ RETURN_TYPE operator OP (double in_var) const { return ((double) m_value) OP in_var; } \
+ RETURN_TYPE operator OP (const cString & in_var) const { return ((double) m_value) OP in_var.AsDouble(); }
CREATE_FLEX_VAR_INT_MATH_OP(==, bool);
CREATE_FLEX_VAR_INT_MATH_OP(!=, bool);
@@ -108,24 +108,24 @@
class cFlexVar_Char : public cFlexVar_Base {
private:
- char value;
+ char m_value;
public:
- cFlexVar_Char(char in_val) : value(in_val) { ; }
+ cFlexVar_Char(char in_val) : m_value(in_val) { ; }
~cFlexVar_Char() { ; }
- int AsInt() const { return (int) value; }
- char AsChar() const { return value; }
- double AsDouble() const { return (double) value; }
- void SetString(cString & in_str) const { in_str.Set("%c", value); }
+ int AsInt() const { return (int) m_value; }
+ char AsChar() const { return m_value; }
+ double AsDouble() const { return (double) m_value; }
+ void SetString(cString & in_str) const { in_str.Set("%c", m_value); }
eFlexType GetType() const { return TYPE_CHAR; }
- void Print(std::ostream& out) const { out << value; }
+ void Print(std::ostream& out) const { out << m_value; }
-#define CREATE_FLEX_VAR_CHAR_MATH_OP(OP, RETURN_TYPE) \
- RETURN_TYPE operator OP (int in_var) const { return ((int) value) OP in_var; } \
- RETURN_TYPE operator OP (char in_var) const { return value OP in_var; } \
- RETURN_TYPE operator OP (double in_var) const { return ((double) value) OP in_var; } \
- RETURN_TYPE operator OP (const cString & in_var) const { return cString(&value, 1) OP in_var; }
+#define CREATE_FLEX_VAR_CHAR_MATH_OP(OP, RETURN_TYPE) \
+ RETURN_TYPE operator OP (int in_var) const { return ((int) m_value) OP in_var; } \
+ RETURN_TYPE operator OP (char in_var) const { return m_value OP in_var; } \
+ RETURN_TYPE operator OP (double in_var) const { return ((double) m_value) OP in_var; } \
+ RETURN_TYPE operator OP (const cString & in_var) const { return cString(&m_value, 1) OP in_var; }
CREATE_FLEX_VAR_CHAR_MATH_OP(==, bool);
CREATE_FLEX_VAR_CHAR_MATH_OP(!=, bool);
@@ -141,24 +141,24 @@
class cFlexVar_Double : public cFlexVar_Base {
private:
- double value;
+ double m_value;
public:
- cFlexVar_Double(double in_val) : value(in_val) { ; }
+ cFlexVar_Double(double in_val) : m_value(in_val) { ; }
~cFlexVar_Double() { ; }
- int AsInt() const { return (int) value; }
- char AsChar() const { return (char) value; }
- double AsDouble() const { return value; }
- void SetString(cString & in_str) const { in_str.Set("%f", value); }
+ int AsInt() const { return (int) m_value; }
+ char AsChar() const { return (char) m_value; }
+ double AsDouble() const { return m_value; }
+ void SetString(cString & in_str) const { in_str.Set("%f", m_value); }
eFlexType GetType() const { return TYPE_DOUBLE; }
- void Print(std::ostream& out) const { out << value; }
+ void Print(std::ostream& out) const { out << m_value; }
-#define CREATE_FLEX_VAR_DOUBLE_MATH_OP(OP, RETURN_TYPE) \
- RETURN_TYPE operator OP (int in_var) const { return value OP (double) in_var; } \
- RETURN_TYPE operator OP (char in_var) const { return value OP (double) in_var; } \
- RETURN_TYPE operator OP (double in_var) const { return value OP in_var; } \
- RETURN_TYPE operator OP (const cString & in_var) const { return value OP in_var.AsDouble(); }
+#define CREATE_FLEX_VAR_DOUBLE_MATH_OP(OP, RETURN_TYPE) \
+ RETURN_TYPE operator OP (int in_var) const { return m_value OP (double) in_var; } \
+ RETURN_TYPE operator OP (char in_var) const { return m_value OP (double) in_var; } \
+ RETURN_TYPE operator OP (double in_var) const { return m_value OP in_var; } \
+ RETURN_TYPE operator OP (const cString & in_var) const { return m_value OP in_var.AsDouble(); }
CREATE_FLEX_VAR_DOUBLE_MATH_OP(==, bool);
CREATE_FLEX_VAR_DOUBLE_MATH_OP(!=, bool);
@@ -174,24 +174,24 @@
class cFlexVar_String : public cFlexVar_Base {
private:
- cString value;
+ cString m_value;
public:
- cFlexVar_String(const cString & in_val) : value(in_val) { ; }
+ cFlexVar_String(const cString & in_val) : m_value(in_val) { ; }
~cFlexVar_String() { ; }
- int AsInt() const { return value.AsInt(); }
- char AsChar() const { return value[0]; }
- double AsDouble() const { return value.AsDouble(); }
- void SetString(cString & in_str) const { in_str = value; }
+ int AsInt() const { return m_value.AsInt(); }
+ char AsChar() const { return m_value[0]; }
+ double AsDouble() const { return m_value.AsDouble(); }
+ void SetString(cString & in_str) const { in_str = m_value; }
eFlexType GetType() const { return TYPE_STRING; }
- void Print(std::ostream& out) const { out << value; }
+ void Print(std::ostream& out) const { out << m_value; }
#define CREATE_FLEX_VAR_STRING_MATH_OP(OP, RETURN_TYPE) \
- RETURN_TYPE operator OP (int in_var) const { return value.AsDouble() OP (double) in_var; } \
- RETURN_TYPE operator OP (char in_var) const { return value OP cString(&in_var, 1); } \
- RETURN_TYPE operator OP (double in_var) const { return value.AsDouble() OP in_var; } \
- RETURN_TYPE operator OP (const cString & in_var) const { return value OP in_var; }
+ RETURN_TYPE operator OP (int in_var) const { return m_value.AsDouble() OP (double) in_var; } \
+ RETURN_TYPE operator OP (char in_var) const { return m_value OP cString(&in_var, 1); } \
+ RETURN_TYPE operator OP (double in_var) const { return m_value.AsDouble() OP in_var; } \
+ RETURN_TYPE operator OP (const cString & in_var) const { return m_value OP in_var; }
CREATE_FLEX_VAR_STRING_MATH_OP(==, bool);
CREATE_FLEX_VAR_STRING_MATH_OP(!=, bool);
@@ -201,67 +201,67 @@
CREATE_FLEX_VAR_STRING_MATH_OP(>=, bool);
};
- cFlexVar_Base * var;
+ cFlexVar_Base* m_var;
public:
// Setup constructors to be able to build this variable from whatever input we need.
- cFlexVar(const cFlexVar & in_var) : var(NULL) {
- if (in_var.GetType() == TYPE_INT) var = new cFlexVar_Int( in_var.AsInt() );
- else if (in_var.GetType() == TYPE_CHAR) var = new cFlexVar_Char( in_var.AsChar() );
- else if (in_var.GetType() == TYPE_DOUBLE) var = new cFlexVar_Double( in_var.AsDouble() );
- else if (in_var.GetType() == TYPE_STRING) var = new cFlexVar_String( in_var.AsString() );
+ cFlexVar(const cFlexVar & in_var) : m_var(NULL) {
+ if (in_var.GetType() == TYPE_INT) m_var = new cFlexVar_Int( in_var.AsInt() );
+ else if (in_var.GetType() == TYPE_CHAR) m_var = new cFlexVar_Char( in_var.AsChar() );
+ else if (in_var.GetType() == TYPE_DOUBLE) m_var = new cFlexVar_Double( in_var.AsDouble() );
+ else if (in_var.GetType() == TYPE_STRING) m_var = new cFlexVar_String( in_var.AsString() );
}
- cFlexVar(int in_value = 0) : var(new cFlexVar_Int(in_value)) { ; }
- cFlexVar(char in_value) : var(new cFlexVar_Char(in_value)) { ; }
- cFlexVar(double in_value) : var(new cFlexVar_Double(in_value)) { ; }
- cFlexVar(const cString & in_value) : var(new cFlexVar_String(in_value)) { ; }
- ~cFlexVar() { delete var; }
+ cFlexVar(int in_value = 0) : m_var(new cFlexVar_Int(in_value)) { ; }
+ cFlexVar(char in_value) : m_var(new cFlexVar_Char(in_value)) { ; }
+ cFlexVar(double in_value) : m_var(new cFlexVar_Double(in_value)) { ; }
+ cFlexVar(const cString & in_value) : m_var(new cFlexVar_String(in_value)) { ; }
+ ~cFlexVar() { delete m_var; }
// Setup an accessor to determine the native type of this variable.
- eFlexType GetType() const { return var->GetType(); }
- void Print(std::ostream& out) const { var->Print(out); }
+ eFlexType GetType() const { return m_var->GetType(); }
+ void Print(std::ostream& out) const { m_var->Print(out); }
// Setup accessors to get this variable as any type we might need.
- int AsInt() const { return var->AsInt(); }
- char AsChar() const { return var->AsChar(); }
- double AsDouble() const { return var->AsDouble(); }
- cString AsString() const { return var->AsString(); }
- void SetString(cString & in_str) const { var->SetString(in_str); }
+ int AsInt() const { return m_var->AsInt(); }
+ char AsChar() const { return m_var->AsChar(); }
+ double AsDouble() const { return m_var->AsDouble(); }
+ cString AsString() const { return m_var->AsString(); }
+ void SetString(cString & in_str) const { m_var->SetString(in_str); }
// Setup a way to convert the native types
- int MakeInt() { int val = AsInt(); delete var; var = new cFlexVar_Int(val); return val; }
- char MakeChar() { char val = AsChar(); delete var; var = new cFlexVar_Char(val); return val; }
- double MakeDouble() { double val = AsDouble(); delete var; var = new cFlexVar_Double(val); return val; }
- cString MakeString() { cString val = AsString(); delete var; var = new cFlexVar_String(val); return val; }
+ int MakeInt() { int val = AsInt(); delete m_var; m_var = new cFlexVar_Int(val); return val; }
+ char MakeChar() { char val = AsChar(); delete m_var; m_var = new cFlexVar_Char(val); return val; }
+ double MakeDouble() { double val = AsDouble(); delete m_var; m_var = new cFlexVar_Double(val); return val; }
+ cString MakeString() { cString val = AsString(); delete m_var; m_var = new cFlexVar_String(val); return val; }
// Setup assignment operators...
cFlexVar & operator=(const cFlexVar & in_var) {
- delete var;
- if (in_var.GetType() == TYPE_INT) var = new cFlexVar_Int( in_var.AsInt() );
- else if (in_var.GetType() == TYPE_CHAR) var = new cFlexVar_Char( in_var.AsChar() );
- else if (in_var.GetType() == TYPE_DOUBLE) var = new cFlexVar_Double( in_var.AsDouble() );
- else if (in_var.GetType() == TYPE_STRING) var = new cFlexVar_String( in_var.AsString() );
+ delete m_var;
+ if (in_var.GetType() == TYPE_INT) m_var = new cFlexVar_Int( in_var.AsInt() );
+ else if (in_var.GetType() == TYPE_CHAR) m_var = new cFlexVar_Char( in_var.AsChar() );
+ else if (in_var.GetType() == TYPE_DOUBLE) m_var = new cFlexVar_Double( in_var.AsDouble() );
+ else if (in_var.GetType() == TYPE_STRING) m_var = new cFlexVar_String( in_var.AsString() );
return *this;
}
- cFlexVar & operator=(int in_value) { delete var; var = new cFlexVar_Int(in_value); return *this; }
- cFlexVar & operator=(char in_value) { delete var; var = new cFlexVar_Char(in_value); return *this; }
- cFlexVar & operator=(double in_value) { delete var; var = new cFlexVar_Double(in_value); return *this; }
- cFlexVar & operator=(const cString & in_value) { delete var; var = new cFlexVar_String(in_value); return *this; }
- cFlexVar & operator=(char * in_value) { delete var; var = new cFlexVar_String(in_value); return *this; }
+ cFlexVar & operator=(int in_value) { delete m_var; m_var = new cFlexVar_Int(in_value); return *this; }
+ cFlexVar & operator=(char in_value) { delete m_var; m_var = new cFlexVar_Char(in_value); return *this; }
+ cFlexVar & operator=(double in_value) { delete m_var; m_var = new cFlexVar_Double(in_value); return *this; }
+ cFlexVar & operator=(const cString & in_value) { delete m_var; m_var = new cFlexVar_String(in_value); return *this; }
+ cFlexVar & operator=(char * in_value) { delete m_var; m_var = new cFlexVar_String(in_value); return *this; }
// The following macro will forward all of the commands with the associated operator to the internal class.
-#define FORWARD_FLEX_VAR_OP(OP, RETURN_TYPE) \
- RETURN_TYPE operator OP(int in_var) const { return (*var) OP in_var; } \
- RETURN_TYPE operator OP(char in_var) const { return (*var) OP in_var; } \
- RETURN_TYPE operator OP(double in_var) const { return (*var) OP in_var; } \
- RETURN_TYPE operator OP(const cString & in_var) const { return (*var) OP in_var; } \
- RETURN_TYPE operator OP(const cFlexVar & in_var) const { \
- const eFlexType type = in_var.GetType(); \
- if (type == TYPE_INT) return (*var) OP in_var.AsInt(); \
- else if (type == TYPE_CHAR) return (*var) OP in_var.AsChar(); \
- else if (type == TYPE_DOUBLE) return (*var) OP in_var.AsDouble(); \
- else /* if (type == TYPE_STRING) */ return (*var) OP in_var.AsString(); \
+#define FORWARD_FLEX_VAR_OP(OP, RETURN_TYPE) \
+ RETURN_TYPE operator OP(int in_var) const { return (*m_var) OP in_var; } \
+ RETURN_TYPE operator OP(char in_var) const { return (*m_var) OP in_var; } \
+ RETURN_TYPE operator OP(double in_var) const { return (*m_var) OP in_var; } \
+ RETURN_TYPE operator OP(const cString & in_var) const { return (*m_var) OP in_var; } \
+ RETURN_TYPE operator OP(const cFlexVar & in_var) const { \
+ const eFlexType type = in_var.GetType(); \
+ if (type == TYPE_INT) return (*m_var) OP in_var.AsInt(); \
+ else if (type == TYPE_CHAR) return (*m_var) OP in_var.AsChar(); \
+ else if (type == TYPE_DOUBLE) return (*m_var) OP in_var.AsDouble(); \
+ else /* if (type == TYPE_STRING) */ return (*m_var) OP in_var.AsString(); \
}
FORWARD_FLEX_VAR_OP(==, bool)
Modified: development/source/tools/tDataEntryCommand.h
===================================================================
--- development/source/tools/tDataEntryCommand.h 2007-06-30 18:33:07 UTC (rev 1738)
+++ development/source/tools/tDataEntryCommand.h 2007-07-01 03:13:17 UTC (rev 1739)
@@ -63,7 +63,6 @@
cFlexVar GetValue(const T * temp_target) const { return data_entry->Get(temp_target); }
void SetTarget(T * _target) { data_entry->SetTarget(_target); }
- // int Compare(T * other) const { return data_entry->Compare(other); }
bool SetValue(const cString & value) { return data_entry->Set(value); }
};
Modified: development/source/tools/tList.h
===================================================================
--- development/source/tools/tList.h 2007-06-30 18:33:07 UTC (rev 1738)
+++ development/source/tools/tList.h 2007-07-01 03:13:17 UTC (rev 1739)
@@ -472,7 +472,7 @@
// This is an extended version of tList that contains extra functions to
-// allow method pointer associated with the object type being listed.
+// allow method pointers associated with the object type being listed.
template <class T> class tListPlus : public tList<T> {
#if USE_tMemTrack
tMemTrack<tListPlus<T> > mt;
More information about the Avida-cvs
mailing list