← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/poco/gutsy

« back to all changes in this revision

Viewing changes to Util/src/OptionProcessor.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Krzysztof Burghardt
  • Date: 2007-04-27 18:33:48 UTC
  • Revision ID: james.westby@ubuntu.com-20070427183348-xgnpct0qd6a2ip34
Tags: upstream-1.2.9
Import upstream version 1.2.9

Show diffs side-by-side

added added

removed removed

Lines of Context:
Util/src/OptionProcessor.cpp
 
1
//
 
2
// OptionProcessor.cpp
 
3
//
 
4
// $Id: //poco/1.2/Util/src/OptionProcessor.cpp#1 $
 
5
//
 
6
// Library: Util
 
7
// Package: Options
 
8
// Module:  OptionProcessor
 
9
//
 
10
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
 
11
// and Contributors.
 
12
//
 
13
// Permission is hereby granted, free of charge, to any person or organization
 
14
// obtaining a copy of the software and accompanying documentation covered by
 
15
// this license (the "Software") to use, reproduce, display, distribute,
 
16
// execute, and transmit the Software, and to prepare derivative works of the
 
17
// Software, and to permit third-parties to whom the Software is furnished to
 
18
// do so, all subject to the following:
 
19
// 
 
20
// The copyright notices in the Software and this entire statement, including
 
21
// the above license grant, this restriction and the following disclaimer,
 
22
// must be included in all copies of the Software, in whole or in part, and
 
23
// all derivative works of the Software, unless such copies or derivative
 
24
// works are solely in the form of machine-executable object code generated by
 
25
// a source language processor.
 
26
// 
 
27
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
28
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
29
// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
 
30
// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
 
31
// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
 
32
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 
33
// DEALINGS IN THE SOFTWARE.
 
34
//
 
35
 
 
36
 
 
37
#include "Poco/Util/OptionProcessor.h"
 
38
#include "Poco/Util/OptionSet.h"
 
39
#include "Poco/Util/Option.h"
 
40
#include "Poco/Util/OptionException.h"
 
41
 
 
42
 
 
43
namespace Poco {
 
44
namespace Util {
 
45
 
 
46
 
 
47
OptionProcessor::OptionProcessor(const OptionSet& options): 
 
48
        _options(options),
 
49
        _unixStyle(true),
 
50
        _ignore(false)
 
51
{
 
52
}
 
53
 
 
54
 
 
55
OptionProcessor::~OptionProcessor()
 
56
{
 
57
}
 
58
 
 
59
 
 
60
void OptionProcessor::setUnixStyle(bool flag)
 
61
{
 
62
        _unixStyle = flag;
 
63
}
 
64
 
 
65
 
 
66
bool OptionProcessor::process(const std::string& argument, std::string& optionName, std::string& optionArg)
 
67
{
 
68
        if (!_ignore)
 
69
        {
 
70
                if (_unixStyle)
 
71
                        return processUnix(argument, optionName, optionArg);
 
72
                else
 
73
                        return processDefault(argument, optionName, optionArg);
 
74
        }
 
75
        return false;
 
76
}
 
77
 
 
78
 
 
79
void OptionProcessor::checkRequired() const
 
80
{
 
81
        for (OptionSet::Iterator it = _options.begin(); it != _options.end(); ++it)
 
82
        {
 
83
                if (it->required() && _specifiedOptions.find(it->fullName()) == _specifiedOptions.end())
 
84
                        throw MissingOptionException(it->fullName());
 
85
        }
 
86
}
 
87
 
 
88
 
 
89
bool OptionProcessor::processUnix(const std::string& argument, std::string& optionName, std::string& optionArg)
 
90
{
 
91
        std::string::const_iterator it  = argument.begin();
 
92
        std::string::const_iterator end = argument.end();
 
93
        if (it != end)
 
94
        {
 
95
                if (*it == '-')
 
96
                {
 
97
                        ++it;
 
98
                        if (it != end)
 
99
                        {
 
100
                                if (*it == '-')
 
101
                                {
 
102
                                        ++it;
 
103
                                        if (it == end)
 
104
                                        {
 
105
                                                _ignore = true;
 
106
                                                return true;
 
107
                                        }
 
108
                                        else return processCommon(std::string(it, end), false, optionName, optionArg);
 
109
                                }
 
110
                                else return processCommon(std::string(it, end), true, optionName, optionArg);
 
111
                        }
 
112
                }
 
113
        }
 
114
        return false;
 
115
}
 
116
 
 
117
 
 
118
bool OptionProcessor::processDefault(const std::string& argument, std::string& optionName, std::string& optionArg)
 
119
{
 
120
        std::string::const_iterator it  = argument.begin();
 
121
        std::string::const_iterator end = argument.end();
 
122
        if (it != end)
 
123
        {
 
124
                if (*it == '/')
 
125
                {
 
126
                        ++it;
 
127
                        return processCommon(std::string(it, end), false, optionName, optionArg);
 
128
                }
 
129
        }
 
130
        return false;
 
131
}
 
132
 
 
133
 
 
134
bool OptionProcessor::processCommon(const std::string& optionStr, bool isShort, std::string& optionName, std::string& optionArg)
 
135
{
 
136
        if (optionStr.empty()) throw EmptyOptionException();
 
137
        const Option& option = _options.getOption(optionStr, isShort);
 
138
        const std::string& group = option.group();
 
139
        if (!group.empty())
 
140
        {
 
141
                if (_groups.find(group) != _groups.end())
 
142
                        throw IncompatibleOptionsException(option.fullName());
 
143
                else
 
144
                        _groups.insert(group);
 
145
        }
 
146
        if (_specifiedOptions.find(option.fullName()) != _specifiedOptions.end() && !option.repeatable())
 
147
                throw DuplicateOptionException(option.fullName());
 
148
        _specifiedOptions.insert(option.fullName());
 
149
        option.process(optionStr, optionArg);
 
150
        optionName = option.fullName();
 
151
        return true;
 
152
}
 
153
 
 
154
 
 
155
} } // namespace Poco::Util