CommandLineOption.cpp

/*
** libutil++
** $Id: CommandLineOption.cpp 1653 2016-02-28 19:54:59Z sella $
** Copyright (c) 2011-2016 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

static const char rcsid[] __attribute__((used)) = "$Id: CommandLineOption.cpp 1653 2016-02-28 19:54:59Z sella $";

#include "CommandLineOption.h"

#include <stdio.h>

#include <string>

using namespace sella::util;

CommandLineOption::CommandLineOption(char opt, const std::string &option, const std::string &usage, const std::string &label, const std::string &value) throw () :
        opt(opt),
        option(option),

        usage(usage),
        value(value),

        argumented(label.size() > 0)
{
        char    buffer[1024];

        if (((opt >= 'a') && (opt <= 'z')) || ((opt >= 'A') && (opt <= 'Z')) || ((opt >= '0') && (opt <= '9'))) {
                if (this->argumented) {
                        snprintf(buffer, sizeof(buffer), "    -%c,--%s=%s", opt, option.c_str(), label.c_str());
                } else {
                        snprintf(buffer, sizeof(buffer), "    -%c,--%s", opt, option.c_str());
                }
        } else {
                if (this->argumented) {
                        snprintf(buffer, sizeof(buffer), "    --%s=%s", option.c_str(), label.c_str());
                } else {
                        snprintf(buffer, sizeof(buffer), "    --%s", option.c_str());
                }
        }
        this->tags = buffer;
}

CommandLineOption::CommandLineOption() throw () :
        opt(),
        option(),

        usage(),
        value(),

        tags(),

        argumented(false)
{ }

CommandLineOption::CommandLineOption(const CommandLineOption &copy) throw () :
        opt(copy.getOpt()),
        option(copy.getOption()),

        usage(copy.getUsage()),
        value(copy.getValue()),

        tags(copy.getTags()),

        argumented(copy.getArgumented())
{ }

CommandLineOption::~CommandLineOption() throw () {
        this->option.clear();
        this->usage.clear();
        this->value.clear();
        this->tags.clear();
}

CommandLineOption & CommandLineOption::operator =  (const CommandLineOption &other) throw () {
        if (this != &other) {
                this->setOpt(other.getOpt());
                this->setOption(other.getOption());

                this->setUsage(other.getUsage());
                this->setValue(other.getValue());

                this->setTags(other.getTags());

                this->setArgumented(other.getArgumented());
        }
        return *this;
}

void CommandLineOption::setOpt(char opt) throw () { 
        this->opt = opt;
}

void CommandLineOption::setOption(const std::string &option) throw () {
        this->option = option;
}

void CommandLineOption::setUsage(const std::string &usage) throw () {
        this->usage = usage;
}

void CommandLineOption::setValue(const std::string &value) throw () {
        this->value = value;
}

void CommandLineOption::setTags(const std::string &tags) throw () {
        this->tags = tags;
}

void CommandLineOption::setArgumented(bool value) throw () {
        this->argumented = value;
}

char CommandLineOption::getOpt() const throw () {
        return this->opt;
}

const std::string & CommandLineOption::getOption() const throw () {
        return this->option;
}

const std::string & CommandLineOption::getUsage() const throw () {
        return this->usage;
}

const std::string & CommandLineOption::getValue() const throw () {
        return this->value;
}

const std::string & CommandLineOption::getTags() const throw () {
        return this->tags;
}

bool CommandLineOption::getArgumented() const throw () {
        return this->argumented;
}

/*
** vim: noet ts=3 sw=3
*/