COptions Class Reference

#include <COptions.h>

Collaboration diagram for COptions:

Classes
class	COptionValue
class	COptionValueTemplate

Public Types
typedef std::map< std::string, std::string >	defaultType
typedef std::vector< std::string >	nonOptionType
typedef std::map< std::string, COptionValue * >	optionType

Public Member Functions
	~COptions ()

Static Public Member Functions
static void	cleanup ()
template<class CType >
static bool	compareValue (const std::string &name, const CType &value)
static std::string	getEnvironmentVariable (const std::string &name)
static const nonOptionType &	getNonOptions ()
static std::string	getPWD (void)
template<class CType >
static void	getValue (const std::string &name, CType &value)
static void	init (C_INT argc=0, char *argv[]=NULL)

Private Member Functions
	COptions ()

Static Private Member Functions
static std::string	getConfigDir (void)
static std::string	getConfigFile (void)
static std::string	getCopasiDir (void)
static std::string	getHome (void)
static std::string	getTemp (void)
template<class CType >
static void	setValue (const std::string &name, const CType &value)

Static Private Attributes
static nonOptionType	mNonOptions
static optionType	mOptions

Detailed Description

COptions class. The class retrieves the options from the commandline and various files. The options as well as their type can be retreived by name.

Created for Copasi by Stefan Hoops 2002

Definition at line 40 of file COptions.h.

Member Typedef Documentation

typedef std::map< std::string, std::string > COptions::defaultType

Definition at line 110 of file COptions.h.

typedef std::vector< std::string > COptions::nonOptionType

Definition at line 109 of file COptions.h.

typedef std::map< std::string, COptionValue * > COptions::optionType

Definition at line 108 of file COptions.h.

Constructor & Destructor Documentation

COptions::COptions ( )

private

Definition at line 50 of file COptions.cpp.

References CONSTRUCTOR_TRACE.

{CONSTRUCTOR_TRACE;}

COptions::~COptions

(

)

Definition at line 53 of file COptions.cpp.

References DESTRUCTOR_TRACE.

{DESTRUCTOR_TRACE;}

Member Function Documentation

void COptions::cleanup ( )

static

Definition at line 243 of file COptions.cpp.

References mOptions, and pdelete.

Referenced by CCopasiRootContainer::destroy().

{
  optionType::iterator begin = mOptions.begin();
  optionType::iterator end = mOptions.end();

  for (; begin != end; begin++) pdelete(begin->second);
}

template<class CType >

static bool COptions::compareValue ( const std::string &  name, const CType &  value  )

inlinestatic

Definition at line 128 of file COptions.h.

References mOptions.

Referenced by CopasiUI3Window::create(), CCopasiMessage::handler(), init(), main(), CopasiUI3Window::openInitialDocument(), and validate().

  {return mOptions[name]->compareValue(value);}

std::string COptions::getConfigDir ( void  )

staticprivate

Definition at line 436 of file COptions.cpp.

References CDirEntry::createDir(), getValue(), and CDirEntry::Separator.

Referenced by init().

{
  std::string Home;

  getValue("Home", Home);

  if (!CDirEntry::createDir(".copasi", Home))
    return Home;

  return Home + CDirEntry::Separator + ".copasi";
}

std::string COptions::getConfigFile ( void  )

staticprivate

Definition at line 448 of file COptions.cpp.

References getValue(), and CDirEntry::Separator.

Referenced by init().

{
  std::string ConfigDir;

  getValue("ConfigDir", ConfigDir);

  return ConfigDir + CDirEntry::Separator + "copasi";
}

std::string COptions::getCopasiDir ( void  )

staticprivate

Definition at line 260 of file COptions.cpp.

References CDirEntry::dirName(), getEnvironmentVariable(), MCConfiguration, CCopasiMessage::RAW, and CLocaleString::toUtf8().

Referenced by init().

{
  std::string CopasiDir;

  CopasiDir = getEnvironmentVariable("COPASIDIR");

#ifdef WIN32

  if (CopasiDir == "")
    {
      DWORD PrgNameSize = 256;
      DWORD Returned;
      CLocaleString::lchar * PrgName = new CLocaleString::lchar[PrgNameSize];

      while (!(Returned = GetModuleFileNameW(NULL, PrgName, PrgNameSize)) ||
             PrgNameSize == Returned)
        {
          if (GetLastError() != ERROR_ALREADY_EXISTS)
            {
              *PrgName = 0;
              break;
            }

          delete [] PrgName;
          PrgNameSize *= 2;
          PrgName = new CLocaleString::lchar[PrgNameSize];
        }

      CopasiDir = CLocaleString(PrgName).toUtf8();

      delete [] PrgName;

      /* Get rid of the executable */
      CopasiDir = CDirEntry::dirName(CopasiDir);

      /* Get rid of bin or sbin */
      CopasiDir = CDirEntry::dirName(CopasiDir);
    }

#endif // WIN32

#ifdef Darwin

  if (CopasiDir == "")
    {
      CFBundleRef MainBundleRef = NULL;
      MainBundleRef = CFBundleGetMainBundle();

      if (MainBundleRef != NULL)
        {
          CFURLRef pluginRef = NULL;
          pluginRef = CFBundleCopyBundleURL(MainBundleRef);

          if (pluginRef != NULL)
            {
              CFStringRef macPath = NULL;
              macPath = CFURLCopyFileSystemPath(pluginRef, kCFURLPOSIXPathStyle);

              if (macPath != NULL)
                {
                  CFIndex size = CFStringGetLength(macPath);
                  char* cString = new char[size + 1];
                  CFStringGetCString(macPath, cString, size + 1, kCFStringEncodingUTF8);
                  CopasiDir = CLocaleString(cString).toUtf8();
                  delete[] cString;
                }
            }
        }
    }

#endif // Darwin

  if (CopasiDir == "")
    CCopasiMessage Message(CCopasiMessage::RAW, MCConfiguration + 1);

  return CopasiDir;
}

std::string COptions::getEnvironmentVariable ( const std::string &  name )

static

Definition at line 253 of file COptions.cpp.

References CLocaleString::fromUtf8(), and CLocaleString::toUtf8().

Referenced by getCopasiDir(), getHome(), and getTemp().

{
  CLocaleString Value = getenv(CLocaleString::fromUtf8(name).c_str());

  return Value.toUtf8();
}

std::string COptions::getHome ( void  )

staticprivate

Definition at line 365 of file COptions.cpp.

References getEnvironmentVariable().

Referenced by init().

{
  std::string Home;

  Home = getEnvironmentVariable("HOME");

#ifdef WIN32

  if (Home == "")
    Home = getEnvironmentVariable("HOMEDRIVE")
           + getEnvironmentVariable("HOMEPATH");

#endif // WIN32

  if (Home == "")
    {
      std::ostringstream error;
      error << std::endl
            << "  use --home HOME" << std::endl
            << "  or set the environment variable HOME" << std::endl
            << "  to point to your home directory" << std::endl;

      throw copasi::option_error(error.str());
    }

  return Home;
}

const COptions::nonOptionType & COptions::getNonOptions ( )

static

Definition at line 251 of file COptions.cpp.

References mNonOptions.

Referenced by main(), and CopasiUI3Window::openInitialDocument().

{return mNonOptions;}

std::string COptions::getPWD ( void  )

static

Definition at line 338 of file COptions.cpp.

References CLocaleString::toUtf8().

Referenced by init(), and Copasi2SBMLTranslator::translateToSBML().

{
#ifdef WIN32
  int PWDSize = 256;
#else // WIN32
  size_t PWDSize = 256;
#endif // not WIN32

  CLocaleString::lchar * PWD = NULL;

  while (!(PWD = getcwd(NULL, PWDSize)))
    {
      if (errno != ERANGE) break;

      PWDSize *= 2;
    }

  std::string pwd = CLocaleString(PWD).toUtf8();

  if (PWD)
    {
      free(PWD);
    }

  return pwd;
}

std::string COptions::getTemp ( void  )

staticprivate

Definition at line 393 of file COptions.cpp.

References CDirEntry::createDir(), getEnvironmentVariable(), CDirEntry::isDir(), CDirEntry::isWritable(), and CDirEntry::Separator.

Referenced by init().

{
  std::string Temp, User, CreateCopasiDir, CreateUserDir;

  Temp = getEnvironmentVariable("TEMP");

  if (Temp == "") Temp = getEnvironmentVariable("TMP");

  User = getEnvironmentVariable("USER");

  if (User == "") User = getEnvironmentVariable("USERNAME");

  if (User == "") User = "CopasiUser";

  if (Temp == "") // OS specific fallback.
#ifdef WIN32
    Temp = getEnvironmentVariable("windir") + CDirEntry::Separator + "Temp";

#else
    Temp = "/tmp";
#endif // WIN32

  // Assure that Temp exists and is a directory.
  if (!CDirEntry::isDir(Temp) || !CDirEntry::isWritable(Temp))
    return "";

  CreateCopasiDir = Temp + CDirEntry::Separator + "copasi";
  CreateUserDir = CreateCopasiDir + CDirEntry::Separator + User;

  //Assure that CreateCopasiDir exists and is a writable directory.
  if (!CDirEntry::createDir("copasi", Temp))
    return Temp;

  Temp = CreateCopasiDir;

  //Assure that CreateUserDir exists and is a writable directory.
  if (!CDirEntry::createDir(User, Temp))
    return Temp;

  Temp = CreateUserDir;
  return Temp;
}

template<class CType >

static void COptions::getValue ( const std::string &  name, CType &  value  )

inlinestatic

Definition at line 124 of file COptions.h.

References mOptions.

Referenced by CRecentFiles::addFile(), CCopasiDataModel::autoSave(), CopasiUI3Window::CleanUp(), exportSBML(), CCopasiDataModel::exportSBML(), getConfigDir(), getConfigFile(), CCopasiDataModel::importSBML(), init(), CConfigurationFile::load(), CConfigurationFile::CXML::load(), CCopasiDataModel::loadModel(), main(), DataModelGUI::miriamDownloadFinished(), CDirEntry::normalize(), CopasiFileDialog::openExampleDir(), CopasiUI3Window::openInitialDocument(), CConfigurationFile::save(), CCopasiDataModel::saveModel(), Copasi2SBMLTranslator::translate(), WizardDialog::WizardDialog(), and writeLogo().

  {mOptions[name]->getValue(value);}

void COptions::init ( C_INT  argc = 0, char *  argv[] = NULL  )

static

Definition at line 56 of file COptions.cpp.

References C_INT, compareValue(), copasi::options::ConfigDir, copasi::options::ConfigFile, copasi::options::CopasiDir, CDirEntry::dirName(), copasi::options::ExportBerkeleyMadonna, copasi::options::ExportC, copasi::options::ExportSBML, copasi::options::ExportXPPAUT, copasi::COptionParser::get_non_options(), copasi::COptionParser::get_options(), getConfigDir(), getConfigFile(), getCopasiDir(), getHome(), getPWD(), getTemp(), getValue(), copasi::options::Home, copasi::options::ImportSBML, CDirEntry::isRelativePath(), copasi::options::License, CDirEntry::makePathAbsolute(), copasi::options::MaxTime, mNonOptions, copasi::options::NoLogo, copasi::COptionParser::parse(), copasi::options::Save, copasi::options::SBMLSchema, setValue(), copasi::options::Tmp, CLocaleString::toUtf8(), copasi::options::Validate, and copasi::options::Verbose.

Referenced by CCopasiRootContainer::init().

{
  // We convert the commandline arguments to Utf8
  std::string * Utf8 = new std::string[argc];
  C_INT i;

#ifdef WIN32
  // We cannot use the commandline arguments provided by main as they are not sufficient
  // to encode unicode data.
  CLocaleString::lchar * CommandLine = GetCommandLineW();

  int intArgC = (int) argc;
  CLocaleString::lchar ** Utf8V = CommandLineToArgvW(CommandLine, &intArgC);

  for (i = 0; i < argc; ++i)
    {
      Utf8[i] = CLocaleString(Utf8V[i]).toUtf8();
    }

  LocalFree(Utf8V);

#else

  for (i = 0; i < argc; ++i)
    {
      Utf8[i] = CLocaleString(argv[i]).toUtf8();
    }

#endif

  if (argc > 0)
    setValue("Self", Utf8[0]);
  else
    setValue("Self", std::string(""));

  setValue("PWD", getPWD());

  // First we must clean up the command line by
  // taking out any SBW commands like -sbwregister and -sbwmodule

  // The default settings for SBW related options
  setValue("SBWRegister", false);
  setValue("SBWModule", false);

  char **ArgV = new char * [argc];
  C_INT ArgC = 0;

  for (i = 0; i < argc; i++)
    {
      if (Utf8[i] == "-sbwregister")
        setValue("SBWRegister", true);
      else if (Utf8[i] == "-sbwmodule")
        setValue("SBWModule", true);
      else
        {
          ArgV[ArgC] = strdup(Utf8[i].c_str());
          ArgC++;
        }
    }

  // Now we are ready to start the Clo++ generated parser.
  copasi::COptionParser * pPreParser = new copasi::COptionParser;
  pPreParser->parse(ArgC, ArgV);

  const copasi::options &PreOptions = pPreParser->get_options();

  setValue("CopasiDir", PreOptions.CopasiDir);

  if (compareValue("CopasiDir", (std::string) ""))
    {
      setValue("CopasiDir", getCopasiDir());
    }

  setValue("Home", PreOptions.Home);

  if (compareValue("Home", (std::string) ""))
    setValue("Home", getHome());

  setValue("Tmp", PreOptions.Tmp);

  if (compareValue("Tmp", (std::string) ""))
    setValue("Tmp", getTemp());

  setValue("ConfigDir", PreOptions.ConfigDir);

  if (compareValue("ConfigDir", (std::string) ""))
    setValue("ConfigDir", getConfigDir());

  setValue("ConfigFile", PreOptions.ConfigFile);

  if (compareValue("ConfigFile", (std::string) ""))
    setValue("ConfigFile", getConfigFile());

  mNonOptions.clear();
  std::vector< std::string >::const_iterator it = pPreParser->get_non_options().begin();
  std::vector< std::string >::const_iterator end = pPreParser->get_non_options().end();

  for (; it != end; ++it)
    mNonOptions.push_back(*it);

  const copasi::options &Options = pPreParser->get_options();

  std::string CopasiDir;
  getValue("CopasiDir", CopasiDir);

#if !defined(DARWIN)

  if (CopasiDir.empty() && argc > 0)
    {
      // in case the directory was not defined on the command line,
      // or via environment variableinstead of defaulting to *most
      // likely* non-existing folders, let us default to the most
      // usual case, that people received the binaries from us, in
      // that case we know that the binaries are located in
      // <copasi>/bin while the remaining data is in <copasi>/share
      // (excluding OSX for the time being as that one ought to have
      // files bundled up).

      CopasiDir = argv[0];

      // if relative, make it an absolute path
      if (CDirEntry::isRelativePath(CopasiDir))
        CDirEntry::makePathAbsolute(CopasiDir, getPWD());

      // strip the executable
      CopasiDir = CDirEntry::dirName(CopasiDir);

      // strip the bin directory
      CopasiDir = CDirEntry::dirName(CopasiDir);
    }

#endif

  std::string Home;
  getValue("Home", Home);

  /* The values for ExampleDir and WizardDir are dependent on CopasiDir
     and on the OS. */

#ifdef Darwin
  setValue("DefaultConfigDir", CDirEntry::dirName(CopasiDir) + "/config");
  setValue("ExampleDir", CDirEntry::dirName(CopasiDir) + "/examples");
  setValue("WizardDir", CopasiDir + "/Contents/Resources/doc/html");
#elif WIN32
  setValue("DefaultConfigDir", CopasiDir + "\\share\\copasi\\config");
  setValue("ExampleDir", CopasiDir + "\\share\\copasi\\examples");
  setValue("WizardDir", CopasiDir + "\\share\\copasi\\doc\\html");
#else // All Unix flavors have the same installation structure.
  setValue("DefaultConfigDir", CopasiDir + "/share/copasi/config");
  setValue("ExampleDir", CopasiDir + "/share/copasi/examples");
  setValue("WizardDir", CopasiDir + "/share/copasi/doc/html");
#endif

  /* Create manually for each option except for:
     CopasiDir, ConfigFile, Home, and Default
     setValue("OptionId", Options.OptionID); */

  if (Options.Tmp != "") setValue("Tmp", Options.Tmp);

  setValue("NoLogo", Options.NoLogo);
  setValue("Validate", Options.Validate);
  setValue("Verbose", Options.Verbose);
  setValue("License", Options.License);
  setValue("Save", Options.Save);
  setValue("ImportSBML", Options.ImportSBML);
  setValue("ExportSBML", Options.ExportSBML);
  setValue("SBMLSchema", Options.SBMLSchema);
  setValue("ExportC", Options.ExportC);
  setValue("ExportXPPAUT", Options.ExportXPPAUT);
  setValue("ExportBerkeleyMadonna", Options.ExportBerkeleyMadonna);
  setValue("MaxTime", Options.MaxTime);

#ifdef COPASI_SEDML
  setValue("ImportSEDML", Options.ImportSEDML);
#endif

  delete pPreParser;

  for (i = 0; i < ArgC; i++)
    {
      free(ArgV[i]);
    }

  delete [] ArgV;
  delete [] Utf8;
}

template<class CType >

static void COptions::setValue ( const std::string &  name, const CType &  value  )

inlinestaticprivate

Definition at line 143 of file COptions.h.

References mOptions.

Referenced by init().

  {
    if (mOptions[name])
      mOptions[name]->setValue(value);
    else
      mOptions[name] = new COptionValueTemplate< CType >(value);

    return;
  }

Member Data Documentation

COptions::nonOptionType COptions::mNonOptions

staticprivate

Definition at line 115 of file COptions.h.

Referenced by getNonOptions(), and init().

COptions::optionType COptions::mOptions

staticprivate

Definition at line 114 of file COptions.h.

Referenced by cleanup(), compareValue(), getValue(), and setValue().

---

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

• COptions.h
• COptions.cpp