Merge lp:~thomas-voss/compiz-core/CompizOptionRework into lp:compiz-core/0.9.5

[Thomas Voß]

Switched CompOption to boost::variant

[Sam Spilsbury (smspillaz)]

14 +// #include <core/option.h>

Remove

164 + BindingTypeNone = 0, BindingTypeKey = 1 << 0, BindingTypeButton = 1
165 + << 1, BindingTypeEdgeButton = 1 << 2

Please put that on separate lines. Can you fix your IDE so that it doesn't autoformat existing code?

review: Needs Resubmitting

[Thomas Voß (thomas-voss)]

Done.

[lp:~thomas-voss/compiz-core/CompizOptionRework]

2899. By Thomas Voß on 2012-01-09

Removed commented out include and adjusted code formatting.

[Daniel van Vugt (vanvugt)]

Most of the diff is still reformatting changes that we don't want. Please fix and resubmit again.

review: Needs Fixing

Unmerged revisions

2899. By Thomas Voß on 2012-01-09

Removed commented out include and adjusted code formatting.

2898. By Thomas Voß on 2012-01-06

Switched CompOption to boost::variant.

2897. By Sam Spilsbury on 2011-12-23

Merge lp:~compiz-team/compiz-core/GoogleTest

2896. By Sam Spilsbury on 2011-12-12

Merged lp:~smspillaz/compiz-core/compiz-core.fix_890947

=== modified file 'include/core/action.h'
--- include/core/action.h	2010-11-09 14:13:19 +0000
+++ include/core/action.h	2012-01-09 16:07:25 +0000
@@ -30,9 +30,13 @@
 
 #include <boost/function.hpp>
 
+#include <vector>
+
 #include <X11/Xlib-xcb.h>
 
-#include <core/option.h>
+#include <core/string.h>
+
+class CompOption;
 
 class PrivateAction;
 
@@ -58,121 +62,127 @@
 /**
  * Context of an event occuring.
  */
-class CompAction {
-    public:
-	typedef enum {
-	    StateInitKey     = 1 <<  0,
-	    StateTermKey     = 1 <<  1,
-	    StateInitButton  = 1 <<  2,
-	    StateTermButton  = 1 <<  3,
-	    StateInitBell    = 1 <<  4,
-	    StateInitEdge    = 1 <<  5,
-	    StateTermEdge    = 1 <<  6,
-	    StateInitEdgeDnd = 1 <<  7,
-	    StateTermEdgeDnd = 1 <<  8,
-	    StateCommit      = 1 <<  9,
-	    StateCancel      = 1 << 10,
-	    StateAutoGrab    = 1 << 11,
-	    StateNoEdgeDelay = 1 << 12
-	} StateEnum;
-
-	/**
-	 * Type of event a CompAction is bound to.
-	 */
-	typedef enum {
-	    BindingTypeNone       = 0,
-	    BindingTypeKey        = 1 << 0,
-	    BindingTypeButton     = 1 << 1,
-	    BindingTypeEdgeButton = 1 << 2
-	} BindingTypeEnum;
-
-	class KeyBinding {
-	    public:
-		KeyBinding ();
-		KeyBinding (const KeyBinding&);
-		KeyBinding (int keycode, unsigned int modifiers = 0);
-
-		unsigned int modifiers () const;
-		int keycode () const;
-
-		bool fromString (const CompString &str);
-		CompString toString () const;
-
-	    private:
-		unsigned int mModifiers;
-		int          mKeycode;
-	};
-
-	class ButtonBinding {
-	    public:
-		ButtonBinding ();
-		ButtonBinding (const ButtonBinding&);
-		ButtonBinding (int button, unsigned int modifiers = 0);
-
-		unsigned int modifiers () const;
-		int button () const;
-
-		bool fromString (const CompString &str);
-		CompString toString () const;
-
-	    private:
-		unsigned int mModifiers;
-		int          mButton;
-	};
-
-	typedef unsigned int State;
-	typedef unsigned int BindingType;
-	typedef boost::function <bool (CompAction *, State, CompOption::Vector &)> CallBack;
-
-    public:
-	CompAction ();
-	CompAction (const CompAction &);
-	~CompAction ();
-
-	CallBack initiate ();
-	CallBack terminate ();
-
-	void setInitiate (const CallBack &initiate);
-	void setTerminate (const CallBack &terminate);
-
-	State state ();
-	BindingType type ();
-
-	KeyBinding & key ();
-	void setKey (const KeyBinding &key);
-
-	ButtonBinding & button ();
-	void setButton (const ButtonBinding &button);
-
-	unsigned int edgeMask ();
-	void setEdgeMask (unsigned int edge);
-
-	bool bell ();
-	void setBell (bool bell);
-
-	void setState (State state);
-
-	void copyState (const CompAction &action);
-
-	bool operator== (const CompAction& val);
-	CompAction & operator= (const CompAction &action);
-
-	bool keyFromString (const CompString &str);
-	bool buttonFromString (const CompString &str);
-	bool edgeMaskFromString (const CompString &str);
-
-	CompString keyToString ();
-	CompString buttonToString ();
-	CompString edgeMaskToString ();
-
-	static CompString edgeToString (unsigned int edge);
-
-	bool active ();
-
-	friend class CompScreen;
-
-    private:
-	PrivateAction *priv;
+class CompAction
+{
+public:
+    enum StateEnum
+    {
+	StateInitKey = 1 << 0,
+	StateTermKey = 1 << 1,
+	StateInitButton = 1 << 2,
+	StateTermButton = 1 << 3,
+	StateInitBell = 1 << 4,
+	StateInitEdge = 1 << 5,
+	StateTermEdge = 1 << 6,
+	StateInitEdgeDnd = 1 << 7,
+	StateTermEdgeDnd = 1 << 8,
+	StateCommit = 1 << 9,
+	StateCancel = 1 << 10,
+	StateAutoGrab = 1 << 11,
+	StateNoEdgeDelay = 1 << 12
+    };
+
+    /**
+     * Type of event a CompAction is bound to.
+     */
+    enum BindingTypeEnum
+    {
+	BindingTypeNone = 0,
+	BindingTypeKey = 1 << 0,
+	BindingTypeButton = 1 << 1,
+	BindingTypeEdgeButton = 1 << 2
+    };
+
+    class KeyBinding
+    {
+    public:
+	KeyBinding ();
+	KeyBinding (const KeyBinding&);
+	KeyBinding (int keycode, unsigned int modifiers = 0);
+
+	unsigned int modifiers () const;
+	int keycode () const;
+
+	bool fromString (const CompString &str);
+	CompString toString () const;
+
+    private:
+	unsigned int mModifiers;
+	int mKeycode;
+    };
+
+    class ButtonBinding
+    {
+    public:
+	ButtonBinding ();
+	ButtonBinding (const ButtonBinding&);
+	ButtonBinding (int button, unsigned int modifiers = 0);
+
+	unsigned int modifiers () const;
+	int button () const;
+
+	bool fromString (const CompString &str);
+	CompString toString () const;
+
+    private:
+	unsigned int mModifiers;
+	int mButton;
+    };
+
+    typedef unsigned int State;
+    typedef unsigned int BindingType;
+    typedef boost::function<
+	    bool (CompAction *, State, std::vector<CompOption> &)> CallBack;
+
+public:
+    CompAction ();
+    CompAction (const CompAction &);
+    ~CompAction ();
+
+    CallBack initiate ();
+    CallBack terminate ();
+
+    void setInitiate (const CallBack &initiate);
+    void setTerminate (const CallBack &terminate);
+
+    State state ();
+    BindingType type ();
+
+    KeyBinding & key ();
+    void setKey (const KeyBinding &key);
+
+    ButtonBinding & button ();
+    void setButton (const ButtonBinding &button);
+
+    unsigned int edgeMask ();
+    void setEdgeMask (unsigned int edge);
+
+    bool bell ();
+    void setBell (bool bell);
+
+    void setState (State state);
+
+    void copyState (const CompAction &action);
+
+    bool operator== (const CompAction& val) const;
+    CompAction & operator= (const CompAction &action);
+
+    bool keyFromString (const CompString &str);
+    bool buttonFromString (const CompString &str);
+    bool edgeMaskFromString (const CompString &str);
+
+    CompString keyToString ();
+    CompString buttonToString ();
+    CompString edgeMaskToString ();
+
+    static CompString edgeToString (unsigned int edge);
+
+    bool active ();
+
+    friend class CompScreen;
+
+private:
+    PrivateAction *priv;
 };
 
 #endif

=== modified file 'include/core/option.h'
--- include/core/option.h	2011-10-31 13:51:00 +0000
+++ include/core/option.h	2012-01-09 16:07:25 +0000
@@ -29,11 +29,15 @@
 #define _COMPOPTION_H
 
 #include <core/string.h>
+
+#include <boost/variant.hpp>
+
 #include <vector>
 
 class PrivateOption;
 class PrivateValue;
 class PrivateRestriction;
+
 class CompAction;
 class CompMatch;
 class CompScreen;
@@ -42,199 +46,302 @@
  * A configuration option with boolean, int, float, String, Color, Key, Button,
  * Edge, Bell, or List.
  */
-class CompOption {
-	/**
-	 * Option data types
-	 */
-    public:
-	typedef enum {
-	    TypeBool,
-	    TypeInt,
-	    TypeFloat,
-	    TypeString,
-	    TypeColor,
-	    TypeAction,
-	    TypeKey,
-	    TypeButton,
-	    TypeEdge,
-	    TypeBell,
-	    TypeMatch,
-	    TypeList,
-	    /* internal use only */
-	    TypeUnset
-	} Type;
-
-	/**
-	 * A value of an Option
-	 */
-	class Value {
-	    public:
-		typedef std::vector<Value> Vector;
-
-	    public:
-		Value ();
-		Value (const Value &);
-		Value (const bool b);
-		Value (const int i);
-		Value (const float f);
-		Value (const unsigned short *color);
-		Value (const CompString& s);
-		Value (const char *s);
-		Value (const CompMatch& m);
-		Value (const CompAction& a);
-		Value (Type type, const Vector& l);
-		~Value ();
-
-		Type type () const;
-
-		void set (const bool b);
-		void set (const int i);
-		void set (const float f);
-		void set (const unsigned short *color);
-		void set (const CompString& s);
-		void set (const char *s);
-		void set (const CompMatch& m);
-		void set (const CompAction& a);
-		void set (Type type, const Vector& l);
-
-		bool               b ();
-		int                i ();
-		float              f ();
-		unsigned short*    c ();
-		CompString         s ();
-		CompMatch &        match ();
-		CompAction &       action ();
-		Type               listType ();
-		Vector &           list ();
-
-		bool operator== (const Value& val);
-		bool operator!= (const Value& val);
-		Value & operator= (const Value &val);
-
-		operator bool ();
-		operator int ();
-		operator float ();
-		operator unsigned short * ();
-		operator CompString ();
-		operator CompMatch & ();
-		operator CompAction & ();
-		operator CompAction * ();
-		operator Type ();
-		operator Vector & ();
-
-	    private:
-		PrivateValue *priv;
-	};
-
-	/**
-	 * TODO
-	 */
-	class Restriction {
-	    public:
-		Restriction ();
-		Restriction (const Restriction &);
-		~Restriction ();
-
-		int iMin ();
-		int iMax ();
-		float fMin ();
-		float fMax ();
-		float fPrecision ();
-
-		void set (int, int);
-		void set (float, float, float);
-
-		bool inRange (int);
-		bool inRange (float);
-
-		Restriction & operator= (const Restriction &rest);
-	    private:
-		PrivateRestriction *priv;
-	};
-
-	typedef std::vector<CompOption> Vector;
-
-	/**
-	 * TODO
-	 */
-	class Class {
-	    public:
-		virtual ~Class() {};
-		virtual Vector & getOptions () = 0;
-
-		virtual CompOption * getOption (const CompString &name);
-
-		virtual bool setOption (const CompString &name,
-					Value            &value) = 0;
-	};
-
-    public:
-	CompOption ();
-	CompOption (const CompOption &);
-	CompOption (CompString name, Type type);
-	~CompOption ();
-
-	void setName (CompString name, Type type);
-
-	void reset ();
-
-	CompString name ();
-
-	Type type ();
-	Value & value ();
-	Restriction & rest ();
-
-	bool set (Value &val);
-	bool isAction ();
-
-	CompOption & operator= (const CompOption &option);
-
-    public:
-	static CompOption * findOption (Vector &options, CompString name,
-					unsigned int *index = NULL);
-
-	static bool
-	getBoolOptionNamed (const Vector& options,
-			    const CompString& name,
-			    bool defaultValue = false);
-
-	static int
-	getIntOptionNamed (const Vector& options,
-			   const CompString& name,
-			   int defaultValue = 0);
-
-	static float
-	getFloatOptionNamed (const Vector& options,
-			     const CompString& name,
-			     const float& defaultValue = 0.0);
-
-	static CompString
-	getStringOptionNamed (const Vector& options,
-			      const CompString& name,
-			      const CompString& defaultValue = "");
-
-	static unsigned short *
-	getColorOptionNamed (const Vector& options,
-			     const CompString& name,
-			     unsigned short *defaultValue);
-
-	static CompMatch
-	getMatchOptionNamed (const Vector& options,
-			     const CompString& name,
-			     const CompMatch& defaultValue);
-
-	static CompString typeToString (Type type);
-
-	static bool stringToColor (CompString     color,
-				   unsigned short *rgba);
-
-	static CompString colorToString (unsigned short *rgba);
-
-
-	static bool setOption (CompOption  &o, Value &value);
-
-    private:
-	PrivateOption *priv;
+class CompOption
+{
+    /**
+     * Option data types
+     */
+public:
+    typedef enum
+    {
+	TypeBool = 0,
+	TypeInt = 1,
+	TypeFloat = 2,
+	TypeString = 3,
+	TypeColor = 4,
+	TypeAction = 5,
+	TypeKey = 6,
+	TypeButton = 7,
+	TypeEdge = 8,
+	TypeBell = 9,
+	TypeMatch = 10,
+	TypeList = 11,
+	/* internal use only */
+	TypeUnset
+    } Type;
+
+    /**
+     * A value of an Option
+     */
+    class Value
+    {
+    public:
+
+	typedef boost::variant<bool, int, float, unsigned short*, CompString,
+		char*, boost::recursive_wrapper<CompMatch>,
+		boost::recursive_wrapper<CompAction>,
+		boost::recursive_wrapper<Value>,
+		boost::recursive_wrapper<std::vector<Value> > > variant_type;
+
+	typedef std::vector<Value> Vector;
+
+	Value ()
+	{
+	}
+
+	template<typename T>
+	Value (const T & t) :
+		value(t)
+	{
+	}
+
+	Type type () const
+	{
+	    return static_cast<Type>(value.which());
+	}
+
+	template<typename T>
+	void set (const T & t)
+	{
+	    value = t;
+	}
+
+	void set (Type type, const Vector & v)
+	{
+	    value = v;
+	}
+
+	bool
+	b ();
+
+	int
+	i ();
+
+	float
+	f ();
+
+	unsigned short*
+	c ();
+
+	CompString&
+	s ();
+
+	CompMatch&
+	match ();
+
+	CompAction&
+	action ();
+
+	Type
+	listType ();
+
+	Vector&
+	list ();
+
+	bool
+	operator== (const Value & rhs) const;
+
+	bool operator!= (const Value & rhs) const
+	{
+	    return (!(*this == rhs));
+	}
+
+    private:
+	variant_type value;
+    };
+
+    /**
+     * @brief Models an interval of valid values for numeric types.
+     */
+    class Restriction
+    {
+    public:
+	/**
+	 * @brief Default c'tor.
+	 */
+	Restriction ();
+
+	/**
+	 * @brief Copy c'tor.
+	 *
+	 * Replace compiler-generated copy c'tor due to pimpl
+	 * and missing copy-on-write functionality.
+	 */
+	Restriction (const Restriction &);
+
+	/**
+	 * @brief Default d'tor.
+	 *
+	 * Replace compiler-generated d'tor due to pimpl.
+	 */
+	~Restriction ();
+
+	/**
+	 * @brief Accesses the minimum valid integer value.
+	 */
+	int
+	iMin ();
+
+	/**
+	 * @brief Accesses the maximum valid integer value.
+	 */
+	int
+	iMax ();
+
+	/**
+	 * @brief Accesses the minimum valid fp value.
+	 */
+	float
+	fMin ();
+
+	/**
+	 * @brief Accesses the maximum valid fp value.
+	 */
+	float
+	fMax ();
+
+	/**
+	 * @brief Accesses the fp precision.
+	 */
+	float
+	fPrecision ();
+
+	/**
+	 * @brief Adjusts the integer bounds.
+	 */
+	void
+	set (int, int);
+
+	/**
+	 * @brief Adjusts the fp bounds and fp precision.
+	 */
+	void
+	set (float, float, float);
+
+	/**
+	 * @brief Checks the provided value if its valid w.r.t. the restriction object.
+	 * @returns true if iMin <= value <= iMax.
+	 */
+	bool
+	inRange (int);
+
+	/**
+	 * @brief Checks the provided value if its valid w.r.t. the restriction object.
+	 * @returns true if fMin <= value <= fMax.
+	 */
+	bool
+	inRange (float);
+
+	/**
+	 * @brief Assignment operator overriden due to pimpl.
+	 */
+	Restriction&
+	operator= (const Restriction &rest);
+    private:
+	PrivateRestriction *priv;
+    };
+public:
+    typedef std::vector<CompOption> Vector;
+
+    /**
+     * @brief Models a type that provides options.
+     */
+    class Class
+    {
+    public:
+	virtual ~Class ()
+	{
+	}
+	;
+
+	virtual Vector &
+	getOptions () = 0;
+
+	virtual CompOption *
+	getOption (const CompString &name);
+
+	virtual bool
+	setOption (const CompString &name, Value &value) = 0;
+    };
+
+public:
+    CompOption ();
+    CompOption (const CompOption &);
+    CompOption (CompString name, Type type);
+    ~CompOption ();
+
+    void
+    setName (CompString name, Type type);
+
+    void
+    reset ();
+
+    CompString
+    name ();
+
+    Type
+    type ();
+
+    Value &
+    value ();
+
+    Restriction &
+    rest ();
+
+    bool
+    set (Value &val);
+
+    bool
+    isAction ();
+
+    CompOption &
+    operator= (const CompOption &option);
+
+public:
+    static CompOption * findOption (Vector &options,
+				    CompString name,
+				    unsigned int *index = NULL);
+
+    static bool
+    getBoolOptionNamed (const Vector& options,
+			const CompString& name,
+			bool defaultValue = false);
+
+    static int
+    getIntOptionNamed (const Vector& options,
+		       const CompString& name,
+		       int defaultValue = 0);
+
+    static float
+    getFloatOptionNamed (const Vector& options,
+			 const CompString& name,
+			 const float& defaultValue = 0.0);
+
+    static CompString
+    getStringOptionNamed (const Vector& options,
+			  const CompString& name,
+			  const CompString& defaultValue = "");
+
+    static unsigned short *
+    getColorOptionNamed (const Vector& options,
+			 const CompString& name,
+			 unsigned short *defaultValue);
+
+    static CompMatch
+    getMatchOptionNamed (const Vector& options,
+			 const CompString& name,
+			 const CompMatch& defaultValue);
+
+    static CompString typeToString (Type type);
+
+    static bool stringToColor (CompString color, unsigned short *rgba);
+
+    static CompString colorToString (unsigned short *rgba);
+
+    static bool setOption (CompOption &o, Value &value);
+
+private:
+    PrivateOption *priv;
 };
 
 extern CompOption::Vector noOptions;

=== modified file 'src/action.cpp'
--- src/action.cpp	2011-10-31 13:51:00 +0000
+++ src/action.cpp	2012-01-09 16:07:25 +0000
@@ -33,42 +33,43 @@
 #include "privateaction.h"
 #include "privatescreen.h"
 
-struct _Modifier {
+struct _Modifier
+{
     const char *name;
-    int        modifier;
-} modifiers[] = {
-    { "<Shift>",      ShiftMask		 },
-    { "<Control>",    ControlMask	 },
-    { "<Mod1>",	      Mod1Mask		 },
-    { "<Mod2>",	      Mod2Mask		 },
-    { "<Mod3>",	      Mod3Mask		 },
-    { "<Mod4>",	      Mod4Mask		 },
-    { "<Mod5>",	      Mod5Mask		 },
-    { "<Alt>",	      CompAltMask        },
-    { "<Meta>",	      CompMetaMask       },
-    { "<Super>",      CompSuperMask      },
-    { "<Hyper>",      CompHyperMask	 },
-    { "<ModeSwitch>", CompModeSwitchMask }
-};
+    int modifier;
+} modifiers[] =
+{
+{ "<Shift>", ShiftMask },
+{ "<Control>", ControlMask },
+{ "<Mod1>", Mod1Mask },
+{ "<Mod2>", Mod2Mask },
+{ "<Mod3>", Mod3Mask },
+{ "<Mod4>", Mod4Mask },
+{ "<Mod5>", Mod5Mask },
+{ "<Alt>", CompAltMask },
+{ "<Meta>", CompMetaMask },
+{ "<Super>", CompSuperMask },
+{ "<Hyper>", CompHyperMask },
+{ "<ModeSwitch>", CompModeSwitchMask } };
 
 #define N_MODIFIERS (sizeof (modifiers) / sizeof (struct _Modifier))
 
-struct _Edge {
+struct _Edge
+{
     const char *name;
     const char *modifierName;
-} edges[] = {
-    { "Left",	     "<LeftEdge>"	 },
-    { "Right",	     "<RightEdge>"	 },
-    { "Top",	     "<TopEdge>"	 },
-    { "Bottom",	     "<BottomEdge>"	 },
-    { "TopLeft",     "<TopLeftEdge>"	 },
-    { "TopRight",    "<TopRightEdge>"	 },
-    { "BottomLeft",  "<BottomLeftEdge>"	 },
-    { "BottomRight", "<BottomRightEdge>" }
-};
+} edges[] =
+{
+{ "Left", "<LeftEdge>" },
+{ "Right", "<RightEdge>" },
+{ "Top", "<TopEdge>" },
+{ "Bottom", "<BottomEdge>" },
+{ "TopLeft", "<TopLeftEdge>" },
+{ "TopRight", "<TopRightEdge>" },
+{ "BottomLeft", "<BottomLeftEdge>" },
+{ "BottomRight", "<BottomRightEdge>" } };
 
-static CompString
-modifiersToString (unsigned int modMask)
+static CompString modifiersToString (unsigned int modMask)
 {
     CompString binding;
 
@@ -81,37 +82,34 @@
     return binding;
 }
 
-static unsigned int
-stringToModifiers (CompString  str)
+static unsigned int stringToModifiers (CompString str)
 {
     unsigned int mods = 0;
 
     for (unsigned int i = 0; i < N_MODIFIERS; i++)
     {
-	if (str.find (modifiers[i].name) != std::string::npos)
+	if (str.find(modifiers[i].name) != std::string::npos)
 	    mods |= modifiers[i].modifier;
     }
 
     return mods;
 }
 
-static unsigned int
-bindingStringToEdgeMask (CompString  str)
+static unsigned int bindingStringToEdgeMask (CompString str)
 {
     unsigned int edgeMask = 0;
 
     for (int i = 0; i < SCREEN_EDGE_NUM; i++)
-	if (str.find (edges[i].modifierName) != std::string::npos)
+	if (str.find(edges[i].modifierName) != std::string::npos)
 	    edgeMask |= 1 << i;
 
     return edgeMask;
 }
 
-static CompString
-edgeMaskToBindingString (unsigned int edgeMask)
+static CompString edgeMaskToBindingString (unsigned int edgeMask)
 {
     CompString binding;
-    int        i;
+    int i;
 
     for (i = 0; i < SCREEN_EDGE_NUM; i++)
 	if (edgeMask & (1 << i))
@@ -121,60 +119,54 @@
 }
 
 CompAction::KeyBinding::KeyBinding () :
-    mModifiers (0),
-    mKeycode (0)
+	mModifiers(0), mKeycode(0)
 {
 }
 
 CompAction::KeyBinding::KeyBinding (const KeyBinding& k) :
-    mModifiers (k.mModifiers),
-    mKeycode (k.mKeycode)
+	mModifiers(k.mModifiers), mKeycode(k.mKeycode)
 {
 }
 
 CompAction::KeyBinding::KeyBinding (int keycode, unsigned int modifiers) :
-    mModifiers (modifiers),
-    mKeycode (keycode)
+	mModifiers(modifiers), mKeycode(keycode)
 {
 }
 
-unsigned int
-CompAction::KeyBinding::modifiers () const
+unsigned int CompAction::KeyBinding::modifiers () const
 {
     return mModifiers;
 }
 
-int
-CompAction::KeyBinding::keycode () const
+int CompAction::KeyBinding::keycode () const
 {
     return mKeycode;
 }
 
-bool
-CompAction::KeyBinding::fromString (const CompString &str)
+bool CompAction::KeyBinding::fromString (const CompString &str)
 {
-    CompString   sStr;
+    CompString sStr;
     unsigned int mods;
-    size_t       pos, start = 0;
-    KeySym	 keysym;
+    size_t pos, start = 0;
+    KeySym keysym;
 
     if (!screen)
 	return false;
 
-    mods = stringToModifiers (str);
+    mods = stringToModifiers(str);
 
-    pos = str.rfind ('>');
+    pos = str.rfind('>');
     if (pos != std::string::npos)
 	start = pos + 1;
 
-    while (start < str.size () && !isalnum (str[start]))
+    while (start < str.size() && !isalnum(str[start]))
 	start++;
 
-    if (start == str.size ())
+    if (start == str.size())
     {
 	if (mods)
 	{
-	    mKeycode   = 0;
+	    mKeycode = 0;
 	    mModifiers = mods;
 
 	    return true;
@@ -183,26 +175,26 @@
 	return false;
     }
 
-    sStr   = str.substr (start);
-    keysym = XStringToKeysym (sStr.c_str ());
+    sStr = str.substr(start);
+    keysym = XStringToKeysym(sStr.c_str());
 
     if (keysym != NoSymbol)
     {
 	KeyCode keycode;
 
-	keycode = XKeysymToKeycode (screen->dpy (), keysym);
+	keycode = XKeysymToKeycode(screen->dpy(), keysym);
 	if (keycode)
 	{
-	    mKeycode   = keycode;
+	    mKeycode = keycode;
 	    mModifiers = mods;
 
 	    return true;
 	}
     }
 
-    if (sStr.compare (0, 2, "0x") == 0)
+    if (sStr.compare(0, 2, "0x") == 0)
     {
-	mKeycode   = strtol (sStr.c_str (), NULL, 0);
+	mKeycode = strtol(sStr.c_str(), NULL, 0);
 	mModifiers = mods;
 
 	return true;
@@ -211,85 +203,78 @@
     return false;
 }
 
-CompString
-CompAction::KeyBinding::toString () const
+CompString CompAction::KeyBinding::toString () const
 {
     CompString binding;
 
     if (!screen)
 	return "";
 
-    binding = modifiersToString (mModifiers);
+    binding = modifiersToString(mModifiers);
 
     if (mKeycode != 0)
     {
 	KeySym keysym;
-	char   *keyname;
+	char *keyname;
 
-	keysym  = XKeycodeToKeysym (screen->dpy (), mKeycode, 0);
-	keyname = XKeysymToString (keysym);
+	keysym = XKeycodeToKeysym(screen->dpy(), mKeycode, 0);
+	keyname = XKeysymToString(keysym);
 
 	if (keyname)
 	    binding += keyname;
 	else
-	    binding += compPrintf ("0x%x", mKeycode);
+	    binding += compPrintf("0x%x", mKeycode);
     }
 
     return binding;
 }
 
 CompAction::ButtonBinding::ButtonBinding () :
-    mModifiers (0),
-    mButton (0)
+	mModifiers(0), mButton(0)
 {
 }
 
 CompAction::ButtonBinding::ButtonBinding (const ButtonBinding& b) :
-    mModifiers (b.mModifiers),
-    mButton (b.mButton)
+	mModifiers(b.mModifiers), mButton(b.mButton)
 {
 }
 
 CompAction::ButtonBinding::ButtonBinding (int button, unsigned int modifiers) :
-    mModifiers (modifiers),
-    mButton (button)
+	mModifiers(modifiers), mButton(button)
 {
 }
 
-unsigned int
-CompAction::ButtonBinding::modifiers () const
+unsigned int CompAction::ButtonBinding::modifiers () const
 {
     return mModifiers;
 }
 
-int
-CompAction::ButtonBinding::button () const
+int CompAction::ButtonBinding::button () const
 {
     return mButton;
 }
 
-bool
-CompAction::ButtonBinding::fromString (const CompString &str)
+bool CompAction::ButtonBinding::fromString (const CompString &str)
 {
     unsigned int mods;
-    size_t       pos, start = 0;
-
-    mods = stringToModifiers (str);
-
-    pos = str.rfind ('>');
+    size_t pos, start = 0;
+
+    mods = stringToModifiers(str);
+
+    pos = str.rfind('>');
     if (pos != std::string::npos)
 	start = pos + 1;
 
-    while (start < str.size () && !isalnum (str[start]))
+    while (start < str.size() && !isalnum(str[start]))
 	start++;
 
-    if (start != str.size () && str.compare (start, 6, "Button") == 0)
+    if (start != str.size() && str.compare(start, 6, "Button") == 0)
     {
 	int buttonNum;
 
-	if (sscanf (str.substr (start + 6).c_str (), "%d", &buttonNum) == 1)
+	if (sscanf(str.substr(start + 6).c_str(), "%d", &buttonNum) == 1)
 	{
-	    mButton    = buttonNum;
+	    mButton = buttonNum;
 	    mModifiers = mods;
 
 	    return true;
@@ -299,27 +284,26 @@
     return false;
 }
 
-CompString
-CompAction::ButtonBinding::toString () const
+CompString CompAction::ButtonBinding::toString () const
 {
     CompString binding;
 
     if (!mModifiers && !mButton)
 	return "";
 
-    binding = modifiersToString (mModifiers);
-    binding += compPrintf ("Button%d", mButton);
+    binding = modifiersToString(mModifiers);
+    binding += compPrintf("Button%d", mButton);
 
     return binding;
 }
 
 CompAction::CompAction () :
-    priv (new PrivateAction ())
+	priv(new PrivateAction())
 {
 }
 
 CompAction::CompAction (const CompAction & a) :
-    priv (new PrivateAction (*a.priv))
+	priv(new PrivateAction(*a.priv))
 {
 }
 
@@ -328,38 +312,32 @@
     delete priv;
 }
 
-CompAction::CallBack
-CompAction::initiate ()
+CompAction::CallBack CompAction::initiate ()
 {
     return priv->initiate;
 }
 
-CompAction::CallBack
-CompAction::terminate ()
+CompAction::CallBack CompAction::terminate ()
 {
     return priv->terminate;
 }
 
-void
-CompAction::setInitiate (const CompAction::CallBack &initiate)
+void CompAction::setInitiate (const CompAction::CallBack &initiate)
 {
     priv->initiate = initiate;
 }
 
-void
-CompAction::setTerminate (const CompAction::CallBack &terminate)
+void CompAction::setTerminate (const CompAction::CallBack &terminate)
 {
     priv->terminate = terminate;
 }
 
-CompAction::State
-CompAction::state ()
+CompAction::State CompAction::state ()
 {
     return priv->state;
 }
 
-CompAction::BindingType
-CompAction::type ()
+CompAction::BindingType CompAction::type ()
 {
     return priv->type;
 }
@@ -370,12 +348,11 @@
     return priv->key;
 }
 
-void
-CompAction::setKey (const CompAction::KeyBinding &key)
+void CompAction::setKey (const CompAction::KeyBinding &key)
 {
     priv->key = key;
 
-    if (key.modifiers () || key.keycode ())
+    if (key.modifiers() || key.keycode())
 	priv->type = CompAction::BindingTypeKey;
     else
 	priv->type = CompAction::BindingTypeNone;
@@ -387,12 +364,11 @@
     return priv->button;
 }
 
-void
-CompAction::setButton (const CompAction::ButtonBinding &button)
+void CompAction::setButton (const CompAction::ButtonBinding &button)
 {
     priv->button = button;
 
-    if (button.modifiers () || button.button ())
+    if (button.modifiers() || button.button())
     {
 	if (priv->edgeMask)
 	    priv->type = CompAction::BindingTypeEdgeButton;
@@ -405,19 +381,17 @@
     }
 }
 
-unsigned int
-CompAction::edgeMask ()
+unsigned int CompAction::edgeMask ()
 {
     return priv->edgeMask;
 }
 
-void
-CompAction::setEdgeMask (unsigned int edge)
+void CompAction::setEdgeMask (unsigned int edge)
 {
     priv->edgeMask = edge;
 
-    if (priv->type == CompAction::BindingTypeEdgeButton ||
-        priv->type == CompAction::BindingTypeButton)
+    if (priv->type == CompAction::BindingTypeEdgeButton
+	    || priv->type == CompAction::BindingTypeButton)
     {
 	if (priv->edgeMask)
 	    priv->type = CompAction::BindingTypeEdgeButton;
@@ -426,54 +400,49 @@
     }
 }
 
-bool
-CompAction::bell ()
+bool CompAction::bell ()
 {
     return priv->bell;
 }
 
-void
-CompAction::setBell (bool bell)
+void CompAction::setBell (bool bell)
 {
     priv->bell = bell;
 }
 
-void
-CompAction::setState (CompAction::State state)
+void CompAction::setState (CompAction::State state)
 {
     priv->state = state;
 }
 
-void
-CompAction::copyState (const CompAction &action)
+void CompAction::copyState (const CompAction &action)
 {
-    priv->initiate  = action.priv->initiate;
+    priv->initiate = action.priv->initiate;
     priv->terminate = action.priv->terminate;
-    priv->state     = action.priv->state;
+    priv->state = action.priv->state;
 
-    memcpy (&priv->priv, &action.priv->priv, sizeof (CompPrivate));
+    memcpy(&priv->priv, &action.priv->priv, sizeof(CompPrivate));
 }
 
-bool
-CompAction::operator== (const CompAction& val)
+bool CompAction::operator== (const CompAction& val) const
 {
     if (priv->state != val.priv->state)
 	return false;
     if (priv->type != val.priv->type)
 	return false;
-    if (priv->key.modifiers () != val.priv->key.modifiers ())
-	return false;
-    if (priv->key.keycode () != val.priv->key.keycode ())
-	return false;
-    if (priv->button.modifiers () != val.priv->button.modifiers ())
-	return false;
-    if (priv->button.button () != val.priv->button.button ())
+    if (priv->key.modifiers() != val.priv->key.modifiers())
+	return false;
+    if (priv->key.keycode() != val.priv->key.keycode())
+	return false;
+    if (priv->button.modifiers() != val.priv->button.modifiers())
+	return false;
+    if (priv->button.button() != val.priv->button.button())
 	return false;
     if (priv->bell != val.priv->bell)
 	return false;
     if (priv->edgeMask != val.priv->edgeMask)
 	return false;
-    if (memcmp (&priv->priv, &val.priv->priv, sizeof (CompPrivate)) != 0)
+    if (memcmp(&priv->priv, &val.priv->priv, sizeof(CompPrivate)) != 0)
 	return false;
 
     return true;
@@ -486,15 +455,14 @@
 	return *this;
 
     delete priv;
-    priv = new PrivateAction (*action.priv);
+    priv = new PrivateAction(*action.priv);
 
     return *this;
 }
 
-bool
-CompAction::keyFromString (const CompString &str)
+bool CompAction::keyFromString (const CompString &str)
 {
-    bool retval = priv->key.fromString (str);
+    bool retval = priv->key.fromString(str);
 
     if (retval)
     {
@@ -510,14 +478,13 @@
     return retval;
 }
 
-bool
-CompAction::buttonFromString (const CompString &str)
+bool CompAction::buttonFromString (const CompString &str)
 {
-    bool retval = priv->button.fromString (str);
+    bool retval = priv->button.fromString(str);
 
     if (retval)
     {
-	priv->edgeMask = bindingStringToEdgeMask (str);
+	priv->edgeMask = bindingStringToEdgeMask(str);
 	if (priv->edgeMask)
 	    priv->type = CompAction::BindingTypeEdgeButton;
 	else
@@ -533,26 +500,25 @@
     return retval;
 }
 
-bool
-CompAction::edgeMaskFromString (const CompString &str)
+bool CompAction::edgeMaskFromString (const CompString &str)
 {
     unsigned int edgeMask = 0;
-    size_t       pos;
+    size_t pos;
 
     for (int i = 0; i < SCREEN_EDGE_NUM; i++)
     {
 	pos = 0;
-	while ((pos = str.find (edgeToString (i), pos)) != std::string::npos)
+	while ((pos = str.find(edgeToString(i), pos)) != std::string::npos)
 	{
-	    if (pos > 0 && isalnum (str[pos - 1]))
+	    if (pos > 0 && isalnum(str[pos - 1]))
 	    {
 		pos++;
 		continue;
 	    }
 
-	    pos += edgeToString (i).size ();
+	    pos += edgeToString(i).size();
 
-	    if (pos < str.size () && isalnum (str[pos]))
+	    if (pos < str.size() && isalnum(str[pos]))
 		continue;
 
 	    edgeMask |= 1 << i;
@@ -561,39 +527,36 @@
 
     priv->edgeMask = edgeMask;
 
-    return (edgeMask != 0 || str.empty ());
+    return (edgeMask != 0 || str.empty());
 }
 
-CompString
-CompAction::keyToString ()
+CompString CompAction::keyToString ()
 {
     CompString binding;
 
-    binding = priv->key.toString ();
-    if (!binding.size ())
+    binding = priv->key.toString();
+    if (!binding.size())
 	return "Disabled";
 
     return binding;
 }
 
-CompString
-CompAction::buttonToString ()
+CompString CompAction::buttonToString ()
 {
     CompString binding, edge;
 
-    binding = modifiersToString (priv->button.modifiers ());
-    binding += edgeMaskToBindingString (priv->edgeMask);
-
-    binding += compPrintf ("Button%d", priv->button.button ());
-
-    if (!priv->button.button ())
+    binding = modifiersToString(priv->button.modifiers());
+    binding += edgeMaskToBindingString(priv->edgeMask);
+
+    binding += compPrintf("Button%d", priv->button.button());
+
+    if (!priv->button.button())
 	return "Disabled";
 
     return binding;
 }
 
-CompString
-CompAction::edgeMaskToString ()
+CompString CompAction::edgeMaskToString ()
 {
     CompString edge;
 
@@ -601,53 +564,50 @@
     {
 	if (priv->edgeMask & (1 << i))
 	{
-	    if (!edge.empty ())
+	    if (!edge.empty())
 		edge += " | ";
 
-	    edge += edgeToString (i);
+	    edge += edgeToString(i);
 	}
     }
 
     return edge;
 }
 
-
-CompString
-CompAction::edgeToString (unsigned int edge)
+CompString CompAction::edgeToString (unsigned int edge)
 {
     return edges[edge].name;
 }
 
-bool
-CompAction::active ()
+bool CompAction::active ()
 {
     return priv->active;
 }
 
 PrivateAction::PrivateAction () :
-    initiate (),
-    terminate (),
-    state (0),
-    type (0),
-    key (),
-    button (),
-    bell (false),
-    edgeMask (0),
-    active (false)
+	initiate(),
+		terminate(),
+		state(0),
+		type(0),
+		key(),
+		button(),
+		bell(false),
+		edgeMask(0),
+		active(false)
 {
-    memset (&priv, 0, sizeof (CompPrivate));
+    memset(&priv, 0, sizeof(CompPrivate));
 }
 
 PrivateAction::PrivateAction (const PrivateAction& a) :
-    initiate (a.initiate),
-    terminate (a.terminate),
-    state (a.state),
-    type (a.type),
-    key (a.key),
-    button (a.button),
-    bell (a.bell),
-    edgeMask (a.edgeMask),
-    active (a.active)
+	initiate(a.initiate),
+		terminate(a.terminate),
+		state(a.state),
+		type(a.type),
+		key(a.key),
+		button(a.button),
+		bell(a.bell),
+		edgeMask(a.edgeMask),
+		active(a.active)
 {
-    memcpy (&priv, &a.priv, sizeof (CompPrivate));
+    memcpy(&priv, &a.priv, sizeof(CompPrivate));
 }

=== modified file 'src/option.cpp'
--- src/option.cpp	2010-11-11 03:14:20 +0000
+++ src/option.cpp	2012-01-09 16:07:25 +0000
@@ -32,491 +32,89 @@
 #include <boost/foreach.hpp>
 #define foreach BOOST_FOREACH
 
+#include <core/action.h>
 #include <core/core.h>
 #include <core/option.h>
 #include "privateoption.h"
 
-CompOption::Vector noOptions (0);
-
-CompOption::Value::Value () :
-    priv (new PrivateValue ())
-{
-}
-
-CompOption::Value::Value (const Value &v) :
-    priv (new PrivateValue (*v.priv))
-{
-}
-
-CompOption::Value::~Value ()
-{
-    delete priv;
-}
-
-CompOption::Value::Value (const bool b) :
-    priv (new PrivateValue ())
-{
-    set (b);
-}
-
-CompOption::Value::Value (const int i) :
-    priv (new PrivateValue ())
-{
-    set (i);
-}
-
-CompOption::Value::Value (const float f) :
-    priv (new PrivateValue ())
-{
-    set (f);
-}
-
-CompOption::Value::Value (const unsigned short *color) :
-    priv (new PrivateValue ())
-{
-    set (color);
-}
-
-CompOption::Value::Value (const CompString& s) :
-    priv (new PrivateValue ())
-{
-    set (s);
-}
-
-CompOption::Value::Value (const char *s) :
-    priv (new PrivateValue ())
-{
-    set (s);
-}
-
-
-CompOption::Value::Value (const CompMatch& m) :
-    priv (new PrivateValue ())
-{
-    set (m);
-}
-
-CompOption::Value::Value (const CompAction& a) :
-    priv (new PrivateValue ())
-{
-    set (a);
-}
-
-CompOption::Value::Value (CompOption::Type type, const Vector& l) :
-    priv (new PrivateValue ())
-{
-    set (type, l);
-}
-
-CompOption::Type
-CompOption::Value::type () const
-{
-    return priv->type;
-}
-
-void
-CompOption::Value::set (const bool b)
-{
-    priv->reset ();
-    priv->type = CompOption::TypeBool;
-    priv->value.b = b;
-}
-
-void
-CompOption::Value::set (const int i)
-{
-    priv->reset ();
-    priv->type = CompOption::TypeInt;
-    priv->value.i = i;
-}
-
-void
-CompOption::Value::set (const float f)
-{
-    priv->reset ();
-    priv->type = CompOption::TypeFloat;
-    priv->value.f = f;
-}
-
-void
-CompOption::Value::set (const unsigned short *color)
-{
-    priv->reset ();
-    priv->type = CompOption::TypeColor;
-    priv->value.c[0] = color[0];
-    priv->value.c[1] = color[1];
-    priv->value.c[2] = color[2];
-    priv->value.c[3] = color[3];
-}
-
-void
-CompOption::Value::set (const CompString& s)
-{
-    priv->reset ();
-    priv->type = CompOption::TypeString;
-    priv->string = s;
-}
-
-void
-CompOption::Value::set (const char *s)
-{
-    priv->reset ();
-    priv->type = CompOption::TypeString;
-    priv->string = CompString (s);
-}
-
-void
-CompOption::Value::set (const CompMatch& m)
-{
-    priv->reset ();
-    priv->type = CompOption::TypeMatch;
-    priv->match = m;
-}
-
-void
-CompOption::Value::set (const CompAction& a)
-{
-    priv->reset ();
-    priv->type = CompOption::TypeAction;
-    priv->action = a;
-}
-
-void
-CompOption::Value::set (CompOption::Type type, const Vector& l)
-{
-    priv->reset ();
-    priv->type = CompOption::TypeList;
-    priv->list = l;
-    priv->listType = type;
-}
-
-static bool
-checkIsAction (CompOption::Type type)
-{
-    switch (type) {
-	case CompOption::TypeAction:
-	case CompOption::TypeKey:
-	case CompOption::TypeButton:
-	case CompOption::TypeEdge:
-	case CompOption::TypeBell:
-	    return true;
-	default:
-	    break;
+CompOption::Vector noOptions(0);
+
+static bool checkIsAction (CompOption::Type type)
+{
+    switch (type)
+    {
+    case CompOption::TypeAction:
+    case CompOption::TypeKey:
+    case CompOption::TypeButton:
+    case CompOption::TypeEdge:
+    case CompOption::TypeBell:
+	return true;
+    default:
+	break;
     }
 
     return false;
 }
 
-bool
-CompOption::Value::b ()
-{
-    if (!priv->checkType (CompOption::TypeBool))
-	return false;
-
-    return priv->value.b;
-}
-
-int
-CompOption::Value::i ()
-{
-    if (!priv->checkType (CompOption::TypeInt))
-	return 0;
-
-    return priv->value.i;
-}
-
-float
-CompOption::Value::f ()
-{
-    if (!priv->checkType (CompOption::TypeFloat))
-	return 0.0;
-
-    return priv->value.f;
-}
-
-static unsigned short defaultColor[4] = { 0x0, 0x0, 0x0, 0xffff};
-
-unsigned short *
+bool CompOption::Value::b ()
+{
+    return boost::get<bool>(value);
+}
+int CompOption::Value::i ()
+{
+    return boost::get<int>(value);
+}
+float CompOption::Value::f ()
+{
+    return boost::get<float>(value);
+}
+unsigned short*
 CompOption::Value::c ()
 {
-    if (!priv->checkType (CompOption::TypeColor))
-	return reinterpret_cast<unsigned short *> (defaultColor);
-
-    return priv->value.c;
+    return boost::get<unsigned short*>(value);
 }
 
-CompString
+CompString&
 CompOption::Value::s ()
 {
-    if (!priv->checkType (CompOption::TypeString))
-	return "";
-
-    return priv->string;
+    return boost::get<CompString>(value);
 }
 
-CompMatch &
+CompMatch&
 CompOption::Value::match ()
 {
-    priv->checkType (CompOption::TypeMatch);
-
-    return priv->match;
+    return boost::get<CompMatch>(value);
 }
 
-CompAction &
+CompAction&
 CompOption::Value::action ()
 {
-    priv->checkType (priv->type);
-
-    if (!checkIsAction (priv->type))
-	compLogMessage ("core", CompLogLevelWarn,
-			"CompOption::Value not an action");
-
-    return priv->action;
+    return boost::get<CompAction>(value);
 }
 
-CompOption::Type
-CompOption::Value::listType ()
+CompOption::Type CompOption::Value::listType ()
 {
-    priv->checkType (CompOption::TypeList);
-
-    return priv->listType;
+    return type();
 }
 
-CompOption::Value::Vector &
+CompOption::Value::Vector&
 CompOption::Value::list ()
 {
-    priv->checkType (CompOption::TypeList);
-
-    return priv->list;
-}
-
-CompOption::Value::operator bool ()
-{
-    return b ();
-}
-
-CompOption::Value::operator int ()
-{
-    return i ();
-}
-
-CompOption::Value::operator float ()
-{
-    return f ();
-}
-
-CompOption::Value::operator unsigned short * ()
-{
-    return c ();
-}
-
-CompOption::Value::operator CompString ()
-{
-    return s ();
-}
-
-CompOption::Value::operator CompMatch & ()
-{
-    return match ();
-}
-
-CompOption::Value::operator CompAction & ()
-{
-    return action ();
-}
-
-CompOption::Value::operator CompAction * ()
-{
-    return &action ();
-}
-
-CompOption::Value::operator Type ()
-{
-    return listType ();
-}
-
-CompOption::Value::operator Vector & ()
-{
-    return list ();
-}
-
-bool
-CompOption::Value::operator== (const CompOption::Value &val)
-{
-    if (priv->type != val.priv->type)
-	return false;
-
-    switch (priv->type)
-    {
-	case CompOption::TypeBool:
-	    return priv->value.b == val.priv->value.b;
-	    break;
-
-	case CompOption::TypeInt:
-	    return priv->value.i == val.priv->value.i;
-	    break;
-
-	case CompOption::TypeFloat:
-	    return priv->value.f == val.priv->value.f;
-	    break;
-
-	case CompOption::TypeColor:
-	    return (priv->value.c[0] == val.priv->value.c[0]) &&
-		   (priv->value.c[1] == val.priv->value.c[1]) &&
-		   (priv->value.c[2] == val.priv->value.c[2]) &&
-		   (priv->value.c[3] == val.priv->value.c[3]);
-	    break;
-
-	case CompOption::TypeString:
-	    return priv->string.compare (val.priv->string) == 0;
-	    break;
-
-	case CompOption::TypeMatch:
-	    return priv->match == val.priv->match;
-	    break;
-
-	case CompOption::TypeAction:
-	    return priv->action == val.priv->action;
-	    break;
-
-	case CompOption::TypeList:
-	    if (priv->listType != val.priv->listType)
-		return false;
-
-	    if (priv->list.size () != val.priv->list.size ())
-		return false;
-
-	    for (unsigned int i = 0; i < priv->list.size (); i++)
-		if (priv->list[i] != val.priv->list[i])
-		    return false;
-
-	    return true;
-	    break;
-
-	default:
-	    break;
-    }
-
-    return true;
-}
-
-bool
-CompOption::Value::operator!= (const CompOption::Value &val)
-{
-    return !(*this == val);
-}
-
-static void
-finiOptionValue (CompOption::Value &v,
-		 CompOption::Type  type)
-{
-    switch (type) {
-	case CompOption::TypeAction:
-	case CompOption::TypeKey:
-	case CompOption::TypeButton:
-	case CompOption::TypeEdge:
-	case CompOption::TypeBell:
-	    if (v.action ().state () & CompAction::StateAutoGrab && screen)
-		screen->removeAction (&v.action ());
-	    break;
-
-	case CompOption::TypeList:
-	    foreach (CompOption::Value &val, v.list ())
-		finiOptionValue (val, v.listType ());
-	    break;
-
-	default:
-	    break;
-    }
-}
-
-CompOption::Value &
-CompOption::Value::operator= (const CompOption::Value &val)
-{
-    if (this == &val)
-	return *this;
-
-    finiOptionValue (*this, priv->type);
-
-    delete priv;
-    priv = new PrivateValue (*val.priv);
-
-    return *this;
-}
-
-PrivateValue::PrivateValue () :
-    type (CompOption::TypeUnset),
-    string (""),
-    action (),
-    match (),
-    listType (CompOption::TypeUnset),
-    list ()
-{
-    memset (&value, 0, sizeof (ValueUnion));
-}
-
-PrivateValue::PrivateValue (const PrivateValue& p) :
-    type (p.type),
-    string (p.string),
-    action (p.action),
-    match (p.match),
-    listType (p.listType),
-    list (p.list)
-{
-    memcpy (&value, &p.value, sizeof (ValueUnion));
-}
-
-bool
-PrivateValue::checkType (CompOption::Type refType)
-{
-    if (type == CompOption::TypeUnset)
-    {
-	compLogMessage ("core", CompLogLevelWarn,
-			"Value type is not yet set");
-	return false;
-    }
-
-    if (type != refType)
-    {
-	compLogMessage ("core", CompLogLevelWarn,
-			"Value type does not match (is %d, expected %d)",
-			type, refType);
-	return false;
-    }
-
-    return true;
-}
-
-void
-PrivateValue::reset ()
-{
-    switch (type) {
-	case CompOption::TypeString:
-	    string = "";
-	    break;
-	case CompOption::TypeMatch:
-	    match = CompMatch ();
-	    break;
-	case CompOption::TypeAction:
-	    action = CompAction ();
-	    break;
-	case CompOption::TypeList:
-	    list.clear ();
-	    listType = CompOption::TypeBool;
-	    break;
-	default:
-	    break;
-    }
-    type = CompOption::TypeBool;
+    return boost::get<CompOption::Value::Vector>(value);
+}
+
+bool CompOption::Value::operator== (const Value & rhs) const
+{
+    return value == rhs.value;
 }
 
 CompOption::Restriction::Restriction () :
-    priv (new PrivateRestriction ())
+	priv(new PrivateRestriction())
 {
 }
 
 CompOption::Restriction::Restriction (const CompOption::Restriction &r) :
-    priv (new PrivateRestriction (*r.priv))
+	priv(new PrivateRestriction(*r.priv))
 {
 }
 
@@ -525,66 +123,57 @@
     delete priv;
 }
 
-int
-CompOption::Restriction::iMin ()
+int CompOption::Restriction::iMin ()
 {
     if (priv->type == CompOption::TypeInt)
 	return priv->rest.i.min;
     return MINSHORT;
 }
 
-int
-CompOption::Restriction::iMax ()
+int CompOption::Restriction::iMax ()
 {
     if (priv->type == CompOption::TypeInt)
 	return priv->rest.i.max;
     return MAXSHORT;
 }
 
-float
-CompOption::Restriction::fMin ()
-{
-    if (priv->type == CompOption::TypeFloat)
-	return priv->rest.f.min;
-    return MINSHORT;
-}
-
-float
-CompOption::Restriction::fMax ()
-{
-    if (priv->type == CompOption::TypeFloat)
-	return priv->rest.f.min;
-    return MINSHORT;
-}
-
-float
-CompOption::Restriction::fPrecision ()
+float CompOption::Restriction::fMin ()
+{
+    if (priv->type == CompOption::TypeFloat)
+	return priv->rest.f.min;
+    return MINSHORT;
+}
+
+float CompOption::Restriction::fMax ()
+{
+    if (priv->type == CompOption::TypeFloat)
+	return priv->rest.f.min;
+    return MINSHORT;
+}
+
+float CompOption::Restriction::fPrecision ()
 {
     if (priv->type == CompOption::TypeFloat)
 	return priv->rest.f.precision;
     return 0.1f;
 }
 
-
-void
-CompOption::Restriction::set (int min, int max)
+void CompOption::Restriction::set (int min, int max)
 {
     priv->type = CompOption::TypeInt;
     priv->rest.i.min = min;
     priv->rest.i.max = max;
 }
 
-void
-CompOption::Restriction::set (float min, float max, float precision)
+void CompOption::Restriction::set (float min, float max, float precision)
 {
     priv->type = CompOption::TypeFloat;
-    priv->rest.f.min       = min;
-    priv->rest.f.max       = max;
+    priv->rest.f.min = min;
+    priv->rest.f.max = max;
     priv->rest.f.precision = precision;
 }
 
-bool
-CompOption::Restriction::inRange (int i)
+bool CompOption::Restriction::inRange (int i)
 {
     if (priv->type != CompOption::TypeInt)
 	return true;
@@ -595,8 +184,7 @@
     return true;
 }
 
-bool
-CompOption::Restriction::inRange (float f)
+bool CompOption::Restriction::inRange (float f)
 {
     if (priv->type != CompOption::TypeFloat)
 	return true;
@@ -613,26 +201,25 @@
     if (this == &rest)
 	return *this;
 
-    delete priv;
-    priv = new PrivateRestriction (*rest.priv);
+    *priv = *rest.priv;
     return *this;
 }
 
 CompOption *
 CompOption::Class::getOption (const CompString &name)
 {
-    CompOption *o = CompOption::findOption (getOptions (), name);
+    CompOption *o = CompOption::findOption(getOptions(), name);
     return o;
 }
 
 CompOption *
 CompOption::findOption (CompOption::Vector &options,
-			CompString         name,
-			unsigned int       *index)
+			CompString name,
+			unsigned int *index)
 {
     unsigned int i;
 
-    for (i = 0; i < options.size (); i++)
+    for (i = 0; i < options.size(); i++)
     {
 	if (options[i].priv->name == name)
 	{
@@ -647,74 +234,70 @@
 }
 
 CompOption::CompOption () :
-    priv (new PrivateOption ())
+	priv(new PrivateOption())
 {
 }
 
 CompOption::CompOption (const CompOption &o) :
-    priv (new PrivateOption (*o.priv))
+	priv(new PrivateOption(*o.priv))
 {
 }
 
 CompOption::CompOption (CompString name, CompOption::Type type) :
-    priv (new PrivateOption ())
+	priv(new PrivateOption())
 {
-    setName (name, type);
+    setName(name, type);
 }
 
-static void
-finiScreenOptionValue (CompScreen        *s,
-		       CompOption::Value &v,
-		       CompOption::Type  type)
+static void finiScreenOptionValue (CompScreen *s,
+				   CompOption::Value &v,
+				   CompOption::Type type)
 {
-    switch (type) {
-	case CompOption::TypeAction:
-	case CompOption::TypeKey:
-	case CompOption::TypeButton:
-	case CompOption::TypeEdge:
-	case CompOption::TypeBell:
-	    if (v.action ().state () & CompAction::StateAutoGrab)
-		s->removeAction (&v.action ());
-	    break;
-
-	case CompOption::TypeList:
-	    foreach (CompOption::Value &val, v.list ())
-		finiScreenOptionValue (s, val, v.listType ());
-	    break;
-
-	default:
-	    break;
+    switch (type)
+    {
+    case CompOption::TypeAction:
+    case CompOption::TypeKey:
+    case CompOption::TypeButton:
+    case CompOption::TypeEdge:
+    case CompOption::TypeBell:
+	if (v.action().state() & CompAction::StateAutoGrab)
+	    s->removeAction(&v.action());
+	break;
+
+    case CompOption::TypeList:
+	foreach (CompOption::Value &val, v.list ())
+		    finiScreenOptionValue(s, val, v.listType());
+	break;
+
+    default:
+	break;
     }
 }
 
 CompOption::~CompOption ()
 {
-    finiOptionValue (priv->value, priv->type);
+    // finiOptionValue (priv->value, priv->type);
     delete priv;
 }
 
-void
-CompOption::reset ()
+void CompOption::reset ()
 {
     priv->name = "";
     priv->type = TypeUnset;
 }
 
-void
-CompOption::setName (CompString name, CompOption::Type type)
+void CompOption::setName (CompString name, CompOption::Type type)
 {
     priv->name = name;
     priv->type = type;
 }
 
-CompString
-CompOption::name ()
+CompString CompOption::name ()
 {
     return priv->name;
 }
 
-CompOption::Type
-CompOption::type ()
+CompOption::Type CompOption::type ()
 {
     return priv->type;
 }
@@ -731,74 +314,73 @@
     return priv->rest;
 }
 
-bool
-CompOption::set (CompOption::Value &val)
+bool CompOption::set (CompOption::Value &val)
 {
-    if (isAction () && priv->type != CompOption::TypeAction)
-	val.action ().copyState (priv->value.action ());
+    if (isAction() && priv->type != CompOption::TypeAction)
+	val.action().copyState(priv->value.action());
 
-    if (priv->type != val.type () &&
-	(!isAction () || !checkIsAction (val.type ())))
+    if (priv->type != val.type() && (!isAction() || !checkIsAction(val.type())))
     {
-	compLogMessage ("core", CompLogLevelWarn,
-			"Can't set Value with type %d to "
-			"option \"%s\" with type %d",
-			val.type (), priv->name.c_str (), priv->type);
+	compLogMessage("core", CompLogLevelWarn,
+		"Can't set Value with type %d to "
+			"option \"%s\" with type %d", val.type(),
+		priv->name.c_str(), priv->type);
 	return false;
     }
 
     if (priv->value == val)
 	return false;
 
-    if (isAction () &&
-        priv->value.action ().state () & CompAction::StateAutoGrab && screen)
+    if (isAction() && priv->value.action().state() & CompAction::StateAutoGrab
+	    && screen)
     {
-	if (!screen->addAction (&val.action ()))
+	if (!screen->addAction(&val.action()))
 	    return false;
 	else
-	    screen->removeAction (&priv->value.action ());
+	    screen->removeAction(&priv->value.action());
     }
 
     switch (priv->type)
     {
-	case CompOption::TypeInt:
-	    if (!priv->rest.inRange (val.i ()))
-		return false;
-	    break;
-
-	case CompOption::TypeFloat:
-	{
-	    float v, p;
-	    int sign = (val.f () < 0 ? -1 : 1);
-
-	    if (!priv->rest.inRange (val.f ()))
-		return false;
-
-	    p = 1.0f / priv->rest.fPrecision ();
-	    v = ((int) (val.f () * p + sign * 0.5f)) / p;
-
-	    priv->value.set (v);
-	    return true;
-	}
-
-	case CompOption::TypeAction:
-	    return false;
-
-	case CompOption::TypeKey:
-	    if (val.action ().type () == value().action ().type () &&
-		!(val.action ().type () & CompAction::BindingTypeKey))
-		return false;
-	    break;
-
-	case CompOption::TypeButton:
-	    if (val.action ().type () == value().action ().type () &&
-		!(val.action ().type () & (CompAction::BindingTypeButton |
-					   CompAction::BindingTypeEdgeButton)))
-		return false;
-	    break;
-
-	default:
-	    break;
+    case CompOption::TypeInt:
+	if (!priv->rest.inRange(val.i()))
+	    return false;
+	break;
+
+    case CompOption::TypeFloat:
+    {
+	float v, p;
+	int sign = (val.f() < 0 ? -1 : 1);
+
+	if (!priv->rest.inRange(val.f()))
+	    return false;
+
+	p = 1.0f / priv->rest.fPrecision();
+	v = ((int) (val.f() * p + sign * 0.5f)) / p;
+
+	priv->value.set(v);
+	return true;
+    }
+
+    case CompOption::TypeAction:
+	return false;
+
+    case CompOption::TypeKey:
+	if (val.action().type() == value().action().type()
+		&& !(val.action().type() & CompAction::BindingTypeKey))
+	    return false;
+	break;
+
+    case CompOption::TypeButton:
+	if (val.action().type() == value().action().type()
+		&& !(val.action().type()
+			& (CompAction::BindingTypeButton
+				| CompAction::BindingTypeEdgeButton)))
+	    return false;
+	break;
+
+    default:
+	break;
     }
 
     priv->value = val;
@@ -806,10 +388,9 @@
     return true;
 }
 
-bool
-CompOption::isAction ()
+bool CompOption::isAction ()
 {
-    return checkIsAction (priv->type);
+    return checkIsAction(priv->type);
 }
 
 CompOption &
@@ -819,90 +400,87 @@
 	return *this;
 
     delete priv;
-    priv = new PrivateOption (*option.priv);
+    priv = new PrivateOption(*option.priv);
     return *this;
 }
 
-bool
-CompOption::getBoolOptionNamed (const Vector&     options,
-				const CompString& name,
-				bool              defaultValue)
-{
-    foreach (const CompOption &o, options)
-	if (o.priv->type == CompOption::TypeBool && o.priv->name == name)
-	    return o.priv->value.b ();
-
-    return defaultValue;
-}
-
-int
-CompOption::getIntOptionNamed (const Vector&     options,
-			       const CompString& name,
-			       int               defaultValue)
-{
-    foreach (const CompOption &o, options)
-	if (o.priv->type == CompOption::TypeInt && o.priv->name == name)
-	    return o.priv->value.i ();
-
-    return defaultValue;
-}
-
-float
-CompOption::getFloatOptionNamed (const Vector&     options,
-				 const CompString& name,
-				 const float&      defaultValue)
-{
-    foreach (const CompOption &o, options)
-	if (o.priv->type == CompOption::TypeFloat && o.priv->name == name)
-	    return o.priv->value.f ();
-
-    return defaultValue;
-}
-
-CompString
-CompOption::getStringOptionNamed (const Vector&     options,
-				  const CompString& name,
-				  const CompString& defaultValue)
-{
-    foreach (const CompOption &o, options)
-	if (o.priv->type == CompOption::TypeString && o.priv->name == name)
-	    return o.priv->value.s ();
+bool CompOption::getBoolOptionNamed (const Vector& options,
+				     const CompString& name,
+				     bool defaultValue)
+{
+    foreach (const CompOption &o, options)
+		if (o.priv->type == CompOption::TypeBool
+			&& o.priv->name == name)
+		    return o.priv->value.b();
+
+    return defaultValue;
+}
+
+int CompOption::getIntOptionNamed (const Vector& options,
+				   const CompString& name,
+				   int defaultValue)
+{
+    foreach (const CompOption &o, options)
+		if (o.priv->type == CompOption::TypeInt && o.priv->name == name)
+		    return o.priv->value.i();
+
+    return defaultValue;
+}
+
+float CompOption::getFloatOptionNamed (const Vector& options,
+				       const CompString& name,
+				       const float& defaultValue)
+{
+    foreach (const CompOption &o, options)
+		if (o.priv->type == CompOption::TypeFloat
+			&& o.priv->name == name)
+		    return o.priv->value.f();
+
+    return defaultValue;
+}
+
+CompString CompOption::getStringOptionNamed (const Vector& options,
+					     const CompString& name,
+					     const CompString& defaultValue)
+{
+    foreach (const CompOption &o, options)
+		if (o.priv->type == CompOption::TypeString
+			&& o.priv->name == name)
+		    return o.priv->value.s();
 
     return defaultValue;
 }
 
 unsigned short *
-CompOption::getColorOptionNamed (const Vector&        options,
-				 const CompString&    name,
-				 unsigned short       *defaultValue)
-{
-    foreach (const CompOption &o, options)
-	if (o.priv->type == CompOption::TypeColor && o.priv->name == name)
-	    return o.priv->value.c ();
-
-    return defaultValue;
-}
-
-CompMatch
-CompOption::getMatchOptionNamed (const Vector&     options,
+CompOption::getColorOptionNamed (const Vector& options,
 				 const CompString& name,
-				 const CompMatch&  defaultValue)
-{
-    foreach (const CompOption &o, options)
-	if (o.priv->type == CompOption::TypeMatch && o.priv->name == name)
-	    return o.priv->value.match ();
-
-    return defaultValue;
-}
-
-bool
-CompOption::stringToColor (CompString     color,
-			   unsigned short *rgba)
+				 unsigned short *defaultValue)
+{
+    foreach (const CompOption &o, options)
+		if (o.priv->type == CompOption::TypeColor
+			&& o.priv->name == name)
+		    return o.priv->value.c();
+
+    return defaultValue;
+}
+
+CompMatch CompOption::getMatchOptionNamed (const Vector& options,
+					   const CompString& name,
+					   const CompMatch& defaultValue)
+{
+    foreach (const CompOption &o, options)
+		if (o.priv->type == CompOption::TypeMatch
+			&& o.priv->name == name)
+		    return o.priv->value.match();
+
+    return defaultValue;
+}
+
+bool CompOption::stringToColor (CompString color, unsigned short *rgba)
 {
     int c[4];
 
-    if (sscanf (color.c_str (), "#%2x%2x%2x%2x",
-		&c[0], &c[1], &c[2], &c[3]) == 4)
+    if (sscanf(color.c_str(), "#%2x%2x%2x%2x", &c[0], &c[1], &c[2], &c[3]) == 4)
     {
 	rgba[0] = c[0] << 8 | c[0];
 	rgba[1] = c[1] << 8 | c[1];
@@ -915,68 +493,59 @@
     return false;
 }
 
-CompString
-CompOption::colorToString (unsigned short *rgba)
+CompString CompOption::colorToString (unsigned short *rgba)
 {
-    return compPrintf ("#%.2x%.2x%.2x%.2x", rgba[0] / 256, rgba[1] / 256,
-					    rgba[2] / 256, rgba[3] / 256);
+    return compPrintf("#%.2x%.2x%.2x%.2x", rgba[0] / 256, rgba[1] / 256,
+	    rgba[2] / 256, rgba[3] / 256);
 }
 
-CompString
-CompOption::typeToString (CompOption::Type type)
+CompString CompOption::typeToString (CompOption::Type type)
 {
-    switch (type) {
-	case CompOption::TypeBool:
-	    return "bool";
-	case CompOption::TypeInt:
-	    return "int";
-	case CompOption::TypeFloat:
-	    return "float";
-	case CompOption::TypeString:
-	    return "string";
-	case CompOption::TypeColor:
-	    return "color";
-	case CompOption::TypeAction:
-	    return "action";
-	case CompOption::TypeKey:
-	    return "key";
-	case CompOption::TypeButton:
-	    return "button";
-	case CompOption::TypeEdge:
-	    return "edge";
-	case CompOption::TypeBell:
-	    return "bell";
-	case CompOption::TypeMatch:
-	    return "match";
-	case CompOption::TypeList:
-	    return "list";
-	default:
-	    break;
+    switch (type)
+    {
+    case CompOption::TypeBool:
+	return "bool";
+    case CompOption::TypeInt:
+	return "int";
+    case CompOption::TypeFloat:
+	return "float";
+    case CompOption::TypeString:
+	return "string";
+    case CompOption::TypeColor:
+	return "color";
+    case CompOption::TypeAction:
+	return "action";
+    case CompOption::TypeKey:
+	return "key";
+    case CompOption::TypeButton:
+	return "button";
+    case CompOption::TypeEdge:
+	return "edge";
+    case CompOption::TypeBell:
+	return "bell";
+    case CompOption::TypeMatch:
+	return "match";
+    case CompOption::TypeList:
+	return "list";
+    default:
+	break;
     }
 
     return "unknown";
 }
 
-bool
-CompOption::setOption (CompOption        &o,
-		       CompOption::Value &value)
+bool CompOption::setOption (CompOption &o, CompOption::Value &value)
 {
-    return o.set (value);
+    return o.set(value);
 }
 
 PrivateOption::PrivateOption () :
-    name (""),
-    type (CompOption::TypeUnset),
-    value (),
-    rest ()
+	name(""), type(CompOption::TypeUnset), value(), rest()
 {
 }
 
 PrivateOption::PrivateOption (const PrivateOption &p) :
-    name (p.name),
-    type (p.type),
-    value (p.value),
-    rest (p.rest)
+	name(p.name), type(p.type), value(p.value), rest(p.rest)
 {
 }