Add doxygen comments for simulator 93/26593/9
authorpooja <pooja.k@partner.samsung.com>
Wed, 25 Jul 2018 13:29:14 +0000 (18:59 +0530)
committerAshok Babu Channa <ashok.channa@samsung.com>
Tue, 25 Sep 2018 06:02:56 +0000 (06:02 +0000)
Change-Id: Icd198cf5bd0ddae84bd6fa29757e6302cded9227
Signed-off-by: pooja <pooja.k@partner.samsung.com>
37 files changed:
service/simulator/inc/simulator_client_types.h
service/simulator/inc/simulator_error_codes.h
service/simulator/inc/simulator_logger.h
service/simulator/inc/simulator_platform_info.h
service/simulator/inc/simulator_request_model.h
service/simulator/inc/simulator_resource_model.h
service/simulator/inc/simulator_resource_model_schema.h
service/simulator/java/jni/jni_listener_holder.h
service/simulator/java/jni/jni_map.h
service/simulator/java/jni/jni_queryparam.h
service/simulator/java/jni/jni_string.h
service/simulator/java/jni/simulator_exceptions_jni.h
service/simulator/java/jni/simulator_resource_utils_jni.h
service/simulator/java/jni/simulator_utils_jni.h
service/simulator/ramlparser/raml/RamlErrorCodes.h
service/simulator/ramlparser/raml/model/ActionType.h
service/simulator/src/client/get_request_generator.h
service/simulator/src/client/post_request_generator.h
service/simulator/src/client/put_request_generator.h
service/simulator/src/client/query_param_generator.h
service/simulator/src/client/request_automation_manager.h
service/simulator/src/client/request_generation.h
service/simulator/src/client/request_list.h
service/simulator/src/client/request_sender.h
service/simulator/src/client/simulator_remote_resource_impl.h
service/simulator/src/common/attribute_generator.h
service/simulator/src/common/attribute_value_generator.h
service/simulator/src/common/request_model.h
service/simulator/src/common/request_model_builder.h
service/simulator/src/common/resource_model_schema_builder.h
service/simulator/src/common/response_model.h
service/simulator/src/common/simulator_utils.h
service/simulator/src/server/oc_interface_details.h
service/simulator/src/server/resource_update_automation.h
service/simulator/src/server/resource_update_automation_mngr.h
service/simulator/src/server/simulator_collection_resource_impl.h
service/simulator/src/server/simulator_single_resource_impl.h

index 8da974e..276eaad 100644 (file)
 #include <memory>
 #include "simulator_error_codes.h"
 
+/** enum for observe type value */
 enum class ObserveType
 {
     OBSERVE,
     OBSERVE_ALL
 };
 
+/** enum value for request type value */
 enum class RequestType
 {
-    RQ_TYPE_UNKNOWN,
-    RQ_TYPE_GET,
-    RQ_TYPE_PUT,
-    RQ_TYPE_POST,
-    RQ_TYPE_DELETE
+    RQ_TYPE_UNKNOWN,       /**< unknown type request */
+    RQ_TYPE_GET,           /**< get type request */
+    RQ_TYPE_PUT,           /**< put type request */
+    RQ_TYPE_POST,          /**< post type request */
+    RQ_TYPE_DELETE         /**< delete type request */
 };
 
+/** structure for validation status */
 typedef struct
 {
-    bool isVerified;
-    SimulatorResult errorCode;
+    bool isVerified;            /**< verified state value */
+    SimulatorResult errorCode;  /**< simulator result */
 } ValidationStatus;
 
+/** enum for operation state value */
 typedef enum
 {
-    OP_START,
-    OP_COMPLETE,
-    OP_ABORT
+    OP_START,         /**< start operation */
+    OP_COMPLETE,      /**< complete operation */
+    OP_ABORT          /**< abort the operation */
 } OperationState;
 
+/** enum for connectivity type value */
 typedef enum
 {
     /** use when defaults are ok. */
index 254af62..b162076 100644 (file)
 typedef enum
 {
     /** STACK error codes - START */
-    SIMULATOR_OK = 0,
-    SIMULATOR_RESOURCE_CREATED,
-    SIMULATOR_RESOURCE_DELETED,
-    SIMULATOR_CONTINUE,
-    SIMULATOR_RESOURCE_CHANGED,
-    SIMULATOR_INVALID_URI = 20,
-    SIMULATOR_INVALID_QUERY,
-    SIMULATOR_INVALID_IP,
-    SIMULATOR_INVALID_PORT,
-    SIMULATOR_INVALID_CALLBACK,
-    SIMULATOR_INVALID_METHOD,
-    SIMULATOR_INVALID_PARAM,
-    SIMULATOR_INVALID_OBSERVE_PARAM,
-    SIMULATOR_NO_MEMORY,
-    SIMULATOR_COMM_ERROR,
-    SIMULATOR_TIMEOUT,
-    SIMULATOR_ADAPTER_NOT_ENABLED,
-    SIMULATOR_NOTIMPL,
-    SIMULATOR_NO_RESOURCE,
-    SIMULATOR_RESOURCE_ERROR,
-    SIMULATOR_SLOW_RESOURCE,
-    SIMULATOR_DUPLICATE_REQUEST,
-    SIMULATOR_NO_OBSERVERS,
-    SIMULATOR_OBSERVER_NOT_FOUND,
-    SIMULATOR_VIRTUAL_DO_NOT_HANDLE,
-    SIMULATOR_INVALID_OPTION,
-    SIMULATOR_MALFORMED_RESPONSE,
-    SIMULATOR_PERSISTENT_BUFFER_REQUIRED,
-    SIMULATOR_INVALID_REQUEST_HANDLE,
-    SIMULATOR_INVALID_DEVICE_INFO,
-    SIMULATOR_INVALID_JSON,
-    SIMULATOR_UNAUTHORIZED_REQ,
-    SIMULATOR_TOO_LARGE_REQ,
-    SIMULATOR_PDM_IS_NOT_INITIALIZED,
-    SIMULATOR_DUPLICATE_UUID,
-    SIMULATOR_INCONSISTENT_DB,
-    SIMULATOR_AUTHENTICATION_FAILURE,
+    SIMULATOR_OK = 0,                      /**< Success */
+    SIMULATOR_RESOURCE_CREATED,            /**< Resource created */
+    SIMULATOR_RESOURCE_DELETED,            /**< Resource deleted */
+    SIMULATOR_CONTINUE,                    /**< Continue */
+    SIMULATOR_RESOURCE_CHANGED,            /**< Resource changed */
+    SIMULATOR_INVALID_URI = 20,            /**< Invalid URI */
+    SIMULATOR_INVALID_QUERY,               /**< Invalid query */
+    SIMULATOR_INVALID_IP,                  /**< Invalid IP */
+    SIMULATOR_INVALID_PORT,                /**< Invalid port */
+    SIMULATOR_INVALID_CALLBACK,            /**< Invalid callback */
+    SIMULATOR_INVALID_METHOD,              /**< Invalid method */
+    SIMULATOR_INVALID_PARAM,               /**< Invalid parameter */
+    SIMULATOR_INVALID_OBSERVE_PARAM,       /**< Invalid observe parameter */
+    SIMULATOR_NO_MEMORY,                   /**< No memory */
+    SIMULATOR_COMM_ERROR,                  /**< Comm error */
+    SIMULATOR_TIMEOUT,                     /**< Timeout */
+    SIMULATOR_ADAPTER_NOT_ENABLED,         /**< Adapter not enabled */
+    SIMULATOR_NOTIMPL,                     /**< Not impl */
+    SIMULATOR_NO_RESOURCE,                 /**< No resource */
+    SIMULATOR_RESOURCE_ERROR,              /**< Resource error */
+    SIMULATOR_SLOW_RESOURCE,               /**< Slow resource */
+    SIMULATOR_DUPLICATE_REQUEST,           /**< Duplicate request */
+    SIMULATOR_NO_OBSERVERS,                /**< No observers */
+    SIMULATOR_OBSERVER_NOT_FOUND,          /**< Observer not found */
+    SIMULATOR_VIRTUAL_DO_NOT_HANDLE,       /**< Virtual do not handle */
+    SIMULATOR_INVALID_OPTION,              /**< Invalid option */
+    SIMULATOR_MALFORMED_RESPONSE,          /**< Malformed response */
+    SIMULATOR_PERSISTENT_BUFFER_REQUIRED,  /**< Persistent buffer required */
+    SIMULATOR_INVALID_REQUEST_HANDLE,      /**< Invalid request handle */
+    SIMULATOR_INVALID_DEVICE_INFO,         /**< Invalid device information */
+    SIMULATOR_INVALID_JSON,                /**< Invalid json */
+    SIMULATOR_UNAUTHORIZED_REQ,            /**< Unauthorized request */
+    SIMULATOR_TOO_LARGE_REQ,               /**< Large request */
+    SIMULATOR_PDM_IS_NOT_INITIALIZED,      /**< PDM is not initialized */
+    SIMULATOR_DUPLICATE_UUID,              /**< Duplicate UUID */
+    SIMULATOR_INCONSISTENT_DB,             /**< Inconsistent DB */
+    SIMULATOR_AUTHENTICATION_FAILURE,      /**< Authentication failure */
 #ifdef WITH_PRESENCE
-    SIMULATOR_PRESENCE_STOPPED = 128,
-    SIMULATOR_PRESENCE_TIMEOUT,
-    SIMULATOR_PRESENCE_DO_NOT_HANDLE,
+    SIMULATOR_PRESENCE_STOPPED = 128,      /**< Presence stopped */
+    SIMULATOR_PRESENCE_TIMEOUT,            /**< Presence timeout */
+    SIMULATOR_PRESENCE_DO_NOT_HANDLE,      /**< Presence do not handle */
 #endif
     /** STACK error codes - END */
 
     /** Simulator specific error codes - START */
-    SIMULATOR_INVALID_TYPE,
-    SIMULATOR_NOT_SUPPORTED,
-    SIMULATOR_OPERATION_NOT_ALLOWED,
-    SIMULATOR_OPERATION_IN_PROGRESS,
+    SIMULATOR_INVALID_TYPE,                /**< Invalid type */
+    SIMULATOR_NOT_SUPPORTED,               /**< Not supported */
+    SIMULATOR_OPERATION_NOT_ALLOWED,       /**< Operation not allowed */
+    SIMULATOR_OPERATION_IN_PROGRESS,       /**< Operation in progress */
 
-    SIMULATOR_INVALID_RESPONSE_CODE,
-    SIMULATOR_UKNOWN_PROPERTY,
-    SIMULATOR_TYPE_MISMATCH,
-    SIMULATOR_BAD_VALUE,
-    SIMULATOR_BAD_OBJECT,
-    SIMULATOR_BAD_SCHEMA,
+    SIMULATOR_INVALID_RESPONSE_CODE,       /**< Invalid response code */
+    SIMULATOR_UKNOWN_PROPERTY,             /**< Unknown property */
+    SIMULATOR_TYPE_MISMATCH,               /**< Type mismatch */
+    SIMULATOR_BAD_VALUE,                   /**< Bad value */
+    SIMULATOR_BAD_OBJECT,                  /**< Bad object */
+    SIMULATOR_BAD_SCHEMA,                  /**< Bad schema */
     /** Simulator specific error codes - END */
 
-    SIMULATOR_ERROR = 255
+    SIMULATOR_ERROR = 255                  /**< Error */
 } SimulatorResult;
-#endif //SIMULATOR_ERROR_CODES_H_
\ No newline at end of file
+#endif //SIMULATOR_ERROR_CODES_H_
index 8a0c028..aa87055 100644 (file)
 #include <iostream>
 #include <memory>
 
+/**
+ * @class ILogger
+ */
 class ILogger
 {
     public:
         enum Level
         {
-            INFO = 0,
-            DEBUG,
-            WARNING,
-            ERROR
+            INFO = 0,    /**< information level log message */
+            DEBUG,       /**< debug level log message */
+            WARNING,     /**< warning level log message */
+            ERROR        /**< error level log message */
         };
 
+        /**
+         * get the string value according to the level value
+         * @param[in] level    log level value
+         *
+         * @return string message
+         */
         static const char *getString(Level level)
         {
             switch (level)
@@ -56,12 +65,33 @@ class ILogger
         virtual void write(std::string, Level, std::string) = 0;
 };
 
+/**
+ * @class Logger
+ */
 class Logger
 {
     public:
+        /**
+         * set the log target to console
+         * @return true or false
+         */
         bool setDefaultConsoleTarget();
+        /**
+         * set the log target to file
+         * @param[in] path    file path
+         * @return true or false
+         */
         bool setDefaultFileTarget(const std::string &path);
+        /**
+         * set the log to custom target
+         * @param[in] target    log target
+         */
         void setCustomTarget(const std::shared_ptr<ILogger> &target);
+        /**
+         * write the log to given target
+         * @param[in] level   type of log
+         * @param[in] str     oc string stream
+         */
         void write(ILogger::Level level, std::ostringstream &str);
 
     private:
@@ -76,4 +106,4 @@ auto simLogger() -> Logger &;
     }
 #endif
 
-#endif
\ No newline at end of file
+#endif
index fb12caf..e1d7c93 100644 (file)
@@ -107,16 +107,81 @@ class PlatformInfo
          */
         std::string getSystemTime() const;
 
+        /**
+         * This method is for set the platform ID
+         *
+         * @param platformId    platform identity
+         */
         void setPlatformID(const std::string &platformId);
+
+        /**
+         * This method is for set the platform version
+         *
+         * @param platformVersion    platform version information
+         */
         void setPlatformVersion(const std::string &platformVersion);
+
+        /**
+         * This method is for set the manufacturer name
+         *
+         * @param manufacturerName       detail of manufacturer name
+         */
         void setManufacturerName(const std::string &manufacturerName);
+
+        /**
+         * This method is for set the manufacturer URL details
+         *
+         * @param manufacturerUrl    manufacturer URL detail to set
+         */
         void setManufacturerUrl(const std::string &manufacturerUrl);
+
+        /**
+         * This method is for set model number
+         *
+         * @param modelNumber    model number information
+         */
         void setModelNumber(const std::string &modelNumber);
+
+        /**
+         * This method is for set date of manufacture
+         *
+         * @param dateOfManufacture    date of manufacture to set
+         */
         void setDateOfManfacture(const std::string &dateOfManufacture);
+
+        /**
+         * This method is for set the OS version
+         *
+         * @param osVersion    OS version information to set
+         */
         void setOSVersion(const std::string &osVersion);
+
+        /**
+         * This method is for set the hardware version
+         *
+         * @param hwVersion    hardware version information to set
+         */
         void setHardwareVersion(const std::string &hwVersion);
+
+        /**
+         * This method is for set the firmware version information
+         *
+         * @param firmwareVersion         firmware version to set
+         */
         void setFirmwareVersion(const std::string &firmwareVersion);
+
+        /**
+         * This method is for set the support URL detail
+         *
+         * @param supportUrl    support URL to set
+         */
         void setSupportUrl(const std::string &supportUrl);
+
+        /**
+         * This method is for set the system time information
+         *
+         * @param systemTime       system time to set
+         */
         void setSystemTime(const std::string &systemTime);
 
     private:
index eb3b2a6..ba52ece 100644 (file)
 #include "simulator_client_types.h"
 #include "simulator_resource_model_schema.h"
 
+/**
+ * @class SimulatorRequestModel
+ */
 class SimulatorRequestModel
 {
     public:
         SimulatorRequestModel();
         SimulatorRequestModel(RequestType type);
 
+        /**
+         * Get the request type of topic
+         * @return request type
+         */
         RequestType getType() const;
+        /**
+         * Get the query parameters
+         * @return parameters
+         */
         std::map<std::string, std::vector<std::string>> getQueryParams() const;
+        /**
+         * Get the request body schema
+         * @return schema information
+         */
         std::shared_ptr<SimulatorResourceModelSchema> getRequestBodySchema() const;
 
+        /**
+         * Set the query parameters
+         * @param[in] queryParams   parameter to set
+         */
         void setQueryParams(const std::map<std::string, std::vector<std::string>> &queryParams);
+        /**
+         * Set the request body schema
+         * @param[in] repSchema   schema to set
+         */
         void setRequestBodySchema(const std::shared_ptr<SimulatorResourceModelSchema> &repSchema);
 
     private:
index a83028f..ffdffbe 100644 (file)
@@ -62,13 +62,13 @@ std::vector<std::vector<std::vector<SimulatorResourceModel>>>
 
 enum class AttributeValueType
 {
-    UNKNOWN,
-    INTEGER,
-    DOUBLE,
-    BOOLEAN,
-    STRING,
-    RESOURCE_MODEL,
-    VECTOR
+    UNKNOWN,         /**< unknown value type */
+    INTEGER,         /**< integer value type */
+    DOUBLE,          /**< double value type */
+    BOOLEAN,         /**< boolean value type */
+    STRING,          /**< string value type */
+    RESOURCE_MODEL,  /**< resource model type */
+    VECTOR           /**< vector type */
 };
 
 class OCRepresentationBuilder;
@@ -101,6 +101,12 @@ class SimulatorResourceModel
                 int m_depth;
         };
 
+        /**
+         * add the value
+         * @param[in] name   find the name
+         * @param[in] value  add the attribute value for the given name
+         * @return boolean value
+         */
         template <typename T>
         bool add(const std::string &name, T value)
         {
@@ -113,6 +119,11 @@ class SimulatorResourceModel
             return false;
         }
 
+        /**
+         * get the value
+         * @param[in] name get the value for given name
+         * @return value
+         */
         template <typename T>
         T get(const std::string &name) const
         {
@@ -132,6 +143,12 @@ class SimulatorResourceModel
             return val;
         }
 
+        /**
+         * update the value
+         * @param[in] name   name to find
+         * @param[in] value  update the value
+         * @return boolean value
+         */
         template <typename T>
         bool update(const std::string &name, T value)
         {
@@ -139,16 +156,35 @@ class SimulatorResourceModel
             return updateValue(name, newValue);
         }
 
+        /**
+         * remove the value
+         * @param[in] name    name to remove
+         * @return boolean value
+         */
         bool remove(const std::string &name);
 
         bool contains(const std::string &name) const;
 
         size_t size() const;
 
+        /**
+         * get the type
+         * @param[in] name   get the type of given name
+         * @return type of name
+         */
         TypeInfo getType(const std::string &name) const;
 
+        /**
+         * get attribute values
+         * @return attribute value
+         */
         std::map<std::string, AttributeValueVariant> getAttributeValues() const;
 
+        /**
+         * get attribute values using name value
+         * @param name   attribute name
+         * @return attribute value
+         */
         AttributeValueVariant getAttributeValue(const std::string &name) const;
 
         std::set<std::string> getAttributeNameSet() const;
@@ -166,6 +202,9 @@ class SimulatorResourceModel
         std::map<std::string, AttributeValueVariant> m_attributes;
 };
 
+/**
+ * @class SimulatorResourceAttribute
+ */
 class SimulatorResourceAttribute
 {
     public:
@@ -173,14 +212,42 @@ class SimulatorResourceAttribute
         SimulatorResourceAttribute(const std::string &name);
         SimulatorResourceAttribute(const std::string &name, const AttributeValueVariant &value);
 
+        /**
+         * get the resource name
+         * @return resource name
+         */
         std::string getName() const;
+        /**
+         * get the type
+         * @return resource type
+         */
         const SimulatorResourceModel::TypeInfo getType() const;
+        /**
+         * get the attribute property
+         * @return attribute property
+         */
         std::shared_ptr<AttributeProperty> getProperty() const;
+        /**
+         * get the attribute value
+         * @return attribute value
+         */
         AttributeValueVariant getValue() const;
 
+        /**
+         * set the atribute name
+         * @param[in] name   set the name
+         */
         void setName(const std::string &name);
+        /**
+         * set the attribute property
+         * @param[in] property   property to set
+         */
         void setProperty(const std::shared_ptr<AttributeProperty> &property);
 
+        /**
+         * set attribute value
+         * @param[in] value   value to set
+         */
         template <typename T>
         void setValue(const T &value)
         {
index 13e0da8..4586224 100644 (file)
@@ -37,102 +37,214 @@ class AttributeProperty
     public:
         enum class Type
         {
-            INTEGER,
-            DOUBLE,
-            BOOLEAN,
-            STRING,
-            MODEL,
-            ARRAY
+            INTEGER,   /**< Integer type */
+            DOUBLE,    /**< Double type */
+            BOOLEAN,   /**< Boolean type */
+            STRING,    /**< String type */
+            MODEL,     /**< Model type */
+            ARRAY      /**< Array type */
         };
 
         explicit AttributeProperty(Type type);
         virtual ~AttributeProperty() {}
 
+        /**
+         * get the attribute type
+         * @return attribute type
+         */
         Type getType() const;
+        /**
+         * Check the integer value
+         * @return boolean value
+         */
         virtual bool isInteger() const
         {
             return false;
         }
-
+        /**
+         * Check the double value
+         * @return boolean value
+         */
         virtual bool isDouble() const
         {
             return false;
         }
-
+        /**
+         * Check the boolean value
+         * @return boolean value
+         */
         virtual bool isBoolean() const
         {
             return false;
         }
-
+        /**
+         * Check the string value
+         * @return boolean value
+         */
         virtual bool isString() const
         {
             return false;
         }
-
+        /**
+         * Check array
+         * @return boolean value
+         */
         virtual bool isArray() const
         {
             return false;
         }
-
+        /**
+         * Check model
+         * @return boolean value
+         */
         virtual bool isModel() const
         {
             return false;
         }
 
+        /**
+         * Integer property
+         * @return integer property object
+         */
         virtual std::shared_ptr<IntegerProperty> asInteger()
         {
             return nullptr;
         }
 
+        /**
+         * double property
+         * @return double property object
+         */
         virtual std::shared_ptr<DoubleProperty> asDouble()
         {
             return nullptr;
         }
 
+        /**
+         * boolean property
+         * @return boolean property object
+         */
         virtual std::shared_ptr<BooleanProperty> asBoolean()
         {
             return nullptr;
         }
 
+        /**
+         * string property
+         * @return string property object
+         */
         virtual std::shared_ptr<StringProperty> asString()
         {
             return nullptr;
         }
 
+        /**
+         * array property
+         * @return array property object
+         */
         virtual std::shared_ptr<ArrayProperty> asArray()
         {
             return nullptr;
         }
 
+        /**
+         * model property
+         * @return model property object
+         */
         virtual std::shared_ptr<ModelProperty> asModel()
         {
             return nullptr;
         }
 
+        /**
+         * validate the attribute value
+         * @param[in] value    value to validate
+         * @return boolean value
+         */
         virtual bool validate(const AttributeValueVariant &value) = 0;
+        /**
+         * This method is to get the attribute default value
+         * @return class object
+         */
         virtual AttributeValueVariant buildValue() = 0;
 
     private:
         Type m_type;
 };
 
+/**
+ * IntegerProperty class
+ */
 class IntegerProperty : public AttributeProperty,
     public std::enable_shared_from_this<IntegerProperty>
 {
     public:
         static std::shared_ptr<IntegerProperty> build(int defaultValue = 0);
 
+        /**
+         * check value is integer or not
+         * @return boolean value
+         */
         bool isInteger() const;
         std::shared_ptr<IntegerProperty> asInteger();
+        /**
+         * set the given default vlaue
+         * @param value  value to set
+         */
         void setDefaultValue(int value);
+
+        /**
+         * set the range
+         * @param min   minimum range value
+         * @param max   maximum range value
+         */
         void setRange(int min, int max);
+
+        /**
+         * set the property values
+         * @param values   value to set
+         */
         void setValues(const std::vector<int> &values);
+
+        /**
+         * check range and return the true or false value
+         * @return boolean value
+         */
         bool hasRange() const;
+        /**
+         * check value and return the true or false value
+         * @return boolean value
+         */
         bool hasValues() const;
+        /**
+         * get the default property value
+         * @return default value
+         */
         int getDefaultValue() const;
+        /**
+         * get the minimum and maximum range value
+         * @param[out] min   minimum range
+         * @param[out] max   maximum range
+         * @return boolean value
+         */
         bool getRange(int &min, int &max) const;
+        /**
+         * get the property values
+         * @param[out] values  property value
+         * @return boolean value
+         */
         bool getValues(std::vector<int> &values) const;
+        /**
+         * validate the attribute value
+         * @param[in] value   attribute value
+         * @return boolean value
+         */
         bool validate(const AttributeValueVariant &value);
+        /**
+         * validate the value
+         * @param[in] value   attribute value
+         * @return boolean value
+         */
         bool validate(const int &value);
         AttributeValueVariant buildValue();
 
@@ -146,23 +258,79 @@ class IntegerProperty : public AttributeProperty,
         bool m_hasRange;
 };
 
+/*
+ * DoubleProperty class
+ */
 class DoubleProperty : public AttributeProperty,
     public std::enable_shared_from_this<DoubleProperty>
 {
     public:
         static std::shared_ptr<DoubleProperty> build(double defaultValue = 0.0);
 
+        /**
+         * check value is double or not
+         * @return boolean value
+         */
         bool isDouble() const;
         std::shared_ptr<DoubleProperty> asDouble();
+
+        /**
+         * set the given default vlaue
+         * @param value  value to set
+         */
         void setDefaultValue(double value);
+
+        /**
+         * set the range
+         * @param min   minimum range value
+         * @param max   maximum range value
+         */
         void setRange(double min, double max);
+
+        /**
+         * set the property values
+         * @param values   value to set
+         */
         void setValues(const std::vector<double> &values);
+        /**
+         * check range and return the true or false value
+         * @return boolean value
+         */
         bool hasRange() const;
+        /**
+         * check value and return the true or false value
+         * @return boolean value
+         */
         bool hasValues() const;
+        /**
+         * get the default property value
+         * @return default vlaue
+         */
         double getDefaultValue() const;
+        /**
+         * get the minimum and maximum range value
+         * @param[out] min   minimum range
+         * @param[out] max   maximum range
+         * @return boolean value
+         */
         bool getRange(double &min, double &max) const;
+        /**
+         * get the property values
+         * @param[out] values  property value
+         * @return boolean value
+         */
         bool getValues(std::vector<double> &values) const;
+        /**
+         * validate the attribute value
+         * @param[in] value   attribute value
+         * @return boolean value
+         */
         bool validate(const AttributeValueVariant &value);
+        /**
+         * validate the value
+         * @param[in] value   attribute value
+         * @return boolean value
+         */
         bool validate(const double &value);
         AttributeValueVariant buildValue();
 
@@ -176,16 +344,36 @@ class DoubleProperty : public AttributeProperty,
         bool m_hasRange;
 };
 
+/**
+ * BooleanProperty class
+ */
 class BooleanProperty : public AttributeProperty,
     public std::enable_shared_from_this<BooleanProperty>
 {
     public:
         static std::shared_ptr<BooleanProperty> build(bool defaultValue = true);
 
+        /**
+         * check value is boolean or not
+         * @return boolean value
+         */
         bool isBoolean() const;
         std::shared_ptr<BooleanProperty> asBoolean();
+        /**
+         * set default value
+         * @param value    attribute default value
+         */
         void setDefaultValue(bool value);
+        /**
+         * get default value
+         * @return boolean value
+         */
         bool getDefaultValue() const;
+        /**
+         * validate attribute value
+         * @param[in] value   attribute value
+         * @return boolean value
+         */
         bool validate(const AttributeValueVariant &value);
         AttributeValueVariant buildValue();
 
@@ -195,23 +383,75 @@ class BooleanProperty : public AttributeProperty,
         bool m_defaultValue;
 };
 
+/**
+ * StringProperty class
+ */
 class StringProperty : public AttributeProperty,
     public std::enable_shared_from_this<StringProperty>
 {
     public:
         static std::shared_ptr<StringProperty> build(const std::string &defaultValue = "");
 
+        /**
+         * check the string value
+         * @return boolean value
+         */
         bool isString() const;
         std::shared_ptr<StringProperty> asString();
+
+        /**
+         * set the given default vlaue
+         * @param value  value to set
+         */
         void setDefaultValue(const std::string &value);
+
+        /**
+         * set the range
+         * @param min   minimum range value
+         * @param max   maximum range value
+         */
         void setRange(size_t min, size_t max);
+
+        /**
+         * set the property values
+         * @param values   value to set
+         */
         void setValues(const std::vector<std::string> &values);
+        /**
+         * check range and return the true or false value
+         * @return boolean value
+         */
         bool hasRange() const;
+        /**
+         * check value and return the true or false value
+         * @return boolean value
+         */
         bool hasValues() const;
         std::string getDefaultValue() const;
+        /**
+         * get the minimum and maximum range value
+         * @param min    minimum range value
+         * @param max    maximum range value
+         * @return boolean value
+         */
         bool getRange(size_t &min, size_t &max) const;
+        /**
+         * get the property values
+         * @param[in] values   attribute value
+         * @return boolean value
+         */
         bool getValues(std::vector<std::string> &values) const;
+        /**
+         * validate attribute value
+         * @param[in] values   attribute value
+         * @return boolean value
+         */
         bool validate(const AttributeValueVariant &value);
+        /**
+         * validate value
+         * @param[in] values   attribute value
+         * @return boolean value
+         */
         bool validate(const std::string &value);
         AttributeValueVariant buildValue();
 
@@ -225,24 +465,79 @@ class StringProperty : public AttributeProperty,
         bool m_hasRange;
 };
 
+/**
+ * ArrayProperty class
+ */
 class ArrayProperty : public AttributeProperty,
     public std::enable_shared_from_this<ArrayProperty>
 {
     public:
         static std::shared_ptr<ArrayProperty> build();
 
+        /**
+         * check array
+         * @return boolean value
+         */
         bool isArray() const;
         std::shared_ptr<ArrayProperty> asArray();
+
+        /**
+         * set the range
+         * @param minItems   minimum range value
+         * @param maxItems   maximum range value
+         */
         void setRange(size_t minItems, size_t maxItems);
+        /**
+         * set variable state
+         * @param[in] state  value to set
+         */
         void setVariable(bool state);
+        /**
+         * set the state value
+         * @param[in] state  value to set
+         */
         void setUnique(bool state);
+        /**
+         * set element property
+         * @param[in] property    attribute property
+         * @return boolean value
+         */
         bool setElementProperty(const std::shared_ptr<AttributeProperty> &property);
+        /**
+         * check range and return the true or false value
+         * @return boolean value
+         */
         bool hasRange() const;
+        /**
+         * check the variable value
+         * @return boolean value
+         */
         bool isVariable() const;
+        /**
+         * check the unique value
+         * @return boolean value
+         */
         bool isUnique() const;
+        /**
+         * get the minimum items value
+         * @return minimum item value
+         */
         size_t getMinItems() const;
+        /**
+         * get the maximum items value
+         * @return miximum item value
+         */
         size_t getMaxItems() const;
+        /**
+         * get the element property
+         * @return element property
+         */
         std::shared_ptr<AttributeProperty> getElementProperty();
+        /**
+         * validate attribute value
+         * @param[in] value   attribute value
+         * @return boolean value
+         */
         bool validate(const AttributeValueVariant &value);
         AttributeValueVariant buildValue();
 
@@ -258,24 +553,58 @@ class ArrayProperty : public AttributeProperty,
         bool m_hasRange;
 };
 
+/**
+ * ModelProperty class
+ */
 class ModelProperty : public AttributeProperty,
     public std::enable_shared_from_this<ModelProperty>
 {
     public:
         static std::shared_ptr<ModelProperty> build();
 
+        /**
+         * check model
+         * @return boolean value
+         */
         bool isModel() const;
         std::shared_ptr<ModelProperty> asModel();
         bool add(const std::string &name, const std::shared_ptr<AttributeProperty> &property,
                  bool required = false);
         std::shared_ptr<AttributeProperty> get(const std::string &name);
         std::unordered_map<std::string, std::shared_ptr<AttributeProperty>> getChildProperties();
+        /**
+         * check name value and return true or false value
+         * @param[in] name    string value
+         * @return boolean value
+         */
         bool isRequired(const std::string &name);
+        /**
+         * remove the given name
+         * @param[in] name   string value
+         */
         void remove(const std::string &name);
+        /**
+         * set the given value
+         * @param[in] name    set the value
+         */
         void setRequired(const std::string &name);
+        /**
+         * unset the given value
+         * @param[in] name   unset the value
+         */
         void unsetRequired(const std::string &name);
         SimulatorResourceModel buildResourceModel();
+        /**
+         * validate attribute value
+         * @param[in] value   attribute value
+         * @return boolean value
+         */
         bool validate(const AttributeValueVariant &value);
+        /**
+         * validate the model value
+         * @param[in] model  model to validate
+         * @return boolean value
+         */
         bool validate(const SimulatorResourceModel &model);
         AttributeValueVariant buildValue();
 
index 6f9e8dc..5347734 100644 (file)
 #ifndef JNI_LISTENER_HOLDER_H_
 #define JNI_LISTENER_HOLDER_H_
 
+/**
+ * @class JniListenerHolder
+ */
 class JniListenerHolder
 {
     public:
+         /** constructor */
         ~JniListenerHolder()
         {
             JNIEnv *env = GetEnv();
@@ -35,11 +39,13 @@ class JniListenerHolder
             ReleaseEnv();
         }
 
+        /** This method is to get the listener object */
         jobject get()
         {
             return m_listener;
         }
 
+        /** This method is to create the new listener */
         static std::shared_ptr<JniListenerHolder> create(JNIEnv *env, jobject &listener)
         {
             return std::shared_ptr<JniListenerHolder>(new JniListenerHolder(env, listener));
index a94db78..1e76591 100644 (file)
 
 #include <jni.h>
 
+/**
+ * @class JniMap
+ */
 class JniMap
 {
     public:
+        /** constructor */
         JniMap(JNIEnv *env);
+        /** This method to add the key and value */
         void put(jobject jKey, jobject jValue);
+        /** This method is to get the java object */
         jobject get();
 
     private:
index dcdc44b..c3cf729 100644 (file)
@@ -25,6 +25,9 @@
 #include <map>
 #include <string>
 
+/**
+ * @class JniQueryParameter
+ */
 class JniQueryParameter
 {
     public:
index ba14d43..761cced 100644 (file)
 #include <jni.h>
 #include <string>
 
+/**
+ * @class JniString
+ */
 class JniString
 {
     public:
+        /** constructor */
         JniString(JNIEnv *env, jstring &string);
         ~JniString();
+        /** This method is to get the string information */
         std::string get();
 
     private:
index 4add306..3e7e950 100644 (file)
  ******************************************************************/
 
 /**
- * @file   simulator_jni_util.h
- *
- * @brief  This file contains the utility functions for conversions from java to CPP
- * and viceversa
+ * @file   simulator_exceptions_jni.h
  */
 
 #ifndef SIMULATOR_EXCEPTIONS_JNI_H_
 
 #include "simulator_error_codes.h"
 
+/**
+ * throw the simulator exception
+ * @param env          JNI interface pointer
+ * @param code         simulator result value
+ */
 void ThrowSimulatorException(JNIEnv *env, SimulatorResult code, const char *message);
 
+/**
+ * throw the invalid argument exception
+ * @param env          JNI interface pointer
+ * @param code         simulator result value
+ */
 void ThrowInvalidArgsException(JNIEnv *env, SimulatorResult code, const char *message);
 
+/**
+ * throw the not supported exception
+ * @param env          JNI interface pointer
+ * @param code         simulator result value
+ */
 void ThrowNoSupportException(JNIEnv *env, const char *message);
 
+/**
+ * throw the operation in progress exception
+ * @param env          JNI interface pointer
+ * @param code         simulator result value
+ */
 void ThrowOperationInProgressException(JNIEnv *env, const char *message);
 
+/**
+ * throw the bad object exception
+ * @param env          JNI interface pointer
+ * @param code         simulator result value
+ */
 void ThrowBadObjectException(JNIEnv *env, const char *message);
 
 #endif
index 49a2e8d..7b81d24 100644 (file)
 #include "simulator_collection_resource.h"
 #include "simulator_remote_resource.h"
 
+/**
+ * API to create the single resource
+ *
+ * @return resource object
+ */
 jobject CreateSingleResource(JNIEnv *env, SimulatorResourceSP singleResource);
+
+/**
+ * API to create collection resource
+ *
+ * @return resource object
+ */
 jobject CreateCollectionResource(JNIEnv *env, SimulatorResourceSP collectionResource);
+
+/**
+ * API to create simulator resource
+ *
+ * @return resource object
+ */
 jobject CreateSimulatorResource(JNIEnv *env, SimulatorResourceSP resource);
+
+/**
+ * API to create simulator resource vector
+ *
+ * @return vector object
+ */
 jobject CreateSimulatorResourceVector(JNIEnv *env, std::vector<SimulatorResourceSP> &resources);
+
+/**
+ * API to create simulator remote resource
+ *
+ * @return resource object
+ */
 jobject CreateSimulatorRemoteResource(JNIEnv *env, SimulatorRemoteResourceSP &remoteResource);
 
 #endif
index 85aa4a4..7f60a0c 100644 (file)
 
 typedef struct
 {
-    jclass objectCls;
-    jclass integerCls;
-    jclass doubleCls;
-    jclass booleanCls;
-    jclass stringCls;
-    jclass hashMapCls;
-    jclass vectorCls;
-    jclass mapCls;
-    jclass mapEntryCls;
-    jclass setCls;
-    jclass iteratorCls;
+    jclass objectCls;   /**< Object class object */
+    jclass integerCls;  /**< Integer class object */
+    jclass doubleCls;   /**< Double class object */
+    jclass booleanCls;  /**< Boolean class object */
+    jclass stringCls;   /**< String class object */
+    jclass hashMapCls;  /**< hash map class object */
+    jclass vectorCls;   /**< Vector class object */
+    jclass mapCls;      /**< Map class object */
+    jclass mapEntryCls; /**< Map entry class object */
+    jclass setCls;      /**< Set class object */
+    jclass iteratorCls; /**< Iterator class object */
 
-    jclass simulatorResourceCls;
-    jclass simulatorResourceTypeCls;
-    jclass simulatorSingleResourceCls;
-    jclass simulatorCollectionResourceCls;
-    jclass simulatorResourceModelCls;
-    jclass simulatorResourceAttributeCls;
-    jclass attributeValueCls;
-    jclass attributeValueTypeCls;
-    jclass attributeTypeInfoCls;
-    jclass attributePropertyCls;
-    jclass attributePropertyTypeCls;
-    jclass integerPropertyCls;
-    jclass integerPropertyBuilderCls;
-    jclass doublePropertyCls;
-    jclass doublePropertyBuilderCls;
-    jclass booleanPropertyCls;
-    jclass booleanPropertyBuilderCls;
-    jclass stringPropertyCls;
-    jclass stringPropertyBuilderCls;
-    jclass arrayPropertyCls;
-    jclass arrayPropertyBuilderCls;
-    jclass modelPropertyCls;
-    jclass autoUpdateTypeCls;
+    jclass simulatorResourceCls;           /**< Simulator resource class object */
+    jclass simulatorResourceTypeCls;       /**< Simulator resource type class object */
+    jclass simulatorSingleResourceCls;     /**< Simulator single resource class object */
+    jclass simulatorCollectionResourceCls; /**< Simulator collection resource class object */
+    jclass simulatorResourceModelCls;      /**< Simulator resource model class object */
+    jclass simulatorResourceAttributeCls;  /**< Simulator resource attribute class object */
+    jclass attributeValueCls;              /**< Attribute value class object */
+    jclass attributeValueTypeCls;          /**< Attribute value type class object */
+    jclass attributeTypeInfoCls;           /**< Attribute type information class object */
+    jclass attributePropertyCls;           /**< Attribute property class object */
+    jclass attributePropertyTypeCls;       /**< Attribute property type class object */
+    jclass integerPropertyCls;             /**< Integer property class object */
+    jclass integerPropertyBuilderCls;      /**< Integer property builder class object */
+    jclass doublePropertyCls;              /**< Double property class object */
+    jclass doublePropertyBuilderCls;       /**< Double property builder class object */
+    jclass booleanPropertyCls;             /**< Boolean property class object */
+    jclass booleanPropertyBuilderCls;      /**< Boolean property builder class object */
+    jclass stringPropertyCls;              /**< String property class object */
+    jclass stringPropertyBuilderCls;       /**< String property builder class object */
+    jclass arrayPropertyCls;               /**< Array property class object */
+    jclass arrayPropertyBuilderCls;        /**< Array property builder class object */
+    jclass modelPropertyCls;               /**< Model property class object */
+    jclass autoUpdateTypeCls;              /**< Auto update type class object */
 
-    jclass simulatorRemoteResourceCls;
-    jclass requestTypeCls;
-    jclass observerCls;
-    jclass deviceInfoCls;
-    jclass platformInfoCls;
-    jclass simulatorRequestModelCls;
+    jclass simulatorRemoteResourceCls;   /**< Simulator remote resource class object */
+    jclass requestTypeCls;               /**< Request type class object */
+    jclass observerCls;                  /**< Observer class object */
+    jclass deviceInfoCls;                /**< Device information class object */
+    jclass platformInfoCls;              /**< Platform information class object */
+    jclass simulatorRequestModelCls;     /**< Simulator request model class object */
 
-    jclass simulatorExceptionCls;
-    jclass invalidArgsExceptionCls;
-    jclass noSupportExceptionCls;
-    jclass operationInProgressExceptionCls;
-    jclass simulatorResultCls;
+    jclass simulatorExceptionCls;           /**< Simulator exception class object */
+    jclass invalidArgsExceptionCls;         /**< Invalid args exception class object */
+    jclass noSupportExceptionCls;           /**< No support exception class object */
+    jclass operationInProgressExceptionCls; /**< Operation in progress exception class object */
+    jclass simulatorResultCls;              /**< Simulator result class object */
 
-    jclass integer1DArrayCls;
-    jclass integer2DArrayCls;
-    jclass integer3DArrayCls;
-    jclass double1DArrayCls;
-    jclass double2DArrayCls;
-    jclass double3DArrayCls;
-    jclass boolean1DArrayCls;
-    jclass boolean2DArrayCls;
-    jclass boolean3DArrayCls;
-    jclass string1DArrayCls;
-    jclass string2DArrayCls;
-    jclass string3DArrayCls;
-    jclass simulatorResModel1DArrayCls;
-    jclass simulatorResModel2DArrayCls;
-    jclass simulatorResModel3DArrayCls;
+    jclass integer1DArrayCls;           /**< Integer 1d array class object */
+    jclass integer2DArrayCls;           /**< Integer 2d array class object */
+    jclass integer3DArrayCls;           /**< Integer 3d array class object */
+    jclass double1DArrayCls;            /**< Double 1d array class object */
+    jclass double2DArrayCls;            /**< Double 2d array class object */
+    jclass double3DArrayCls;            /**< Double 3d array class object */
+    jclass boolean1DArrayCls;           /**< Boolean 1d array class object */
+    jclass boolean2DArrayCls;           /**< Boolean 2d array class object */
+    jclass boolean3DArrayCls;           /**< Boolean 3d array class object */
+    jclass string1DArrayCls;            /**< String 1d array class object */
+    jclass string2DArrayCls;            /**< String 2d array class object */
+    jclass string3DArrayCls;            /**< String 3d array class object */
+    jclass simulatorResModel1DArrayCls; /**< Simulator resource model 1d array class object */
+    jclass simulatorResModel2DArrayCls; /**< Simulator resource model 2d array class object */
+    jclass simulatorResModel3DArrayCls; /**< Simulator resource model 3d array class object */
 } SimulatorClassRefs;
 
+/** Validate value */
 #define VALIDATE_INPUT(ENV, CONDITION, MSG) if (CONDITION) {ThrowInvalidArgsException(ENV, SIMULATOR_INVALID_PARAM, MSG); return;}
+/** Validate value and return */
 #define VALIDATE_INPUT_RET(ENV, CONDITION, MSG, RET) if (CONDITION) {ThrowInvalidArgsException(ENV, SIMULATOR_INVALID_PARAM, MSG); return RET;}
 
+/** Validate callback */
 #define VALIDATE_CALLBACK(ENV, CALLBACK) if (!CALLBACK){ThrowInvalidArgsException(env, SIMULATOR_INVALID_CALLBACK, "Invalid callback!"); return;}
+/** Validate callback and return */
 #define VALIDATE_CALLBACK_RET(ENV, CALLBACK, RET) if (!CALLBACK){ThrowInvalidArgsException(env, SIMULATOR_INVALID_CALLBACK, "Invalid callback!"); return RET;}
 
+/** get handle field */
 static jfieldID getHandleField(JNIEnv *env, jobject jobj)
 {
     jclass cls = env->GetObjectClass(jobj);
     return env->GetFieldID(cls, "mNativeHandle", "J");
 }
 
+/** get handle */
 template <typename T>
 static T *getHandle(JNIEnv *env, jobject jobj)
 {
@@ -111,6 +117,7 @@ static T *getHandle(JNIEnv *env, jobject jobj)
     return reinterpret_cast<T *>(handle);
 }
 
+/** set handle */
 template <typename T>
 static void setHandle(JNIEnv *env, jobject jobj, T *type)
 {
@@ -118,8 +125,8 @@ static void setHandle(JNIEnv *env, jobject jobj, T *type)
     env->SetLongField(jobj, getHandleField(env, jobj), handle);
 }
 
-extern JNIEnv *GetEnv();
-extern void ReleaseEnv();
+extern JNIEnv *GetEnv();    /**< get the environment information */
+extern void ReleaseEnv();   /**< release the environment information */
 extern SimulatorClassRefs gSimulatorClassRefs;
 
 jobject SimulatorResultToJava(JNIEnv *env, SimulatorResult errorCode);
index 5e8eb34..f04c1af 100644 (file)
@@ -30,8 +30,8 @@
 /** RamlParserResult - This enum provides list of error codes from RamlParser*/\r
 typedef enum\r
 {\r
-    RAML_PARSER_OK = 0,\r
-    RAML_FILE_PATH_REQUIRED,\r
-    RAML_PARSER_ERROR = 255\r
+    RAML_PARSER_OK = 0,                /**< RAML parser success */\r
+    RAML_FILE_PATH_REQUIRED,           /**< RAML file path is required */\r
+    RAML_PARSER_ERROR = 255            /**< RAML parser error */\r
 } RamlParserResult;\r
 #endif\r
index b529a54..22d89ad 100644 (file)
@@ -27,6 +27,9 @@
 #ifndef ACTION_TYPE_H\r
 #define ACTION_TYPE_H\r
 \r
+/**\r
+ * RAML namespace\r
+ */\r
 namespace RAML\r
 {\r
     /** ActionType - This class provides data Model for RAML ActionType. */\r
index bd64036..3aeee9e 100644 (file)
 #include "query_param_generator.h"
 #include "request_sender.h"
 
+/**
+ * @class RequestModel
+ */
 class RequestModel;
 class GETRequestGenerator : public RequestGeneration
 {
     public:
+        /**
+         * get request generator
+         * @param[in] id             identity
+         * @param[in] ocResource     oc resource
+         * @param[in] requestSchema  request schema
+         * @param[in] callback       callback function
+         */
         GETRequestGenerator(int id, const std::shared_ptr<OC::OCResource> &ocResource,
                             const std::shared_ptr<RequestModel> &requestSchema,
                             ProgressStateCallback callback);
 
+        /** start sending requests */
         void startSending();
+        /** stop sending requests */
         void stopSending();
 
     private:
index 92a23b2..473790e 100644 (file)
 #include "attribute_generator.h"
 #include "request_sender.h"
 
+/**
+ * @class RequestModel
+ */
 class RequestModel;
 class POSTRequestGenerator : public RequestGeneration
 {
     public:
+        /**
+         * constructor
+         * @param[in] id            identity
+         * @param[in] ocResource    oc resource
+         * @param[in] requestSchema request schema
+         * @param[in] callback      callback function
+         */
         POSTRequestGenerator(int id, const std::shared_ptr<OC::OCResource> &ocResource,
                              const std::shared_ptr<RequestModel> &requestSchema,
                              ProgressStateCallback callback);
 
+        /** start sending requests */
         void startSending();
+        /** stop sending requests */
         void stopSending();
 
     private:
+        /** send all requests */
         void SendAllRequests();
         void onResponseReceived(SimulatorResult result,
                                 const SimulatorResourceModel &repModel, const RequestInfo &reqInfo);
+        /** completed event */
         void completed();
 
         bool m_stopRequested;
index b6e49d9..41ccd43 100644 (file)
 #include "attribute_generator.h"
 #include "request_sender.h"
 
+/**
+ * @class RequestModel
+ */
 class RequestModel;
 class PUTRequestGenerator : public RequestGeneration
 {
     public:
+        /**
+         * constructor
+         * @param[in] id            identity
+         * @param[in] ocResource    oc resource
+         * @param[in] requestModel  request model
+         * @param[in] callback      callback function
+         */
         PUTRequestGenerator(int id, const std::shared_ptr<OC::OCResource> &ocResource,
                             const std::shared_ptr<RequestModel> &requestModel,
                             ProgressStateCallback callback);
 
+        /** start sending request */
         void startSending();
+        /** stop sending request */
         void stopSending();
 
     private:
+        /** send all requests */
         void SendAllRequests();
         void onResponseReceived(SimulatorResult result,
                                 const SimulatorResourceModel &repModel, const RequestInfo &reqInfo);
+        /** completed event */
         void completed();
 
         bool m_stopRequested;
index 6040ffd..7646f53 100644 (file)
 #include <map>
 #include <vector>
 
+/**
+ * @class QPGenerator
+ */
 class QPGenerator
 {
     public:
+        /** query parameter detail structure */
         typedef struct
         {
-            std::string key;
-            std::vector<std::string> values;
-            std::size_t index;
+            std::string key;                 /**< identity of detail */
+            std::vector<std::string> values; /**< parameter value */
+            std::size_t index;               /**< index of detail */
         } QPDetail;
 
         QPGenerator() = default;
+        /**
+         * This method is for query parameter generator
+         * @param[in] queryParams    query parameter
+         */
         QPGenerator(const std::map<std::string, std::vector<std::string>> &queryParams);
+        /** check the next parameter from list */
         bool hasNext();
         std::map<std::string, std::string> next();
 
index 8a6a5c5..ea8d18b 100644 (file)
 
 #include "request_generation.h"
 
+/**
+ * OC namespace
+ */
 namespace OC
 {
     class OCResource;
 }
 
+/**
+ * @class RequestModel
+ */
 class RequestModel;
+/**
+ * @class RequestAutomationMngr
+ */
 class RequestAutomationMngr
 {
     public:
+        /**
+         * API to request automation manager
+         * @param[in] ocResource     oc resource
+         */
         RequestAutomationMngr(const std::shared_ptr<OC::OCResource> &ocResource);
 
+        /**
+         * API to start the get request
+         * @param[in] requestSchema   request schema
+         * @param[in] callback        callback function
+         */
         int startOnGET(const std::shared_ptr<RequestModel> &requestSchema,
                        RequestGeneration::ProgressStateCallback callback);
 
+        /**
+         * API to start the put request
+         * @param[in] requestSchema   request schema
+         * @param[in] callback        callback function
+         */
         int startOnPUT(const std::shared_ptr<RequestModel> &requestSchema,
                        RequestGeneration::ProgressStateCallback callback);
 
+        /**
+         * API to start the post request
+         * @param[in] requestSchema   request schema
+         * @param[in] callback        callback function
+         */
         int startOnPOST(const std::shared_ptr<RequestModel> &requestSchema,
                         RequestGeneration::ProgressStateCallback callback);
 
+        /**
+         * API to stop the request for the given id
+         * @param[in] id    request identity
+         */
         void stop(int id);
 
     private:
index 7c098bd..5a888b0 100644 (file)
 
 #include "simulator_client_types.h"
 
+/**
+ * @class RequestGeneration
+ */
 class RequestGeneration
 {
     public:
         typedef std::function<void (int, OperationState)> ProgressStateCallback;
 
+        /**
+         * This method is to start the generation of the given type request
+         * @param[in] type     request type
+         * @param[in] id       request id
+         * @param[in] callback callback function
+         */
         RequestGeneration(RequestType type, int id,
                           ProgressStateCallback callback);
+        /**
+         * get the type of request
+         * @return request type
+         */
         RequestType type() const
         {
             return m_type;
         }
+        /**
+         * get the request id
+         * @return request id
+         */
         int id() const
         {
             return m_id;
         }
+        /** This method is to start the request */
         void start();
+        /** This method is to stop the request */
         void stop();
 
     protected:
index 4992633..2813da4 100644 (file)
 #include <map>
 #include <mutex>
 
+/**
+ * @class RequestList
+ */
 template <typename T>
 class RequestList
 {
     public:
         RequestList() : m_id(0) {}
 
+        /**
+         * add the request to the list
+         * @param request  request to add in list
+         * @return identity value
+         */
         int add(T request)
         {
             if (!request)
@@ -40,6 +48,11 @@ class RequestList
             return m_id - 1;
         }
 
+        /**
+         * get the request for the given id
+         * @param id  get the information using id
+         * @return request object
+         */
         T get(int id)
         {
             std::lock_guard<std::recursive_mutex> lock(m_listMutex);
@@ -49,6 +62,11 @@ class RequestList
             return nullptr;
         }
 
+        /**
+         * remove the request for the given id
+         * @param id   remove the request for given id
+         * @return request object
+         */
         T remove(int id)
         {
             std::lock_guard<std::recursive_mutex> lock(m_listMutex);
@@ -62,12 +80,19 @@ class RequestList
             return nullptr;
         }
 
+        /**
+         * get the size of request list
+         * @return the size of list
+         */
         int size()
         {
             std::lock_guard<std::recursive_mutex> lock(m_listMutex);
             return m_requestList.size();
         }
 
+        /**
+         * clear the list
+         */
         void clear()
         {
             std::lock_guard<std::recursive_mutex> lock(m_listMutex);
index 542423d..bb40dc1 100644 (file)
 
 struct RequestInfo
 {
-    RequestType type;
-    std::map<std::string, std::string> queryParams;
-    SimulatorResourceModel payLoad;
+    RequestType type;   /**< type of request */
+    std::map<std::string, std::string> queryParams; /**< query parameters */
+    SimulatorResourceModel payLoad;                 /**< resource payload */
 };
 
+/**
+ * @class GETRequestSender
+ */
 class GETRequestSender
 {
     public:
         typedef std::function<void (SimulatorResult result, const SimulatorResourceModel &resModel,
                                     const RequestInfo &reqInfo)> ResponseCallback;
 
+        /**
+         * send the get request
+         * @param[in] ocResource   oc resource
+         */
         GETRequestSender(const std::shared_ptr<OC::OCResource> &ocResource);
 
         SimulatorResult send(const ResponseCallback &callback);
@@ -45,6 +52,14 @@ class GETRequestSender
         SimulatorResult send(const std::map<std::string, std::string> &queryParams,
                              const ResponseCallback &callback);
 
+        /**
+         * response of get request
+         * @param[in] headerOptions    header options
+         * @param[in] rep              oc representation
+         * @param[in] errorCode        error code
+         * @param[in] requestInfo      request information
+         * @param[in] callback         callback function
+         */
         void onResponseReceived(const OC::HeaderOptions &headerOptions,
                                 const OC::OCRepresentation &rep, const int errorCode, RequestInfo &requestInfo,
                                 ResponseCallback callback);
@@ -53,12 +68,19 @@ class GETRequestSender
         std::shared_ptr<OC::OCResource> m_ocResource;
 };
 
+/**
+ * @class PUTRequestSender
+ */
 class PUTRequestSender
 {
     public:
         typedef std::function<void (SimulatorResult result, const SimulatorResourceModel &resModel,
                                     const RequestInfo &reqInfo)> ResponseCallback;
 
+        /**
+         * send the put request
+         * @param[in] ocResource  oc resource
+         */
         PUTRequestSender(const std::shared_ptr<OC::OCResource> &ocResource);
 
         SimulatorResult send(const SimulatorResourceModel &representation,
@@ -68,6 +90,14 @@ class PUTRequestSender
                              const SimulatorResourceModel &representation,
                              const ResponseCallback &callback);
 
+        /**
+         * response of put request
+         * @param[in] headerOptions    header options
+         * @param[in] rep              oc representation
+         * @param[in] errorCode        error code
+         * @param[in] requestInfo      request information
+         * @param[in] callback         callback function
+         */
         void onResponseReceived(const OC::HeaderOptions &headerOptions,
                                 const OC::OCRepresentation &rep, const int errorCode, RequestInfo &requestInfo,
                                 ResponseCallback callback);
@@ -76,12 +106,19 @@ class PUTRequestSender
         std::shared_ptr<OC::OCResource> m_ocResource;
 };
 
+/**
+ * @class POSTRequestSender
+ */
 class POSTRequestSender
 {
     public:
         typedef std::function<void (SimulatorResult result, const SimulatorResourceModel &resModel,
                                     const RequestInfo &reqInfo)> ResponseCallback;
 
+        /**
+         * send the post request
+         * @param[in] ocResource  oc resource
+         */
         POSTRequestSender(const std::shared_ptr<OC::OCResource> &ocResource);
 
         SimulatorResult send(const SimulatorResourceModel &representation,
@@ -91,6 +128,14 @@ class POSTRequestSender
                              const SimulatorResourceModel &representation,
                              const ResponseCallback &callback);
 
+        /**
+         * response of post request
+         * @param[in] headerOptions    header options
+         * @param[in] rep              oc representation
+         * @param[in] errorCode        error code
+         * @param[in] requestInfo      request information
+         * @param[in] callback         callback function
+         */
         void onResponseReceived(const OC::HeaderOptions &headerOptions,
                                 const OC::OCRepresentation &rep, const int errorCode, RequestInfo &requestInfo,
                                 ResponseCallback callback);
index 4169c01..72438d8 100644 (file)
 
 #include <mutex>
 
+/**
+ * SimulatorRemoteResourceImpl
+ */
 class SimulatorRemoteResourceImpl : public SimulatorRemoteResource
 {
     public:
+        /**
+         * Implement the simulator remote resource
+         * @param[in] ocResource   oc resource
+         */
         SimulatorRemoteResourceImpl(const std::shared_ptr<OC::OCResource> &ocResource);
+        /**
+         * API to get the resource URI
+         * @return resource URI
+         */
         std::string getURI() const;
+        /**
+         * API to get the host information
+         * @return host information
+         */
         std::string getHost() const;
+        /**
+         * API to get the resource ID
+         * @return resource ID
+         */
         std::string getID() const;
+        /**
+         * API to get the connectivity type
+         * @return connectivity type
+         */
         SimulatorConnectivityType getConnectivityType() const;
+        /**
+         * API to get the resource types
+         * @return resource types
+         */
         std::vector < std::string > getResourceTypes() const;
+        /**
+         * API to get the interface information
+         * @return interface information
+         */
         std::vector < std::string > getInterface() const;
+        /**
+         * API to get the observable state of resource
+         * @return boolean value
+         */
         bool isObservable() const;
 
+        /**
+         * This method is to observe the resources
+         * @param[in] callback  notification callback function
+         */
         void observe(ObserveType type, ObserveNotificationCallback callback);
+        /**
+         * This method is to observe the resources
+         * @param[in] type         observe type
+         * @param[in] queryParams  query parameter
+         * @param[in] callback  notification callback function
+         */
         void observe(ObserveType type, const std::map<std::string, std::string> &queryParams,
                      ObserveNotificationCallback callback);
+        /** This method is to stop the observing of resource */
         void cancelObserve();
 
         void get(const GetResponseCallback &callback);
@@ -80,9 +126,23 @@ class SimulatorRemoteResourceImpl : public SimulatorRemoteResource
                   const SimulatorResourceModel &representation,
                   const PostResponseCallback &callback);
 
+        /**
+         * This method is to configure the path
+         * @param[in] path   config path
+         * @return class object
+         */
         std::map<RequestType, SimulatorRequestModel> configure(
             const std::string &path);
+        /**
+         * This method is to start the request
+         * @param[in] type      request type
+         * @param[in] callback  request id
+         */
         int startAutoRequesting(RequestType type, AutoRequestGenerationCallback callback);
+        /**
+         * This method is to stop the request for the given id
+         * @param[in] id   id to request
+         */
         void stopAutoRequesting(int id);
 
     private:
index 3c45cff..99ca029 100644 (file)
 #include "simulator_resource_model.h"
 #include "attribute_value_generator.h"
 
+/**
+ * @class AttributeGenerator
+ */
 class AttributeGenerator
 {
     public:
+        /**
+         * This method is to generate the attribute
+         * @param[in] attribute  resource attribute
+         */
         AttributeGenerator(const SimulatorResourceAttribute &attribute);
+        /**
+         * This method is to generate the attribute
+         * @param[in] name       attribute name
+         * @param[in] property   attribute property
+         */
         AttributeGenerator(const std::string &name,
                            const std::shared_ptr<AttributeProperty> &property);
 
+        /**
+         * Check the attribute next value
+         * and return the value otherwise return the false
+         * @return boolean value
+         */
         bool hasNext();
+        /**
+         * This method is to generate the next attribute
+         * and set that name and property value.
+         * @param[in] attribute  resource attribute
+         * @return true or false
+         */
         bool next(SimulatorResourceAttribute &attribute);
+        /**
+         * This method is to get the current attribute value
+         * @return attribute object
+         */
         SimulatorResourceAttribute current();
+        /** This method is to reset the attribute value */
         void reset();
 
     private:
@@ -42,9 +70,16 @@ class AttributeGenerator
         std::unique_ptr<AttributeValueGen> m_valueGen;
 };
 
+/**
+ * @class AttributeCombinationGen
+ */
 class AttributeCombinationGen
 {
     public:
+        /**
+         * This method is to create the attribute with the different property value
+         * @param[in] attributes    resource attributes
+         */
         AttributeCombinationGen(const std::vector<SimulatorResourceAttribute> &attributes);
         bool next(SimulatorResourceModel &resModel);
 
index e55af62..22339db 100644 (file)
 
 #include "simulator_resource_model_schema.h"
 
+/**
+ * @class AttributeValueGen
+ */
 class AttributeValueGen
 {
     public:
+        /**
+         * check the next value
+         * @return boolean value
+         */
         virtual bool hasNext() = 0;
+        /**
+         * This method is to get the next index value
+         * @return attribute value variant object
+         */
         virtual AttributeValueVariant next() = 0;
+        /**
+         * This method is to get the index value
+         * @return attribute value variant object
+         */
         virtual AttributeValueVariant value() = 0;
+        /** This method is to reset the value */
         virtual void reset() = 0;
 };
 
+/**
+ * @class RangeValueGen
+ */
 template <typename TYPE>
 class RangeValueGen : public AttributeValueGen
 {
@@ -41,6 +60,11 @@ class RangeValueGen : public AttributeValueGen
         TYPE m_cur;
 
     public:
+        /**
+         * This method is to generate the range values
+         * @param[in] min    minimum range value
+         * @param[in] max    maximum range value
+         */
         RangeValueGen(TYPE min, TYPE max) : m_min(min), m_max(max), m_cur(min) {}
 
         bool hasNext()
@@ -48,6 +72,10 @@ class RangeValueGen : public AttributeValueGen
             return (m_cur <= m_max);
         }
 
+        /**
+         * This method is get the next index value
+         * @return index value
+         */
         AttributeValueVariant next()
         {
             TYPE value = m_cur;
@@ -55,17 +83,25 @@ class RangeValueGen : public AttributeValueGen
             return value;
         }
 
+        /**
+         * This method is get the previous index value
+         * @return index value
+         */
         AttributeValueVariant value()
         {
             return m_cur - 1;
         }
 
+        /** This method is to reset the value with minimum range value */
         void reset()
         {
             m_cur = m_min;
         }
 };
 
+/**
+ * @class ValuesSetGen
+ */
 template <typename TYPE>
 class ValuesSetGen : public AttributeValueGen
 {
@@ -74,6 +110,10 @@ class ValuesSetGen : public AttributeValueGen
         size_t m_index;
 
     public:
+        /**
+         * This method is to set the value for the given place
+         * @param[in] values   attribute value
+         */
         ValuesSetGen(const std::vector<TYPE> &values) : m_values(values), m_index(0) {}
 
         bool hasNext()
@@ -81,25 +121,42 @@ class ValuesSetGen : public AttributeValueGen
             return (m_index < m_values.size());
         }
 
+        /**
+         * This method is get the next index value
+         * @return index value
+         */
         AttributeValueVariant next()
         {
             return m_values[m_index++];
         }
 
+        /**
+         * This method is get the previous index value
+         * @return index value
+         */
         AttributeValueVariant value()
         {
             return m_values[m_index - 1];
         }
 
+        /** This method is to reset the value */
         void reset()
         {
             m_index = 0;
         }
 };
 
+/**
+ * @class AttributeValueGenFactory
+ */
 class AttributeValueGenFactory
 {
     public:
+        /**
+         * generate the attribute value
+         * @param[in] property  attribute property
+         * @return attribute value object
+         */
         static std::unique_ptr<AttributeValueGen> create(
             const std::shared_ptr<AttributeProperty> &property);
 };
index c2223b9..785296d 100644 (file)
 
 typedef std::map<std::string, std::vector<std::string>> SupportedQueryParams;
 
+/**
+ * @class RequestModelBuilder
+ */
 class RequestModelBuilder;
 class RequestModel
 {
     public:
         friend class RequestModelBuilder;
-
+        /**
+         * This method is to get the request type
+         * @return request type
+         */
         std::string getType() const;
+        /**
+         * This method is get the query parameters
+         * @return query parameters object
+         */
         SupportedQueryParams getQueryParams();
+        /**
+         * This method is to get the query param with the given key value
+         * @return query parameters object
+         */
         std::vector<std::string> getQueryParams(const std::string &key);
+        /**
+         * This method is to get the request representation schema
+         * @return request representation schema object
+         */
         std::shared_ptr<SimulatorResourceModelSchema> getRequestRepSchema();
+        /**
+         * This method is to get the response model with the code value
+         * @param[in] code   code value
+         */
         ResponseModelSP getResponseModel(int code);
+        /** This method is to validate the response */
         SimulatorResult validateResponse(int code, const SimulatorResourceModel &resModel);
 
     private:
index 0bfbf1f..7b054c3 100644 (file)
@@ -24,6 +24,7 @@
 #include "request_model.h"
 #include "response_model.h"
 
+/** Raml namespace */
 namespace RAML
 {
     class Raml;
@@ -33,11 +34,27 @@ namespace RAML
     class RequestResponseBody;
 }
 
+/**
+ * @class RequestModelBuilder
+ * This class is to construct Request and Response Model from RAML
+ * get, put, post, delete are the all request and response actions
+ */
 class RequestModelBuilder
 {
     public:
+        /**
+         * build the request model for the given URI information
+         * @param[in] raml     RAML object
+         * @param[in] uri      resource URI
+         * @return class object
+         */
         std::unordered_map<std::string, RequestModelSP> build(
             const std::shared_ptr<RAML::Raml> &raml, const std::string &uri);
+        /**
+         * build the request model for the given resource information
+         * @param[in] resource   RAML resource
+         * @return class object
+         */
         std::unordered_map<std::string, RequestModelSP> build(
             const std::shared_ptr<RAML::RamlResource> &resource);
 
index fee7751..ed3b476 100644 (file)
@@ -23,6 +23,7 @@
 
 #include "simulator_resource_model_schema.h"
 
+/** RAML namespace */
 namespace RAML
 {
     class RequestResponseBody;
@@ -31,9 +32,16 @@ namespace RAML
     enum class VariantType;
 }
 
+/**
+ * @class ResourceModelSchemaBuilder
+ */
 class ResourceModelSchemaBuilder
 {
     public:
+        /**
+         * resource model schema builder
+         * @param[in] ramlSchema   RAML schema
+         */
         ResourceModelSchemaBuilder(const std::shared_ptr<RAML::RequestResponseBody> &ramlSchema);
         std::shared_ptr<SimulatorResourceModelSchema> build();
 
index 6a78748..8d0936c 100644 (file)
 #include "simulator_resource_model_schema.h"
 #include "simulator_error_codes.h"
 
+/**
+ * @class RequestModelBuilder
+ */
 class RequestModelBuilder;
+/**
+ * @class ResponseModel
+ */
 class ResponseModel
 {
     public:
         friend class RequestModelBuilder;
 
+        /**
+         * get schema information
+         * @return schema
+         */
         std::shared_ptr<SimulatorResourceModelSchema> getSchema();
+        /**
+         * verify the response
+         * @param[in] resModel  resource model
+         * @return simulator result
+         */
         SimulatorResult verifyResponse(const SimulatorResourceModel &resModel);
 
     private:
index 1a4bc1c..8639106 100644 (file)
@@ -56,18 +56,39 @@ invokeocplatform(FnT fn, ArgsT &&...args)
     }
 }
 
+/** OC namespace */
 namespace OC
 {
     class OCRepresentation;
 }
 
-std::string getPayloadString(const OC::OCRepresentation &);
+/**
+ * This methosd is to get the payload string
+ * @param[in] rep    oc representation
+ * @return payload value
+ */
+std::string getPayloadString(const OC::OCRepresentation &rep);
+/**
+ * This method is to get the type of payload string
+ * @param[in] type   payload type
+ * @return payload type value
+ */
 std::string getPayloadTypeString(OCPayloadType type);
+/**
+ * This method is to get the request string
+ * @param[in] queryParams   query parameters
+ * @param[in] rep           oc representation
+ * @return request value
+ */
 std::string getRequestString(const std::map<std::string, std::string> &queryParams,
                              const OC::OCRepresentation &rep);
+/**
+ * This method is to get the request string
+ * @param[in] queryParams   query parameters
+ * @return request value
+ */
 std::string getRequestString(const std::map<std::string, std::string> &queryParams);
 
-
 #define VALIDATE_INPUT(CONDITION, MSG) if (CONDITION) {throw InvalidArgsException(SIMULATOR_INVALID_PARAM, MSG);}
 #define VALIDATE_CALLBACK(CALLBACK) if (!CALLBACK){throw InvalidArgsException(SIMULATOR_INVALID_CALLBACK, "Invalid callback!");}
 
index 02d764b..90885cc 100644 (file)
@@ -33,6 +33,7 @@
 
 #include "OCApi.h"
 
+/** OC namespace */
 namespace OC
 {
     // Read-Only interface
@@ -48,11 +49,29 @@ namespace OC
     const std::string SENSOR_INTERFACE = "oic.if.s";
 }
 
+/**
+ * @class OCInterfaceDetails
+ */
 class OCInterfaceDetails
 {
     public:
+        /**
+         * get the instance detail
+         * @return class object
+         */
         static OCInterfaceDetails *getInstance();
+        /**
+         * check the interface with given type
+         * @param[in] interfaceType   type of interface
+         * @return boolean value
+         */
         bool isInterface(const std::string &interfaceType);
+        /**
+         * check request is supported or not
+         * @param[in] interfaceType   type of interface
+         * @param[in] requestType     type of request
+         * @return boolean value
+         */
         bool isRequestSupported(const std::string &interfaceType, const std::string &requestType);
 
     private:
index 11839af..87c07f1 100644 (file)
 #include "attribute_generator.h"
 #include "simulator_single_resource.h"
 
+/**
+ * @class SimulatorSingleResourceImpl
+ */
 class SimulatorSingleResourceImpl;
+
+/**
+ * @class AttributeUpdateAutomation
+ */
 class AttributeUpdateAutomation
 {
     public:
+        /**
+         * update attribute automation
+         * @param[in] id                attribute identity
+         * @param[in] resource          simulator resource
+         * @param[in] name              attribute name
+         * @param[in] type              attribute type
+         * @param[in] interval          interval
+         * @param[in] callback          callback function
+         * @param[in] finishedCallback  callback function
+         */
         AttributeUpdateAutomation(int id, std::shared_ptr<SimulatorSingleResourceImpl> resource,
                                   const std::string &name, AutoUpdateType type, int interval,
                                   const SimulatorSingleResource::AutoUpdateCompleteCallback &callback,
                                   std::function<void (const int)> finishedCallback);
 
         ~AttributeUpdateAutomation();
+        /** start attribute update*/
         void start();
+        /** stop attribute update*/
         void stop();
 
     private:
@@ -60,16 +79,30 @@ class AttributeUpdateAutomation
 
 typedef std::shared_ptr<AttributeUpdateAutomation> AttributeUpdateAutomationSP;
 
+/**
+ * @class ResourceUpdateAutomation
+ */
 class ResourceUpdateAutomation
 {
     public:
+        /**
+         * update resource automation
+         * @param[in] id                resource identity
+         * @param[in] resource          simulator resource
+         * @param[in] type              resource type
+         * @param[in] interval          interval
+         * @param[in] callback          callback function
+         * @param[in] finishedCallback  callback function
+         */
         ResourceUpdateAutomation(int id, std::shared_ptr<SimulatorSingleResourceImpl> resource,
                                  AutoUpdateType type, int interval,
                                  const SimulatorSingleResource::AutoUpdateCompleteCallback &callback,
                                  std::function<void (const int)> finishedCallback);
 
         ~ResourceUpdateAutomation();
+        /** start resource automation update */
         void start();
+        /** stop resource automation update*/
         void stop();
 
     private:
index dcf2419..4930b77 100644 (file)
 #include "resource_update_automation.h"
 #include <unordered_map>
 
+/**
+ * @class SimulatorSingleResourceImpl
+ */
 class SimulatorSingleResourceImpl;
+/**
+ * @class UpdateAutomationMngr
+ */
 class UpdateAutomationMngr
 {
     public:
         UpdateAutomationMngr() : m_id(0) {}
 
+        /**
+         * start resource automation
+         * @param[in] resource    automation resource
+         * @param[in] type        resource type
+         * @param[in] interval    interval
+         * @param[in] callback    callback function
+         * @return resource automation id value
+         */
         int startResourceAutomation(std::shared_ptr<SimulatorSingleResourceImpl> resource,
                                     AutoUpdateType type, int interval,
                                     const SimulatorSingleResource::AutoUpdateCompleteCallback &callback);
 
+        /**
+         * start attribute automation
+         * @param[in] resource     simulator resource
+         * @param[in] attrName     attribute name
+         * @param[in] type         attribute type
+         * @param[in] interval     interval
+         * @param[in] callback     callback function
+         * @return resource automation id value
+         */
         int startAttributeAutomation(std::shared_ptr<SimulatorSingleResourceImpl> resource,
                                      const std::string &attrName, AutoUpdateType type, int interval,
                                      const SimulatorSingleResource::AutoUpdateCompleteCallback &callback);
 
+        /**
+         * get resource automation Ids
+         * @return resource automation id
+         */
         std::vector<int> getResourceAutomationIds();
 
+        /**
+         * get attribute automation Ids
+         * @return attribute automation id
+         */
         std::vector<int> getAttributeAutomationIds();
 
+        /**
+         * stop updation for given Id
+         * @param[in] updationID   id to update
+         */
         void stop(int updationID);
 
+        /** stop all updation */
         void stopAll();
 
     private:
index bf22985..7b5d432 100644 (file)
 #include "request_model.h"
 #include "RamlParser.h"
 
+/**
+ * @class SimulatorResourceFactory
+ */
 class SimulatorResourceFactory;
 class SimulatorCollectionResourceImpl : public SimulatorCollectionResource
 {
     public:
         friend class SimulatorResourceFactory;
 
+        /**
+         * check collection resource
+         * @return boolean value
+         */
         bool isCollection() const;
+        /**
+         * set the resource name
+         * @param[in] name   resource name
+         */
         void setName(const std::string &name);
+        /**
+         * set uri information
+         * @param[in] uri   resource uri
+         */
         void setURI(const std::string &uri);
+        /**
+         * set resource type
+         * @param[in] resourceType   resource type
+         */
         void setResourceType(const std::string &resourceType);
+        /**
+         * set interface type
+         * @param[in] interfaceType  interface type
+         */
         void setInterface(const std::string &interfaceType);
+        /**
+         * set interface type
+         * @param[in] interfaceTypes  interface types
+         */
         void setInterface(const std::vector<std::string> &interfaceTypes);
+        /**
+         * add the new interface
+         * @param[in] interfaceType  interface type
+         */
         void addInterface(const std::string &interfaceType);
+        /**
+         * set the observable state information
+         * @param[in] state   value to set
+         */
         void setObservable(bool state);
+        /**
+         * set discoverable state information
+         * @param[in] state   value to set
+         */
         void setDiscoverable(bool state);
+        /**
+         * set observer callback
+         * @param[in] callback   observer callback function
+         */
         void setObserverCallback(ObserverCallback callback);
+        /**
+         * set model change callback
+         * @param[in] callback   callback function
+         */
         void setModelChangeCallback(ResourceModelUpdateCallback callback);
+        /**
+         * check observable value
+         * @return boolean value
+         */
         bool isObservable() const;
+        /**
+         * check discoverable value
+         * @return boolean value
+         */
         bool isDiscoverable() const;
+        /**
+         * check resource observation started or not
+         * @return boolean value
+         */
         bool isStarted() const;
+        /**
+         * start resource
+         */
         void start();
+        /**
+         * stop resource
+         */
         void stop();
+        /**
+         * get resource model information
+         * @return resource model object
+         */
         SimulatorResourceModel getResourceModel();
+        /**
+         * get observers details
+         * @return observer object
+         */
         std::vector<ObserverInfo> getObservers() const;
+        /**
+         * notify to given Id
+         * @param[in] observerID   observer id
+         */
         void notify(int observerID);
+        /**
+         * notify to all
+         */
         void notifyAll();
-
+        /**
+         * get supported resources information
+         * @return supported resource object
+         */
         std::vector<std::string> getSupportedResources();
+        /**
+         * add child resource information
+         * @param[in] resource    simulator resource
+         */
         void addChildResource(const std::shared_ptr<SimulatorResource> &resource);
+        /**
+         * remove child resource information
+         * @param[in] resource    simulator resource
+         */
         void removeChildResource(const std::shared_ptr<SimulatorResource> &resource);
+        /**
+         * remove child resource
+         * @param[in] uri   resource URI
+         */
         void removeChildResource(const std::string &uri);
+        /**
+         * get child resources information
+         * @return resource object
+         */
         std::vector<SimulatorResourceSP> getChildResources();
 
     private:
index 81ea2f8..1674fdc 100644 (file)
 #include "resource_update_automation_mngr.h"
 #include "RamlParser.h"
 
+/**
+ * @class SimulatorResourceFactory
+ */
 class SimulatorResourceFactory;
 class SimulatorSingleResourceImpl : public SimulatorSingleResource,
     public std::enable_shared_from_this<SimulatorSingleResourceImpl>
 {
     public:
         friend class SimulatorResourceFactory;
-
+        /**
+         * set resource name
+         * @param[in] name  resource name
+         */
         void setName(const std::string &name);
+        /**
+         * set the given URI information
+         * @param[in] uri   resource uri
+         */
         void setURI(const std::string &uri);
+        /**
+         * set the resource type
+         * @param[in] resourceType  resource type
+         */
         void setResourceType(const std::string &resourceType);
+        /**
+         * set the interface detail
+         * @param[in] interfaceType  interface type
+         */
         void setInterface(const std::string &interfaceType);
+        /**
+         * set interface
+         * @param[in] interfaceType  interface types
+         */
         void setInterface(const std::vector<std::string> &interfaceTypes);
+        /**
+         * add new interface
+         * @param[in] interfaceType  interface type
+         */
         void addInterface(const std::string &interfaceType);
+        /**
+         * set observable state information
+         * @param[in] state   state to set
+         */
         void setObservable(bool state);
+        /**
+         * set discoverable state information
+         * @param[in] state   state to set
+         */
         void setDiscoverable(bool state);
+        /**
+         * set observer callback
+         * @param[in] callback   callback function
+         */
         void setObserverCallback(ObserverCallback callback);
+        /**
+         * set model change callback
+         * @param[in] callback   callback function
+         */
         void setModelChangeCallback(ResourceModelUpdateCallback callback);
+        /**
+         * check observable value
+         * @return boolean value
+         */
         bool isObservable() const;
+        /**
+         * check discoverable value
+         * @return boolean value
+         */
         bool isDiscoverable() const;
+        /**
+         * check resource is started or not
+         * @return boolean value
+         */
         bool isStarted() const;
+        /**
+         * start resource
+         */
         void start();
+        /**
+         * stop resource
+         */
         void stop();
+        /**
+         * get resource model information
+         * @return resource model object
+         */
         SimulatorResourceModel getResourceModel();
+        /**
+         * get observers details
+         * @return observers object
+         */
         std::vector<ObserverInfo> getObservers() const;
+        /**
+         * notify to given Id
+         * @param[in] observerID   observer id
+         */
         void notify(int observerID);
+        /**
+         * notify to all
+         */
         void notifyAll();
-
+        /**
+         * get attribute value
+         * @param[in] attrName   attribute name
+         * @param[out] attribute attribute
+         * @return boolean value
+         */
         bool getAttribute(const std::string &attrName, SimulatorResourceAttribute &attribute);
+        /**
+         * get attribute
+         * @return resource object
+         */
         std::map<std::string, SimulatorResourceAttribute> getAttributes();
+        /**
+         * add new attribute
+         * @param[in] attribute   resource attribute
+         * @param[in] notify      notify resource value
+         * @return boolean value
+         */
         bool addAttribute(const SimulatorResourceAttribute &attribute, bool notify = true);
+        /**
+         * update attribute value
+         * @param[in] attribute   resource attribute
+         * @param[in] notify      notify resource value
+         * @return boolean value
+         */
         bool updateAttributeValue(const SimulatorResourceAttribute &attribute,
                                   bool notify = true);
+        /**
+         * remove attribute with given information
+         * @param[in] attrName     attribute name
+         * @param[in] notify       notify resource value
+         * @return boolean value
+         */
         bool removeAttribute(const std::string &attrName, bool notify = true);
+        /**
+         * start resource updation
+         * @param[in] type            update type
+         * @param[in] updateInterval  update interval
+         * @param[in] callback        callback function
+         * return resource object
+         */
         int startResourceUpdation(AutoUpdateType type, int updateInterval,
                                   AutoUpdateCompleteCallback callback);
+        /**
+         * start attribute updation
+         * @param[in] attrName         attribute name
+         * @param[in] type             update type
+         * @param[in] updateInterval   update interval
+         * @param[in] callback         callback function
+         * @return attribute object
+         */
         int startAttributeUpdation(const std::string &attrName, AutoUpdateType type,
                                    int updateInterval, AutoUpdateCompleteCallback callback);
+        /**
+         * get resource updations
+         * @return resource object
+         */
         std::vector<int> getResourceUpdations();
+        /**
+         * get attribute updations
+         * @return attribute object
+         */
         std::vector<int> getAttributeUpdations();
+        /**
+         * set updation
+         * @param[in] id   id to update
+         */
         void stopUpdation(const int id);
-
+        /**
+         * update resource model
+         * @param[in] reqResModel      resource model
+         * @param[in] updatedResModel  resource model to update
+         * @param[in] overwrite        boolean value for overwrite
+         * @param[in] notify           boolean value for notify
+         * @return boolean value
+         */
         bool updateResourceModel(const SimulatorResourceModel &reqResModel,
                                  SimulatorResourceModel &updatedResModel, bool overwrite = false,
                                  bool notify = true);
+        /**
+         * notify app
+         */
         void notifyApp();
+        /**
+         * notify app
+         * @param[in] resModel   resource model
+         */
         void notifyApp(const SimulatorResourceModel &resModel);
 
     private: