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