Merge pull request #203 from RicoAntonioFelix/master

Enhanced and refactored file constant.h

3 files changed, 119 insertions, 62 deletions

diff --git a/include/argument.h b/include/argument.h
index 747f7a8..f7fb782 100644
--- a/include/argument.h
+++ b/include/argument.h
@@ -1,5 +1,5 @@
 /**
- *  Argument.h
+ *  @file argument.h
  *
  *  Class holds information about an argument that is passed to a function.
  *  You'll need this class when you're defining your own functions.
@@ -25,7 +25,7 @@ public:
     /**
      *  Destructor
      */
-    virtual ~Argument() {}
+    virtual ~Argument() = default;
 
 protected:
     /**
diff --git a/include/classtype.h b/include/classtype.h
index 9b6cc9e..5128353 100644
--- a/include/classtype.h
+++ b/include/classtype.h
@@ -1,5 +1,5 @@
 /**
- *  ClassType.h
+ *  @file classtype.h
  *
  *  Internal class types enumeration.
  *
diff --git a/include/constant.h b/include/constant.h
index 0f2b354..1397994 100644
--- a/include/constant.h
+++ b/include/constant.h
@@ -1,12 +1,13 @@
 /**
- *  Constant.h
+ *  @file constant.h
  *
  *  If you want to define global PHP constants, or class constants you can
  *  use this constant class for it. Wrap the constant you'd like to create
- *  in a Php::Constant object and add it to the extension or the class:
+ *  in a Php::Constant object and add it to the extension or the class.
  *
- *  extension.add(Php::Constant("CONSTANT_NAME", "value"));
- *  myclass.add(Php::Constant("CLASS_CONSTANT", "value"));
+ *  Examples:
+ *      extension.add(Php::Constant("CONSTANT_NAME", "value"));
+ *      myclass.add(Php::Constant("CLASS_CONSTANT", "value"));
  *
  *  @author Emiel Bruijntjes <emiel.bruijntjes@copernica.com>
  *  @copyright 2015 Copernica BV
@@ -28,64 +29,120 @@ class ConstantImpl;
 class PHPCPP_EXPORT Constant
 {
 public:
-    /**
-     *  Constructor
-     *  @param  name            Constant name
-     *  @param  value           Constant value
-     *  @param  size            Size of the value (in case of a string)
-     */
-    Constant(const char *name, std::nullptr_t value = nullptr);
-    Constant(const char *name, bool value);
-    Constant(const char *name, int32_t value);
-    Constant(const char *name, int64_t value);
-    Constant(const char *name, double value);
-    Constant(const char *name, const char *value);
-    Constant(const char *name, const char *value, size_t size);
-    Constant(const char *name, const std::string &value);
-
-    /**
-     *  Destructor
-     */
-    virtual ~Constant() {}
-
-    /**
-     *  Add the constant to a class
-     *
-     *  You normally do not have to call this method yourself. You can simply
-     *  do one of the following method calls to create class constants:
-     *
-     *      myclass.property("MY_CONSTANT", "value", Php::Const);
-     *      myclass.constant("MY_CONSTANT", "value");
-     *      myclass.add(Php::Constant("MY_CONSTANT", "value"));
-     *
-     *  All of the calls have the same result, it is up to you to decide which
-     *  one suits you most. If you use the last one - using a Php::Constant
-     *  class - the PHP-CPP library will call this "addTo()" method internally
-     *  to forward the call to one of the other methods.
-     *
-     *  @param  clss        Class to which the constant is added
-     *  @internal
-     */
-    void addTo(ClassBase &clss) const;
+	/**
+	 *  Constructor to create a constant for a null value
+	 *
+	 *  @param  name  Constant's name
+	 *  @param  value Constant's value
+	 */
+	Constant(const char *name, std::nullptr_t value = nullptr);
+
+	/**
+	 * Constructor to create a constant for a boolean value
+	 *
+	 * @param name  Constant's name
+	 * @param value Constant's value
+	 */
+	Constant(const char *name, bool value);
+
+	/**
+	 * Constructor to create a constant for a 32-bit integer
+	 *
+	 * @param name  Constant's name
+	 * @param value Constant's value
+	 */
+	Constant(const char *name, int32_t value);
+
+	/**
+	 * Constructor to create a constant for a 64-bit integer
+	 *
+	 * @param name  Constant's name
+	 * @param value Constant's value
+	 */
+	Constant(const char *name, int64_t value);
+
+	/**
+	 * Constructor to create a constant for a double precision
+	 * floating point number
+	 *
+	 * @param name  Constant's name
+	 * @param value Constant's value
+	 */
+	Constant(const char *name, double value);
+
+	/**
+	 * Constructor to create a constant for a string literal
+	 *
+	 * @param name  Constant's name
+	 * @param value Constant's value
+	 */
+	Constant(const char *name, const char *value);
+
+	/**
+	 * Constructor to create a constant for a string literal
+	 * specifying the length of the string
+	 *
+	 * @param name  Constant's name
+	 * @param value Constant's value
+	 * @param size  Length of the string value
+	 */
+	Constant(const char *name, const char *value, size_t size);
+
+	/**
+	 * Constructor to create a constant for a string literal
+	 * using a std::string
+	 *
+	 * @param name  Constant's name
+	 * @param value Constant's value
+	 */
+	Constant(const char *name, const std::string &value);
+
+	/**
+	 *  Destructor
+	 */
+	virtual ~Constant() = default;
+
+	/**
+	 *  Add the constant to a class
+	 *
+	 *  You normally do not have to call this method yourself. You can simply
+	 *  do one of the following method calls to create class constants:
+	 *
+	 *      myclass.property("MY_CONSTANT", "value", Php::Const);
+	 *      myclass.constant("MY_CONSTANT", "value");
+	 *      myclass.add(Php::Constant("MY_CONSTANT", "value"));
+	 *
+	 *  All of the calls have the same result, it is up to you to decide which
+	 *  one suits you best. If you use the last one - using a Php::Constant
+	 *  class - the PHP-CPP library will call this "addTo()" method internally
+	 *  to forward the call to one of the other methods.
+	 *
+	 *  @param clss Class to which the constant is added
+	 *  @internal
+	 */
+	void addTo(ClassBase &clss) const;
 
 private:
-    /**
-     *  Pointer to the actual implementation of the constant
-     *  @var    std::shared_ptr
-     */
-    std::shared_ptr<ConstantImpl> _impl;
-
-    /**
-     *  Get access to the implementation object
-     *  @return std::shared_ptr
-     */
-    const std::shared_ptr<ConstantImpl> &implementation() const { return _impl; }
-
-    /**
-     *  The extension object has access to privates
-     */
-    friend class ExtensionImpl;
+	/**
+	 *  Pointer to the actual implementation of the constant
+	 *
+	 *  @var std::shared_ptr Pointer to the constant implementation containing
+	 *                       distributed ownership properties
+	 */
+	std::shared_ptr<ConstantImpl> _impl;
+
+	/**
+	 *  Get access to the implementation object
+	 *
+	 *  @return std::shared_ptr Pointer to the constant implementation
+	 */
+	const std::shared_ptr<ConstantImpl> &implementation() const
+	{ return _impl; }
 
+	/**
+	 *  The extension object has access to privates
+	 */
+	friend class ExtensionImpl;
 };
 
 /**