YProperty.h

/*
  Copyright (C) 2000-2012 Novell, Inc
  This library is free software; you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as
  published by the Free Software Foundation; either version 2.1 of the
  License, or (at your option) version 3.0 of the License. This library
  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 Lesser General Public
  License for more details. You should have received a copy of the GNU
  Lesser General Public License along with this library; if not, write
  to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  Floor, Boston, MA 02110-1301 USA
*/
 
 
/*-/
 
  File:     YProperty.h
 
  Author:   Stefan Hundhammer <shundhammer@suse.de>
 
/-*/
 
#ifndef YProperty_h
#define YProperty_h
 
#include <string>
#include <vector>
 
 
 
enum YPropertyType
{
    YUnknownPropertyType = 0,
    YOtherProperty,     // requires futher checking
    YStringProperty,        // const std::string &
    YBoolProperty,      // bool
    YIntegerProperty        // YCP Integer == C++ long long
};
 
class YWidget;
class YProperty;
 
typedef long long   YInteger;
 

class YProperty
{
public:
    YProperty( const std::string & name, YPropertyType type, bool isReadOnly = false )
    : _name( name )
    , _type( type )
    , _isReadOnly( isReadOnly )
    {}

    std::string name() const { return _name; }

    YPropertyType type() const { return _type; }

    bool isReadOnly() const { return _isReadOnly; }

    std::string typeAsStr() const { return YProperty::typeAsStr( _type ); }

    static std::string typeAsStr( YPropertyType type );
 
private:
 
    std::string     _name;
    YPropertyType   _type;
    bool        _isReadOnly;
};
 

class YPropertyValue
{
public:

    YPropertyValue( const std::string & str ):
    _type( YStringProperty ), _stringVal( str ) {}

    YPropertyValue( const char * str ):
    _type( YStringProperty ), _stringVal( str ) {}

    explicit YPropertyValue( bool b ):
    _type( YBoolProperty ), _boolVal( b ) {}

    explicit YPropertyValue( YInteger num ):
    _type( YIntegerProperty ), _integerVal( num ) {}

    explicit YPropertyValue( int num ):
    _type( YIntegerProperty ), _integerVal( num ) {}
 
    explicit YPropertyValue( YPropertyType type ) :
    _type( type ) {}

    YPropertyValue():
    _type( YUnknownPropertyType ) {}

    ~YPropertyValue();

    bool operator==( const YPropertyValue &other ) const;

    bool operator!=( const YPropertyValue &other ) const;

    YPropertyType type() const { return _type; }

    std::string typeAsStr() const { return YProperty::typeAsStr( _type ); }

    std::string stringVal()    const { return _stringVal;  }
    bool    boolVal()   const { return _boolVal;    }
    YInteger    integerVal()    const { return _integerVal; }
 
 
private:
 
    YPropertyType   _type;
    std::string     _stringVal;
    bool        _boolVal;
    YInteger        _integerVal;
};
 

class YPropertySet
{
public:
    YPropertySet();

    void check( const std::string & propertyName ) const;

    void check( const std::string & propertyName, YPropertyType type ) const;

    void check( const YProperty & prop ) const
    { check( prop.name(), prop.type() ); }

    bool contains( const std::string & propertyName ) const throw();

    bool contains( const std::string & propertyName, YPropertyType type ) const;

    bool contains( const YProperty & prop ) const
    { return contains( prop.name(), prop.type() ); }

    bool isEmpty() const { return _properties.empty(); }

    int size() const { return (int) _properties.size(); }

    void add( const YProperty & prop );

    void add( const YPropertySet & otherSet );
 
    typedef std::vector<YProperty>::const_iterator const_iterator;

    const_iterator propertiesBegin() const;

    const_iterator propertiesEnd() const;
 
private:

    std::vector<YProperty> _properties;
};
 
 
#endif // YProperty_h