Scale Stack 0.3 Developer Documentation

scalestack/kernel/option.cc

Go to the documentation of this file.

/*
 * Scale Stack
 *
 * Copyright 2010 Eric Day
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "config.h"

#include <cstdlib>
#include <iostream>
#include <strings.h>

#include <scalestack/kernel/module.h>
#include <scalestack/kernel/option.h>

using namespace std;

namespace scalestack
{
namespace kernel
{

/*
 * Public methods.
 */

option::~option()
{
}

module& option::get_module(void) const
{
  return _module;
}

const string& option::get_name(void) const
{
  return _name;
}

const string& option::get_help(void) const
{
  return _help;
}

const string& option::get_value_name(void) const
{
  return _value_name;
}

const string& option::get_default_value(void) const
{
  return _default_value;
}

const string& option::get_value(void) const
{
  return _value;
}

int option::get_int_value(void) const
{
  return atoi(_value.c_str());
}

size_t option::get_size_value(void) const
{
  return strtoul(_value.c_str(), NULL, 0);
}

bool option::get_bool_value(void) const
{
  if (!strcasecmp(_value.c_str(), "false") ||
      !strcasecmp(_value.c_str(), "f") ||
      !strcasecmp(_value.c_str(), "no") ||
      !strcasecmp(_value.c_str(), "n") ||
      _value == "0")
  {
    return false;
  }

  return true;
}

vector<string> option::get_list_value(void) const
{
  vector<string> list;
  string::size_type current = 0;

  do
  {
    string::size_type next = _value.find_first_of(",", current);
    list.push_back(_value.substr(current, next - current));
    current = _value.find_first_not_of(",", next);
  }
  while (current != string::npos);

  return list;
}

bool option::is_valid(void) const
{
  return _is_valid;
}

/*
 * Private methods.
 */

option::option(module& module, const std::string& name):
  _is_valid(),
  _is_set(),
  _module(module),
  _name(name),
  _help(),
  _value_name(),
  _default_value(),
  _value()
{
}

void option::_set_help(const std::string& help)
{
  _help = help;
}

void option::_set_value_name(const std::string& value_name)
{
  _value_name = value_name;
}

void option::_set_default_value(const std::string& default_value)
{
  _default_value = default_value;
}

void option::_set_value(const std::string& value, bool overwrite)
{
  if (overwrite || !_is_set)
  {
    _value = value;
    _is_set = true;
  }
}

void option::_set_valid(bool valid)
{
  _is_valid = valid;
}

void option::_print_help(void)
{
  cout << "  " << _name << "=" << _value_name << " - " << _help;

  if (_default_value != "")
    cout << _(" (Default: ") << _default_value << ")";

  cout << endl;
}

void option::_print_config(void)
{
  cout << _module.get_name() << "." << _name << "=" << _value << endl;
}

} /* namespace kernel */
} /* namespace scalestack */

---