resource-container: make registerResource() return status code

[platform/upstream/iotivity.git] / service / simulator / src / client-controller / attribute_generator.cpp

diff --git a/service/simulator/src/client-controller/attribute_generator.cpp b/service/simulator/src/client-controller/attribute_generator.cpp
index 7cd3290..03abd64 100644 (file)
--- a/service/simulator/src/client-controller/attribute_generator.cpp
+++ b/service/simulator/src/client-controller/attribute_generator.cpp
@@ -20,121 +20,168 @@
 
 #include "attribute_generator.h"
 
-AttributeGenerator::AttributeGenerator(SimulatorResourceModel::Attribute &attribute)
+AttributeGenerator::AttributeGenerator(const SimulatorResourceModel::Attribute &attribute)
+    :   m_name(attribute.getName()),
+        m_min(INT_MIN),
+        m_max(INT_MAX),
+        m_rangeIndex(-1),
+        m_allowedValueIndex(0),
+        m_hasRange(false),
+        m_hasAllowedValue(false)
 {
-    m_name.assign(attribute.getName());
-    m_type = attribute.getValueType();
-
-    if (!attribute.getValueType())
+    if (attribute.getValueType() ==
+        SimulatorResourceModel::Attribute::ValueType::INTEGER)
+    {
         attribute.getRange(m_min, m_max);
-    if (m_max > 0)
+        if (INT_MIN != m_min && INT_MAX != m_max)
+        {
+            m_hasRange = true;
+            m_rangeIndex = m_min;
+        }
+    }
+    else
     {
-        m_hasRange = true;
+        m_allowedValues = attribute.getAllowedValues();
+        if (0 != m_allowedValues.size())
+        {
+            m_hasAllowedValue = true;
+        }
     }
+}
 
-    if (!m_type)
-        m_rangeIndex = m_min;
+bool AttributeGenerator::hasNext()
+{
+    if (m_hasRange && m_rangeIndex <= m_max)
+    {
+        return true;
+    }
 
-    m_allowedValues = attribute.getAllowedValues();
-    if (0 != m_allowedValues.size())
+    if (m_hasAllowedValue && m_allowedValueIndex < m_allowedValues.size())
     {
-        m_hasAllowedValue = true;
+        return true;
     }
-    m_nextAllowedValueIndex = 0;
-    m_prevAllowedValueIndex = m_allowedValues.size();
-}
 
-AttributeGenerator::~AttributeGenerator()
-{
-    m_rangeIndex = 0;
-    m_min = 0;
-    m_max = 0;
-    m_nextAllowedValueIndex = 0;
-    m_prevAllowedValueIndex = 0;
-    m_type = 0;
+    return false;
 }
 
-bool AttributeGenerator::hasNext()
+bool AttributeGenerator::next(SimulatorResourceModel::Attribute &attribute)
 {
-    if (m_hasRange && m_rangeIndex <= m_max && !m_type)
+    attribute.setName(m_name);
+
+    if (m_hasRange)
     {
+        attribute.setValue(m_rangeIndex++);
         return true;
     }
-
-    if (m_hasAllowedValue && m_nextAllowedValueIndex < m_allowedValues.size())
+    else if (m_hasAllowedValue)
     {
+        attribute.setValue(m_allowedValues[m_allowedValueIndex++]);
         return true;
     }
 
     return false;
 }
 
-AttributeSP AttributeGenerator::next()
+SimulatorResourceModel::Attribute AttributeGenerator::current()
 {
-    AttributeSP attr = std::make_shared<SimulatorResourceModel::Attribute>(m_name);
+    SimulatorResourceModel::Attribute attribute;
 
-    if (!attr)
-        return nullptr;
-
-    if (m_hasRange && !m_type)
+    attribute.setName(m_name);
+    if (m_hasRange)
     {
-        attr->setName(m_name);
-        attr->setValue(m_rangeIndex++);
-        return attr;
+        attribute.setValue(m_rangeIndex);
     }
-
-    if (m_hasAllowedValue)
+    else if (m_hasAllowedValue)
     {
-        switch (m_type)
-        {
-            case 1:
-                {
-                    attr->setValue(m_allowedValues[m_nextAllowedValueIndex++]);
-                }
-                break;
+        attribute.setValue(m_allowedValues[m_allowedValueIndex]);
+    }
 
-            case 3:
-                {
-                    attr->setValue(m_allowedValues[m_nextAllowedValueIndex++]);
-                }
-                break;
-        }
+    return attribute;
+}
 
-        return attr;
+void AttributeGenerator::reset()
+{
+    if (m_hasRange)
+    {
+        m_rangeIndex = m_min;
+    }
+    else if (m_hasAllowedValue)
+    {
+        m_allowedValueIndex = 0;
     }
 }
 
-AttributeSP AttributeGenerator::previous()
+AttributeCombinationGen::AttributeCombinationGen(
+        const std::vector<SimulatorResourceModel::Attribute> &attributes)
 {
-    AttributeSP attr = std::make_shared<SimulatorResourceModel::Attribute>(m_name);
+    for (auto &attr : attributes)
+    {
+        AttributeGenerator attrGen(attr);
+        m_attrGenList.push_back(attr);
+    }
 
-    if (!attr)
-        return nullptr;
+    m_index = -1;
+}
 
-    if (m_hasRange && !m_type)
+bool AttributeCombinationGen::next(SimulatorResourceModel &resModel)
+{
+    if (!m_attrGenList.size())
     {
-        attr->setValue(m_rangeIndex - 1);
-        return attr;
+        return false;
     }
 
-    if (m_hasAllowedValue)
+    std::lock_guard<std::mutex> lock(m_lock);
+
+    // This block will execute for only first time
+    if (-1 == m_index)
     {
-        switch (m_type)
+        for (int index = 0; index < m_attrGenList.size(); index++)
         {
-            case 1:
-                {
-                    attr->setValue(m_allowedValues[m_prevAllowedValueIndex - 1]);
-                }
-                break;
+            // Add the attribute on resource model
+            addAttributeToModel(index);
+        }
 
-            case 3:
-                {
-                    attr->setValue(m_allowedValues[m_prevAllowedValueIndex - 1]);
-                }
+        m_index = m_attrGenList.size() - 1;
+        resModel = m_resModel;
+        return true;
+    }
+
+    // Get the next attribute from statck top element
+    if (m_attrGenList[m_index].hasNext())
+    {
+        addAttributeToModel(m_index);
+        resModel = m_resModel;
+        return true;
+    }
+    else
+    {
+        for (int index = m_index; index >= 0; index--)
+        {
+            if (!m_attrGenList[index].hasNext())
+            {
+                if (!index)
+                    return false;
+
+                m_attrGenList[index].reset();
+                addAttributeToModel(index);
+            }
+            else
+            {
+                addAttributeToModel(index);
                 break;
+            }
         }
 
-        return attr;
+        resModel = m_resModel;
+        return true;
     }
+
+    return false;
 }
 
+void AttributeCombinationGen::addAttributeToModel(int index)
+{
+    SimulatorResourceModel::Attribute attribute;
+    m_attrGenList[index].next(attribute);
+    m_resModel.addAttribute(attribute, true);
+}