path_configuration.cpp

Go to the documentation of this file.

#ifndef PATH_CONFIGURATION_IMPLEMENTATION_FILE
#define PATH_CONFIGURATION_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : path_configuration                                                *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 2000-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "command_line.h"
#include "filename.h"
#include "ini_config.h"
#include "path_configuration.h"

#include <basis/function.h>
#include <basis/guards.h>
#include <basis/istring.h>
#include <basis/mutex.h>
#include <basis/object_base.h>
#include <basis/portable.h>
#include <data_struct/static_memory_gremlin.h>
#include <textual/parser_bits.h>

#ifdef __WIN32__
  #include <direct.h>
#else
  #include <dirent.h>
#endif
#include <string.h>
#include <sys/stat.h>

namespace path_configuration {

const char *PATH_CONFIGURATION_FILENAME() { return "paths.ini"; }

istring path_configuration_file()
{
  filename cfg_file(application_directory() + "/"
      + PATH_CONFIGURATION_FILENAME());
  return cfg_file.raw();
}

const istring &GLOBAL_SECTION_NAME() { STATIC_STRING("Common"); }

const istring &LOCAL_FOLDER_NAME() { STATIC_STRING("LocalFiles"); }

const istring &LOGGING_FOLDER_NAME() { STATIC_STRING("LogPath"); }


const int MAX_LOG_PATH = 200;
  // the maximum length of the entry stored for the log path.

istring installation_root()
{
  istring to_return = read_item(LOCAL_FOLDER_NAME());
  if (!to_return) {
    // well, if this other guy has a path, we'll give that back.  otherwise,
    // we don't know what the path should be at all.
    to_return = filename(path_configuration_file()).dirname();
  }
  return to_return;
}

istring get_logging_directory()
{
  // start with the root of our installation.
  istring def_log = installation_root();
  // add logs directory underneath that.
  def_log += "/logs";
    // add the subdirectory for logs.

  // now grab the current value for the name, if any.
  istring log_dir = read_item(LOGGING_FOLDER_NAME());
    // get the entry for the logging path.
  if (!log_dir) {
    // if the entry was absent, we set it.
    ini_configurator ini(path_configuration_file(),
        ini_configurator::RETURN_ONLY,
        ini_configurator::APPLICATION_DIRECTORY);
    ini.store(GLOBAL_SECTION_NAME(), LOGGING_FOLDER_NAME(), def_log);
  } else {
    // they gave us something.  let's replace the environment variables
    // in their string so we resolve paths and such.
    log_dir = parser_bits::substitute_env_vars(log_dir);
  }

  // now we make sure the directory exists.
  struct stat to_fill;
  int stat_ret = stat(log_dir.observe(), &to_fill);
  if (stat_ret || !(to_fill.st_mode & S_IFDIR) ) {
    // if it's not anything yet or if it's not a directory, then we need
    // to create it.
//if it's something besides a directory... should it be deleted?
#ifdef __UNIX__
    int mk_ret = mkdir(log_dir.s(), 0777);
#endif
#ifdef __WIN32__
    int mk_ret = mkdir(log_dir.s());
#endif
    if (mk_ret) return "";
//can't have a log file if we can't make the directory successfully???
  }

  return log_dir;
}

istring make_logfile_name(const istring &base_name)
{ return get_logging_directory() + "/" + base_name; }

SAFE_STATIC(istring_object, _hidden_hardcoding_appname, )

void hard_code_application_name(const istring &new_name)
{ _hidden_hardcoding_appname() = new_name; }

istring application_name()
{
  if (_hidden_hardcoding_appname().t()) return _hidden_hardcoding_appname();
  return portable::application_name();
}

SAFE_STATIC(istring_object, _hidden_hardcoding_dir, )

void hard_code_application_dir(const istring &new_dir)
{ _hidden_hardcoding_dir() = new_dir; }

istring application_directory()
{
  // first check for the so-called hard-coded directory.
  if (_hidden_hardcoding_dir().t())
    return _hidden_hardcoding_dir();
  return filename(application_name()).dirname().raw();
}

istring core_bin_directory() { return read_item("core_bin"); }

istring read_item(const istring &key_name)
{
  filename ini_name = path_configuration_file();
  ini_configurator ini(ini_name, ini_configurator::RETURN_ONLY,
      ini_configurator::APPLICATION_DIRECTORY);
  istring to_return =  ini.load(GLOBAL_SECTION_NAME(), key_name, "");
  if (!!to_return) {
    // if the string has any length, then we process any environment
    // variables found encoded in the value.
    to_return = parser_bits::substitute_env_vars(to_return);
  }
  return to_return;
}

} // namespace.


#endif //PATH_CONFIGURATION_IMPLEMENTATION_FILE

---