Cppcheck report - CGM: src/util/SettingHandler.cpp

#include <cassert>
#include <cstdio>
#include <cstring>

#include <iostream>

#include "SettingHandler.hpp"
#include "CubitDefines.h"
#include "CubitString.hpp"
#include "CubitUtil.hpp"
#include "CubitMessage.hpp"
#include "AppUtil.hpp"
#include "CubitFile.hpp"


SettingHandler* SettingHandler::instance_ = NULL;

SettingHandler* SettingHandler::instance()
{	
  if (!instance_)
    {	
      instance_ = new SettingHandler;
      if (!instance_)
	{
	  std::cerr << " *** Unable to instantiate setting_handler object ***" << std::endl;
	  exit(1);
	}
    }
  return instance_;
}

//Default Constructor
SettingHandler::SettingHandler() 
{
  debug_flags_added = CUBIT_FALSE;
} 

void SettingHandler::delete_instance() 
{
  if (instance_)
  {
    delete instance_;
    instance_ = 0;
  }
}

SettingHandler::~SettingHandler() 
{
    std::map<CubitString, SettingHolder*>::iterator iter = mSettingsList.begin();
  std::map<CubitString, SettingHolder*>::iterator end = mSettingsList.end();

  for( ; iter != end; ++iter)
    delete (*iter).second;
  mSettingsList.clear();
}

void SettingHandler::add_setting(const char* name, void (*setFn) (int), 
				int (*getFn)())
{
  CubitString cs = name;
  //Check to see if a setting with the same name already exists
  if (mSettingsList.find(cs) != mSettingsList.end()) {
    std::cerr << "The " << name << " setting has the same name as another setting.\n" 
		<< "This is a bug.  Please report!\n";
    exit(-1);
  }
  SettingHolder* setting = new SettingHolder(cs, setFn, getFn);
  mSettingsList[cs] = setting;
}


void SettingHandler::add_setting(const char* name, void (*setFn) (double), 
				double (*getFn)())
{
  CubitString cs = name;
  //Check to see if a setting with the same name already exists
  if (mSettingsList.find(cs) != mSettingsList.end()) {
    std::cerr << "The " << name << " setting has the same name as another setting.\n" 
		<< "This is a bug.  Please report!\n";
    exit(-1);
    
  }
  SettingHolder* setting = new SettingHolder(cs, setFn, getFn);
  mSettingsList[cs] = setting;
}


void SettingHandler::add_setting(const char* name, void (*setFn) (CubitBoolean), 
				CubitBoolean (*getFn)())
{
   CubitString cs = name;
  //Check to see if a setting with the same name already exists
  if (mSettingsList.find(cs) != mSettingsList.end()) {
    std::cerr << "The " << name << " setting has the same name as another setting.\n" 
		<< "This is a bug.  Please report!\n";
    exit(-1);
    
  }
  SettingHolder* setting = new SettingHolder(cs, setFn, getFn);
  mSettingsList[cs] = setting;
}


void SettingHandler::add_setting(const char* name, void (*setFn) (CubitString), 
				CubitString (*getFn)())
{
   CubitString cs = name;
  //Check to see if a setting with the same name already exists
  if (mSettingsList.find(cs) != mSettingsList.end()) {
    std::cerr << "The " << name << " setting has the same name as another setting.\n" 
		<< "This is a bug.  Please report!\n";
    exit(-1);
    
  }
  SettingHolder* setting = new SettingHolder(cs, setFn, getFn);
  mSettingsList[cs] = setting;
}

void SettingHandler::save_settings(const char *filename)
{
  CubitFile file(filename, "w");
  
  if (!file) {
    std::cerr << "File " << filename << " could not be opened.  Settings not saved." << std::endl;
    return;
   }

  //Put a header at the top of the file
  fprintf(file.file(), "#Setting Name                                 Setting Value\n");
  fprintf(file.file(), "#------------------------------------------------------------\n");

  // Get starting and ending iterators from the map
  std::map<CubitString, SettingHolder*>::iterator start = mSettingsList.begin();
  std::map<CubitString, SettingHolder*>::iterator end = mSettingsList.end();
  
  // Step through the map and build a file to hold the settings
  while(start != end) {
    SettingHolder* setting = (*start).second;

    //Integer settings
    if (setting->setting_type == 0) {
      fprintf(file.file(), "%-50.50s%d \n", setting->name.c_str(), (setting->get_int_function)());
    }
    
    //Double settings
    else if (setting->setting_type == 1) {
      fprintf(file.file(), "%-50.50s%f \n", setting->name.c_str(), (setting->get_double_function)());
    }

    //Boolean settings
    else if (setting->setting_type == 2) {
      fprintf(file.file(), "%-50.50s%d \n", setting->name.c_str(), (setting->get_bool_function)());
    }
    
    //String settings
    else if (setting->setting_type == 3) {
      fprintf(file.file(), "%-50.50s%s \n", setting->name.c_str(), (setting->get_string_function)().c_str());
    }

    else
    {
      assert(false);
      PRINT_ERROR("Error with SettingHolder type!  Please report.");
    }

    ++start;
  }
}

void SettingHandler::print_settings()
{
  int rows, cols;
  if (!AppUtil::instance()->get_terminal_size(rows, cols))
    cols = 71;
  --cols;

  // Get starting and ending iterators from the map
  std::map<CubitString, SettingHolder*>::iterator iter = mSettingsList.begin();
  const std::map<CubitString, SettingHolder*>::iterator end = mSettingsList.end();
  
  // Step through the map and build a file to hold the settings
  for ( ; iter != end; ++iter ) 
  {
    SettingHolder* setting = iter->second;
    int vallen = cols - setting->name.length() - 1;
    if (vallen < 1) vallen = 1;
    switch( setting->setting_type )
    {
      case 0:
        PRINT_INFO("%s %*d\n", setting->name.c_str(), vallen,
            (setting->get_int_function)());
        break;
      case 1:
        PRINT_INFO("%s %*f\n", setting->name.c_str(), vallen,
            (setting->get_double_function)());
        break;
      case 2:
        PRINT_INFO("%s %*s\n", setting->name.c_str(), vallen, 
            (setting->get_bool_function)() ? "true" : "false");
        break;
      case 3:
        PRINT_INFO("%s %*s\n", setting->name.c_str(), vallen, 
            (setting->get_string_function)().c_str());
        break;
      default:
        PRINT_INFO("%s %*s\n", setting->name.c_str(), vallen,
            "ERROR : UNKNOWN SETTING TYPE");
    }
  }
}

void SettingHandler::save_settings()
{
  
  const char* default_filename = "cubit.settings";

  CubitFile file(default_filename, "w");
  
  if (!file) {
    std::cerr << "File " << default_filename << " could not be opened.  Settings not saved." << std::endl;
    return;
   }

  //Put a header at the top of the file
  fprintf(file.file(), "#Setting Name                                 Setting Value\n");
  fprintf(file.file(), "#------------------------------------------------------------\n");

  // Get starting and ending iterators from the map
  std::map<CubitString, SettingHolder*>::iterator start = mSettingsList.begin();
  std::map<CubitString, SettingHolder*>::iterator end = mSettingsList.end();

  // Step through the map and build a file to hold the settings
  while(start != end) {
    SettingHolder* setting = (*start).second;

    //Integer settings
    if (setting->setting_type == 0) {
      fprintf(file.file(), "%-50.50s%d \n", setting->name.c_str(), (setting->get_int_function)());
    }
    
    //Double settings
    else if (setting->setting_type == 1) {
      fprintf(file.file(), "%-50.50s%f \n", setting->name.c_str(), (setting->get_double_function)());
    }

    //Boolean settings
    else if (setting->setting_type == 2) {
      fprintf(file.file(), "%-50.50s%d \n", setting->name.c_str(), (setting->get_bool_function)());
    }
    
    //String settings
    else if (setting->setting_type == 3) {
      fprintf(file.file(), "%-50.50s%s \n", setting->name.c_str(), (setting->get_string_function)().c_str());
    }

    else
    {
      assert(false);
      PRINT_ERROR("Error with SettingHolder type!  Please report.");
    }

    ++start;
  }
}


void SettingHandler::restore_settings(const char* filename)
{

  //Open the file for reading
  CubitFile file(filename, "r");

  if (file) {
    std::cerr << "File " << filename << " could not be opened.  Settings not restored." << std::endl;
    return;
   }

  //Read the first 2 lines of the file, we know they are not settings
  //so just get rid of them
  char junk[100];
  fgets(junk, 100, file.file());
  fgets(junk, 100, file.file());

  char name[51]; //Allocate 50 bytes for the characters and 1 for a null termination
  CubitString cubit_name; //A CubitString that will be used for checking if the setting
                          //is in the map.
  char value[120]; //This will be used when getting the value of a setting
  SettingHolder* setting;
  int int_value = -1;<--- Variable 'int_value' is assigned a value that is never used.
  double double_value = 0.0;<--- Variable 'double_value' is assigned a value that is never used.
  CubitBoolean bool_value = CUBIT_FALSE;<--- Variable 'bool_value' is assigned a value that is never used.
  CubitString string_value = "";<--- Variable 'string_value' is assigned a value that is never used.

  while (!feof(file.file())) {

  //Get the setting name.  This will be in the first 50 characters of a line
  fgets(name, 51, file.file());

  cubit_name = name;
  cubit_name.trim();

  //Find the setting in the map
  std::map<CubitString, SettingHolder*>::iterator temp;

  temp = mSettingsList.find(cubit_name);
  
    //Read in the rest of the line no matter what
  fgets(value, 120, file.file());
    
  if (temp == mSettingsList.end()) {
    std::cerr << "Setting " << cubit_name.c_str() << " was not found." << std::endl;  
  }
  else {
    setting = (*temp).second;
    //Integer Settings
    if (setting->setting_type == 0) {
      int_value = atoi(value);
      (setting->set_int_function)(int_value);
    }
    
    //Double Settings
    if (setting->setting_type == 1) {
      double_value = atof(value);
      (setting->set_double_function)(double_value);
    }    

    //Boolean Settings
    if (setting->setting_type == 2) {
//      bool_value = (CubitBoolean)(atoi(value));
      bool_value = (atoi(value)) ? true : false;
      (setting->set_bool_function)(bool_value);
    }    
    
    //CubitString Settings
    if (setting->setting_type == 3) {
      string_value = value;
      (setting->set_string_function)(string_value);
    }     

  }

  } //End while

}

SettingHolder* SettingHandler::get_setting_holder(CubitString name)
{ 
  std::map<CubitString, SettingHolder*>::iterator it = mSettingsList.find(name);
  return it  ==  mSettingsList.end()  ? NULL : it->second;
}
 
void SettingHandler::get_settings_list(std::vector< std::pair<CubitString, SettingHolder*> > &list)
{
  // return a list of the settings
  std::map<CubitString, SettingHolder*>::iterator iter = mSettingsList.begin();
  while(iter != mSettingsList.end())
  {
    std::pair<CubitString, SettingHolder*>  tmp_pair;
    CubitString key = (*iter).first;
    tmp_pair.first = key;
    tmp_pair.second = (*iter).second;
    list.push_back( (tmp_pair) );
    iter++;
<--- Prefer prefix ++/-- operators for non-primitive types. [+]
Prefix ++/-- operators should be preferred for non-primitive types. Pre-increment/decrement can be more efficient than post-increment/decrement. Post-increment/decrement usually involves keeping a copy of the previous value around and adds a little extra code.
  }
}