#include <main.h>

Collaboration diagram for ComSwitch:

Public Member Functions
	ComSwitch ()
	Default Constructor. More...

	ComSwitch (int rArgc, char *rpArgv[])
	Constructor with program arguments. More...

	~ComSwitch ()
	Free memory, and close open file handles. More...

bool	parseOptions ()
	Parse command options, begin logging. More...

void	setArguments (int rArgc, char *rpArgv[])
	Set command line arguments. More...

bool	requiredArgsSet ()
	Check if required arguments are set. More...

int	getFileDimensions (int rFile)
	Get file dimensions. More...

std::vector< adj_map >	getConvFactor (int rFile)
	Get conversion factors. More...

std::vector< adj_map >	getNormVal (int rFile)
	Get normalization values. More...

bool	getVerbosity ()
	Get logging verbosity. More...

ifstream &	getInputFile (int rFile)
	Get Input File. More...

string	getFileName (int rFile)
	Get File Name. More...

ofstream &	getLogFile ()
	Get Log File. More...

string	getOutPrefix ()
	Get OutPrefix. More...

bool	isRangeSpecified ()
	Returns a flag that indicates whether a range was supplied to this instance of CommSwitch. More...

BoundingBox	getRange ()
	Returns a bounding box corresponding to the range of the region of interest. More...

std::vector< cmp_map >	getComparisonList ()
	Get Comparison List. More...

std::vector< std::vector< int > >	getFieldMappings (int rFile)
	Get the field mapping vector for the specified file. More...

std::vector< index_order >	getIndexOrder (int rFile)
	Get the index order for the specified file. More...

Private Member Functions
void	setDefaultVars ()
	Set default member variables. More...

bool	readOptions ()
	Set option string and long opts struct then parse arguments. More...

bool	parseValuesFromArguments (string rOptString, const struct option *rLongOpts)
	Read and parse options from array. More...

bool	initializeFileStreams ()
	Initialize file streams. More...

bool	writeLogHeader ()
	Write the log file header Program Name - switches Input files. More...

Private Attributes
bool	mHelp
	Help flag is set from command line options. More...

int	mArgc

char **	mpArgv
	Number of arguments. More...

bool	mBadSwitch
	The actual command line arguments. More...

int	mInfile1Dimensions
	Bad command line switch detection. More...

int	mInfile2Dimensions
	Infile 1 independent variable dimensions. More...

bool	restrictToRange
	Infile 2 independent variable dimensions. More...

BoundingBox	mRange
	Flag used to indicate if the metrics will be restricted to a given range. More...

std::vector< adj_map >	mFile1ConversionFactor
	Range of region of interest. More...

std::vector< adj_map >	mFile2ConversionFactor

std::vector< adj_map >	mFile1Norm

std::vector< adj_map >	mFile2Norm

ofstream	mLog

string	mOutPrefix

string	mInfileName1

string	mInfileName2

ifstream	mInfile1

ifstream	mInfile2

std::vector< cmp_map >	mComparisonList

std::vector< std::vector< int > >	mFieldMappingsFile1

std::vector< std::vector< int > >	mFieldMappingsFile2

std::vector< index_order >	mIndexOrderFile1

std::vector< index_order >	mIndexOrderFile2

bool	mLoud

Detailed Description

Definition at line 32 of file main.h.

Constructor & Destructor Documentation

ComSwitch ( )

Default Constructor.

Definition at line 348 of file main.cpp.

References setDefaultVars().

                     {
 
     //Set default values
     setDefaultVars();
 }

Here is the call graph for this function:

ComSwitch	(	int	rArgc,
		char *	rpArgv[]
	)

Constructor with program arguments.

Parameters

rArgc	Number of arguments
rpArgv	Actual arguments

Definition at line 354 of file main.cpp.

References setArguments(), and setDefaultVars().

                                           {
 
     //Set default values
     setDefaultVars();
 
     setArguments(argc, argv);
 }

Here is the call graph for this function:

~ComSwitch ( )

Free memory, and close open file handles.

Definition at line 428 of file main.cpp.

References mInfile1, mInfile2, and mLog.

                      {
 
     //Close files
     mLog.close();
     mInfile1.close();
     mInfile2.close();
 }

Member Function Documentation

std::vector< cmp_map > getComparisonList ( )

Get Comparison List.

Returns: Vector comparison list

Definition at line 550 of file main.cpp.

References mComparisonList.

Referenced by compareFiles().

                                                {
     return mComparisonList;
 }

Here is the caller graph for this function:

std::vector< adj_map > getConvFactor ( int rFile )

Get conversion factors.

Parameters

rFile File number (1 or 2)

Returns: Vector of conversion factors for the file

Definition at line 474 of file main.cpp.

References mFile1ConversionFactor, and mFile2ConversionFactor.

Referenced by openAndParseFiles().

                                                    {
     if(file == 1){
         return mFile1ConversionFactor;
     }
     else if(file == 2){
         return mFile2ConversionFactor;
     }
 
     std::vector<adj_map> ret;
     return ret;
 }

Here is the caller graph for this function:

std::vector< std::vector< int > > getFieldMappings ( int rFile )

Get the field mapping vector for the specified file.

Parameters

rFile File number (1 or 2)

Returns: Field mapping vector

Definition at line 557 of file main.cpp.

References empty(), mFieldMappingsFile1, and mFieldMappingsFile2.

Referenced by openAndParseFiles().

                                                                 {
     switch( rFile ){
 
         case 1 :
             return mFieldMappingsFile1;
             break;
 
         case 2 :
             return mFieldMappingsFile2;
             break;
 
         default :
             std::vector< std::vector<int> > empty;
             return empty;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int getFileDimensions ( int rFile )

Get file dimensions.

Parameters

rFile File number (1 or 2)

Returns: Number of independent dimensions

Definition at line 462 of file main.cpp.

References mInfile1Dimensions, and mInfile2Dimensions.

Referenced by openAndParseFiles().

                                         {
     if(file == 1)
         return mInfile1Dimensions;
     else if(file == 2)
         return mInfile2Dimensions;
     else
         return -1;
 }

Here is the caller graph for this function:

string getFileName ( int rFile )

Get File Name.

Parameters

rFile File number (1 or 2)

Returns: File name

Definition at line 523 of file main.cpp.

References mInfileName1, and mInfileName2.

Referenced by openAndParseFiles().

                                       {
     string ret("");
     if(rFile == 1)
         ret = mInfileName1;
     else if(rFile == 2)
         ret = mInfileName2;
 
     return ret;
 }

Here is the caller graph for this function:

std::vector< index_order > getIndexOrder ( int rFile )

Get the index order for the specified file.

Parameters

rFile File number (1 or 2)

Returns: Index order vector

Definition at line 577 of file main.cpp.

References empty(), mIndexOrderFile1, and mIndexOrderFile2.

Referenced by openAndParseFiles().

                                                         {
     switch( rFile ){
         
         case 1 :
             return mIndexOrderFile1;
             break;
 
         case 2 :
             return mIndexOrderFile2;
             break;
 
         default :
             std::vector<index_order> empty;
             return empty;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ifstream & getInputFile ( int rFile )

Get Input File.

Parameters

rFile File number (1 or 2)

Returns: Reference to ifstream

Definition at line 511 of file main.cpp.

References mInfile1, and mInfile2.

Referenced by openAndParseFiles().

                                            {
 
     if(rFile == 1)
         return mInfile1;
     else
         return mInfile2;
 
 }

Here is the caller graph for this function:

ofstream & getLogFile ( )

Get Log File.

Returns: Reference to ofstream logfile

Definition at line 536 of file main.cpp.

References mLog.

Referenced by compareFiles(), and openAndParseFiles().

                                 {
     return mLog;
 }

Here is the caller graph for this function:

std::vector< adj_map > getNormVal ( int rFile )

Get normalization values.

Parameters

rFile File number (1 or 2)

Returns: Vector of normalization values for the file

Definition at line 489 of file main.cpp.

References mFile1Norm, and mFile2Norm.

Referenced by openAndParseFiles().

                                                 {
     if(file == 1){
         return mFile1Norm;
     }
     else if(file == 2){
         return mFile2Norm;
     }
 
     std::vector<adj_map> ret;
     return ret;
 }

Here is the caller graph for this function:

string getOutPrefix ( )

Get OutPrefix.

Returns: OutPrefix string

Definition at line 543 of file main.cpp.

References mOutPrefix.

Referenced by compareFiles().

                               {
     return mOutPrefix;
 }

Here is the caller graph for this function:

BoundingBox getRange ( )

inline

Returns a bounding box corresponding to the range of the region of interest.

Returns: b a bounding box instance.

See Also: BoundingBox

Definition at line 144 of file main.h.

Referenced by compareFiles().

         {
                 return this ->mRange;
         }

Here is the caller graph for this function:

bool getVerbosity ( )

Get logging verbosity.

Returns: True if logging is verbose, otherwise false

Definition at line 504 of file main.cpp.

References mLoud.

Referenced by compareFiles(), and openAndParseFiles().

                             {
     return mLoud;
 }

Here is the caller graph for this function:

bool initializeFileStreams ( )

private

Initialize file streams.

Returns: True on successful initialization false on failure

Definition at line 922 of file main.cpp.

References mInfile1, mInfile2, mInfileName1, mInfileName2, mLog, mOutPrefix, and printUsage().

Referenced by parseOptions().

                                      {
 
     //Intialize Log File
     if(mOutPrefix.compare("") != 0){
         mLog.open((mOutPrefix + ".log").c_str(), ofstream::out);
 
         if(!mLog.is_open()){
             string err_ps("Invalid Output File Prefix Specified: Directory may not exist");
             printUsage(err_ps);
 
             return false;
         }
     }
 
     //Initialize Input File 1
     if(mInfileName1.compare("") != 0){
         mInfile1.open(mInfileName1.c_str(), ifstream::in);
 
         if(!mInfile1.is_open()){
             string err_ps("Could Not Open Input File 1: ");
             err_ps += mInfileName1;
             printUsage(err_ps);
 
             return false;
         }
     }
 
     //Initialize Input File 2
     if(mInfileName2.compare("") != 0){
         mInfile2.open(mInfileName2.c_str(), ifstream::in);
 
         if(!mInfile2.is_open()){
             string err_ps("Could Not Open Input File 2: ");
             err_ps += mInfileName2;
             printUsage(err_ps);
 
             return false;
         }
     }
 
     return true;
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool isRangeSpecified ( )

inline

Returns a flag that indicates whether a range was supplied to this instance of CommSwitch.

Returns

Definition at line 133 of file main.h.

Referenced by compareFiles().

         {
                 return this ->restrictToRange;
         };

Here is the caller graph for this function:

bool parseOptions ( )

Parse command options, begin logging.

Returns: True if options were successfully parsed

Definition at line 395 of file main.cpp.

References initializeFileStreams(), mBadSwitch, mHelp, printUsage(), readOptions(), requiredArgsSet(), and writeLogHeader().

Referenced by main().

                             {
 
     //Parse Arguments
     readOptions();
 
     if( mHelp ){
         printUsage(string(""));
         exit(0);
     }
 
     if( mBadSwitch ){
         printUsage(string(""));
         exit(1);
     }
 
     if( !initializeFileStreams() )
         exit(1);
 
     //Check completeness
     if(requiredArgsSet()){
         writeLogHeader();
     }
     else{
         string err_ps("Missing Arguments");
         printUsage(err_ps);
 
         exit(1);
     }
 
     return true;
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool parseValuesFromArguments	(	string	rOptString,
		const struct option *	rLongOpts
	)

private

Read and parse options from array.

Parameters

rOptString	Short options string
rLongOpts	Long options struct

Returns: True if options were successfully parsed

Definition at line 624 of file main.cpp.

References cimg_library::cimg::atof(), check_non_numeric_str(), CGAL::compare(), adj_map::factor, cmp_map::file1_partitions, cmp_map::file2_partition, mArgc, mBadSwitch, mComparisonList, cmp_map::metric, mFieldMappingsFile1, mFieldMappingsFile2, mFile1ConversionFactor, mFile1Norm, mFile2ConversionFactor, mFile2Norm, mHelp, mIndexOrderFile1, mIndexOrderFile2, mInfile1Dimensions, mInfile2Dimensions, mInfileName1, mInfileName2, mLoud, mOutPrefix, mpArgv, mRange, index_order::order, index_order::partition_number, restrictToRange, BoundingBox::setCoordinates(), str_tokenize(), cmp_map::var1, cmp_map::var2, and adj_map::variable.

Referenced by readOptions().

                                                                         {
 
 
     //Parse options
     int opt = 0;
     opt = getopt_long( mArgc, mpArgv, rOptString.c_str(), rLongOpts, NULL );
 
     while( opt != -1 ){
         switch( opt ){
 
             //Outfile
             case 'o': {
                 mOutPrefix = optarg;
             } break;
 
             //File 1
             case '1': {
                 std::vector<string> infile_info = str_tokenize(string(optarg), string(":"));
 
                 if(infile_info.size() != 2)
                     break;
 
                 if( check_non_numeric_str( infile_info[1] ) )
                     break;
 
                 mInfileName1 = infile_info[0];
                 mInfile1Dimensions = atoi(infile_info[1].c_str());
             } break;
 
             //File 2
             case '2': {
                 std::vector<string> infile_info = str_tokenize(string(optarg), string(":"));
 
                 if(infile_info.size() != 2)
                     break;
 
                 if( check_non_numeric_str( infile_info[1] ) )
                     break;
 
                 mInfileName2 = infile_info[0];
                 mInfile2Dimensions = atoi(infile_info[1].c_str());
             } break;
 
             //Field mapping
             case 'f': {
                 std::vector<string> field_map = str_tokenize(string(optarg), string(":/"));
 
                 if(field_map.size() != 3)
                     break;
 
                 //Make sure we only have numerals or "null"
                 if( check_non_numeric_str( field_map[0] ) ||
                     check_non_numeric_str( field_map[1] ) ){
                     
                     if(check_non_numeric_str( field_map[2] ) &&
                        field_map[2].compare("null") != 0     ){
                         break;
                     }
                 }
 
                 //Pack entry
                 vector<int> entry;
                 entry.push_back( atoi(field_map[1].c_str()) );
 
                 if(field_map[2].compare("null") != 0)
                     entry.push_back( atoi(field_map[2].c_str()) );
                 else
                     entry.push_back( -1 );
 
                 //Add entry to list of mappings
                 switch( atoi(field_map[0].c_str()) ){
 
                     case 1:
                         mFieldMappingsFile1.push_back(entry);
                     break;
 
                     case 2:
                         mFieldMappingsFile2.push_back(entry);
                         break;
 
                     default:
                         break;
 
                 }
 
             } break;
 
             //Index order
             case 'i': {
                 std::vector<string> order = str_tokenize(string(optarg), string(":,"));
                 std::vector<int> order_int;
 
                 if(order.size() <= 0)
                     break;
 
                 //Get the file number
                 int file_num = 0;
                 if(!check_non_numeric_str(order[0])){
                     file_num = atoi(order[0].c_str());
 
                     if(file_num != 1 && file_num != 2){
                         break;
                     }
                 }
 
                 //Get the partition number
                 int partition_num = -1;
                 if(!check_non_numeric_str(order[1])){
                     partition_num = atoi(order[1].c_str());
                     if(partition_num < 0)
                         break;
                 }
 
                 bool non_numeric = false;
 
                 //Loop through remaining values
                 for(int token_num = 2; token_num < order.size(); token_num++){
                     
                     if(!check_non_numeric_str(order[token_num])){
 
                         //Convert to int
                         int value = atoi(order[token_num].c_str());
 
                         //Check for repeats
                         bool repeat = false;
                         for(int prev_num = 0; prev_num < order_int.size(); prev_num++){
                             if(value == order_int[prev_num]){
                                 repeat = true;
                                 break;
                             }
                         }
 
                         //Add value to the list
                         if(!repeat)
                             order_int.push_back(value);
                     }
                     else{
                         non_numeric = true;
                         break;
                     }
                 }
 
                 //Discard all values if any are non-numeric
                 if(non_numeric)
                     break;
                 
                 index_order curr_index;
                 curr_index.order = order_int;
                 curr_index.partition_number = partition_num;
 
                 if(file_num == 1)
                     mIndexOrderFile1.push_back(curr_index);
                 else if(file_num == 2)
                     mIndexOrderFile2.push_back(curr_index);
                 
             } break;
 
             //Conversion factor
             case 'c': {
                 std::vector<string> conv_info = str_tokenize(string(optarg), string(":"));
 
                 if(conv_info.size() != 3)
                     break;
 
                 adj_map add;
                 add.variable = atoi(conv_info[1].c_str());
                 add.factor = strtold(conv_info[2].c_str(), NULL);
 
                 int file = atoi(conv_info[0].c_str());
 
                 if(file == 1)
                     mFile1ConversionFactor.push_back(add);
                 else if(file == 2)
                     mFile2ConversionFactor.push_back(add);
 
             } break;
 
             // Range used for cropping
             case 'r': {
 
                                                                 // Set the flag to indicate that matrics are going to be restricted to the user-supplied range.
                                                                 restrictToRange = true;
 
                                                                 std::vector< std::string > conv_info = str_tokenize( std::string( optarg ), std::string( "," ) );
 
                                                                 //
                                                                 // The expected parameters are of the form "xmin,ymin,zmin,xmax,ymax,zmax"
                                                                 //
                                                                 if( conv_info.size( ) != 6 )
                                                                         break;
 
                                                                 double xmin = std::atof( conv_info[ 0 ].c_str( ) );
                                                                 double ymin = std::atof( conv_info[ 1 ].c_str( ) );
                                                                 double zmin = std::atof( conv_info[ 2 ].c_str( ) );
                                                                 double xmax = std::atof( conv_info[ 3 ].c_str( ) );
                                                                 double ymax = std::atof( conv_info[ 4 ].c_str( ) );
                                                                 double zmax = std::atof( conv_info[ 5 ].c_str( ) );
 
                                                                 mRange.setCoordinates( xmin, ymin, zmin, xmax, ymax, zmax );
 
             }
 
             //Normalization factor
             case 'n': {
                 std::vector<string> norm_info = str_tokenize(string(optarg), string(":"));
 
                 if(norm_info.size() != 3)
                     break;
 
                 adj_map add;
                 add.variable = atoi(norm_info[1].c_str());
                 add.factor = strtold(norm_info[2].c_str(), NULL);
 
                 int file = atoi(norm_info[0].c_str());
 
                 if(file == 1)
                     mFile1Norm.push_back(add);
                 else if(file == 2)
                     mFile2Norm.push_back(add);
             } break;
 
             //Comparison
             case 'm': {
                 std::vector<string> comp = str_tokenize(string(optarg), string("=:/"));
 
                 if(comp.size() != 5)
                     break;
 
                 if( check_non_numeric_str( comp[0] ) ||
                     check_non_numeric_str( comp[2] ) ||
                     check_non_numeric_str( comp[3] ) ||
                     check_non_numeric_str( comp[4] )    ){
 
                     break;
                 }
 
                 bool bad_entry = false;
 
                 //Get file 1's partition list
                 std::vector<string> partitions_1 = str_tokenize(string(comp[1]), string(","));               
                 std::vector<int> partitions_1_int;
                 
                 for(int token_num = 0; token_num < partitions_1.size(); token_num++){
                     
                     if(check_non_numeric_str( partitions_1[token_num] )){
                         bad_entry = true;
                         break;
                     }
 
                     partitions_1_int.push_back( atoi(partitions_1[token_num].c_str()) );
                 }
 
                 if(bad_entry)
                     break;
 
                 cmp_map add_cmp;
                 add_cmp.metric = atoi(comp[0].c_str());
                 add_cmp.file1_partitions = partitions_1_int;
                 add_cmp.var1 = atoi(comp[2].c_str());
                 add_cmp.file2_partition = atoi(comp[3].c_str());
                 add_cmp.var2 = atoi(comp[4].c_str());
 
                 mComparisonList.push_back(add_cmp);
 
             } break;
 
             //Logging Level
             case 'v': {
                 mLoud = true;
             } break;
 
             //Help message
             case 'h': {
                 mHelp = true;
                 return false;
             } break;
 
             case 0: {
                 mBadSwitch = true;
                 return false;
             } break;
 
             case '?': {
                 mBadSwitch = true;
                 return false;
             } break;
         }
 
         opt = getopt_long( mArgc, mpArgv, rOptString.c_str(), rLongOpts, NULL );
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool readOptions ( )

private

Set option string and long opts struct then parse arguments.

Returns: True if options were successfully parsed

Definition at line 597 of file main.cpp.

References cimg_library::cimg::option(), and parseValuesFromArguments().

Referenced by parseOptions().

                            {
 
     //Short options
     string opt_string("o:1:2:f:i:c:n:m:r:vh");
 
     //Long options
     static const struct option long_opts[] = {
         {"outfile",     required_argument, NULL, 'o'},
         {"infile1",     required_argument, NULL, '1'},
         {"infile2",     required_argument, NULL, '2'},
         {"fieldmap",    required_argument, NULL, 'f'},
         {"index-order", required_argument, NULL, 'i'},
         {"conv",        required_argument, NULL, 'c'},
         {"norm",        required_argument, NULL, 'n'},
         {"range",           required_argument, NULL, 'r'},
         {"metric",      required_argument, NULL, 'm'},
         {"verbose",     no_argument,       NULL, 'v'},
         {"help",        no_argument,       NULL, 'h'},
         {NULL,          no_argument,       NULL,  0 }
     };
 
     return parseValuesFromArguments(opt_string, long_opts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool requiredArgsSet ( )

Check if required arguments are set.

Returns: True if all required args are set, otherwise false

Definition at line 436 of file main.cpp.

References mBadSwitch, mComparisonList, mInfile1, mInfile1Dimensions, mInfile2, mInfile2Dimensions, mLog, and mOutPrefix.

Referenced by parseOptions().

                                {
 
     if( mOutPrefix.compare("") == 0 )
         return false;
 
     if( !mLog.is_open() )
         return false;
 
     if( !mInfile1.is_open() || !mInfile2.is_open() )
         return false;
 
     if( mComparisonList.size() <= 0 )
         return false;
 
     if( mInfile1Dimensions <= 0 || mInfile2Dimensions <= 0 )
         return false;
 
     if( mBadSwitch )
         return false;
 
     return true;
 }

Here is the caller graph for this function:

void setArguments	(	int	rArgc,
		char *	rpArgv[]
	)

Set command line arguments.

Parameters

rArgc	Number of arguments
rpArgv	Actual arguments

Definition at line 365 of file main.cpp.

References mArgc, and mpArgv.

Referenced by ComSwitch(), and main().

                                                      {
     mArgc = rArgc;
     mpArgv = rpArgv;
 }

Here is the caller graph for this function:

void setDefaultVars ( )

private

Set default member variables.

Definition at line 373 of file main.cpp.

References mBadSwitch, mHelp, mInfile1Dimensions, mInfile2Dimensions, mLoud, and restrictToRange.

Referenced by ComSwitch().

                               {
 
     //Help message flag
     mHelp = false;
 
     //Bad command line switches
     mBadSwitch = false;
 
     //File dimensions
     mInfile1Dimensions = -1;
     mInfile2Dimensions = -1;
 
     //Log verbosity
     mLoud = false;
 
     // Restrict search
     restrictToRange = false;
 }

Here is the caller graph for this function:

bool writeLogHeader ( )

private

Write the log file header Program Name - switches Input files.

Definition at line 969 of file main.cpp.

References mArgc, mInfileName1, mInfileName2, mLog, and mpArgv.

Referenced by parseOptions().

                               {
 
     //Write the program name to the log file
     if(mArgc > 0)
         mLog << mpArgv[0] << endl;
 
     mLog << endl;
 
     //Write the supplied arguments to the log file
     mLog << "ARGUMENTS: " << endl;
 
     for(int arg_num=0; arg_num < mArgc; arg_num++){
         mLog << mpArgv[arg_num] << " ";
     }
 
     mLog << endl << endl;
 
     //Write input files to log file
     mLog << "INPUT FILES:  " << endl;
     mLog << mInfileName1;
     mLog << ", " << mInfileName2 << endl << endl;
 
     //Write header for run output
     mLog << "RUN OUTPUT:" << endl << flush;
 
     return false;
 }