value.h

Go to the documentation of this file.

//
//  Copyright (c) Benjamin Kaufmann 2004
//
//  This 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 file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this file; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//
// NOTE: ProgramOptions is inspired by Boost.Program_options
//       see: www.boost.org/libs/program_options
//
#ifndef PROGRAM_OPTIONS_VALUE_H_INCLUDED
#define PROGRAM_OPTIONS_VALUE_H_INCLUDED
#ifdef _MSC_VER
#pragma warning (disable : 4786)
#pragma warning (disable : 4503)
#endif
#include <string>
#include <typeinfo>
#include <cstddef>
#if defined(_MSC_VER) && _MSC_VER <= 1200
namespace std { using ::size_t; }
#endif

namespace ProgramOptions {


enum DescriptionLevel {
        desc_level_default = 0, 
        desc_level_e1      = 1,
        desc_level_e2      = 2,
        desc_level_e3      = 3,
        desc_level_all     = 4,
        desc_level_hidden  = 5 
};


class Value {
public:
        enum State { 
                value_unassigned = 0, 
                value_defaulted  = 1, 
                value_fixed      = 2  
        };
        enum DescType {
                  desc_name    = 1
                , desc_default = 2
                , desc_implicit= 4
        };
        virtual ~Value();

        State state() const { return static_cast<State>(state_); }
        
        Value* state(Value::State s) {
                state(true, s);
                return this;
        }


        const char* arg()          const;
        Value*      arg(const char* n) { return desc(desc_name, n); }

        Value* alias(char c) { optAlias_ = c; return this; }
        char   alias() const { return optAlias_; }

        Value* level(DescriptionLevel lev) {
                unsigned x = (lev * level_shift);
                flags_     = static_cast<byte_t>(x | (flags_&(level_shift-1)));
                return this;
        }
        DescriptionLevel level() const { return DescriptionLevel(flags_ / level_shift); }


        bool isNegatable() const { return hasProperty(property_negatable); }
        Value* negatable()       { setProperty(property_negatable); return this; }

        

        bool   isImplicit() const { return hasProperty(property_implicit); }
        

        bool isFlag() const { return hasProperty(property_flag); }

        Value* flag() { setProperty(property_flag); return this; }

        
        bool isComposing() const { return hasProperty(property_composing); }
        Value* composing() { setProperty(property_composing); return this; }

        Value* defaultsTo(const char* v){ return desc(desc_default, v); }
        const char* defaultsTo()  const { return desc(desc_default); }  
        Value* implicit(const char* str) { return desc(desc_implicit, str); }
        const char* implicit() const;


        bool parse(const std::string& name, const std::string& value, State st = value_fixed);
protected:
        typedef unsigned char byte_t;
        enum Property {
                  property_implicit    = 1 // implicit value?
                , property_flag        = 3 // implicit and type bool?
          , property_composing   = 4 // multiple values allowed?
                , property_negatable   = 8 // negatable form allowed? 
                , property_location    =16 // fixed storage location?
                , not_a_property       =32
        };
        Value(byte_t flagSet, State initial = value_unassigned);
        void setProperty(Property f)     { flags_ |= byte_t(f); }
        void clearProperty(Property f)   { flags_ &= ~byte_t(f);}
        bool hasProperty(Property f)const{ return (flags_ & byte_t(f)) == f; }
        bool state(bool b, State s) { if (b) { state_ = static_cast<byte_t>(s); } return b; }
        virtual bool doParse(const std::string& name, const std::string& value) = 0;
        const char* desc(DescType t) const;
        Value*      desc(DescType t,  const char* d);
private:
        enum { desc_pack    = 8, level_shift = not_a_property, levels = 255/level_shift };
        byte_t state_;       // state: one of State
        byte_t flags_;       // flag set holding properties
        byte_t descFlag_;    // either desc_pack or one of DescType
        byte_t optAlias_;    // alias name of option
        union ValueDesc {    // optional value descriptions either
                const char*  value;// a single value or
                const char** pack; // a pointer to a full pack
        }      desc_;         
};
}
#endif