changed SystemStatusOsObserver

to allow clients to subscribe before subscription obj
arrives, and also simplified ClientIndex and DataItemIndex
implementation significantly.

Change-Id: I092f344e688fa698aa98795b8a8f0c1ba8fcd9e4
CRs-Fixed: 2218519

1 files changed, 59 insertions, 35 deletions

diff --git a/core/SystemStatusOsObserver.h b/core/SystemStatusOsObserver.h
index 930ddc1..fd60606 100644
--- a/core/SystemStatusOsObserver.h
+++ b/core/SystemStatusOsObserver.h
@@ -41,6 +41,7 @@
 #include <IOsObserver.h>
 #include <loc_pla.h>
 #include <log_util.h>
+#include <LocUnorderedSetMap.h>
 
 namespace loc_core
 {
@@ -48,39 +49,57 @@ namespace loc_core
  SystemStatusOsObserver
 ******************************************************************************/
 using namespace std;
+using namespace loc_util;
 
 // Forward Declarations
 class IDataItemCore;
-template<typename CT, typename DIT> class IClientIndex;
-template<typename CT, typename DIT> class IDataItemIndex;
+class SystemStatus;
+class SystemStatusOsObserver;
+typedef map<IDataItemObserver*, list<DataItemId>> ObserverReqCache;
+typedef LocUnorderedSetMap<IDataItemObserver*, DataItemId> ClientToDataItems;
+typedef LocUnorderedSetMap<DataItemId, IDataItemObserver*> DataItemToClients;
+typedef unordered_map<DataItemId, IDataItemCore*> DataItemIdToCore;
+typedef unordered_map<DataItemId, int> DataItemIdToInt;
 
-struct SystemContext {
+struct ObserverContext {
     IDataItemSubscription* mSubscriptionObj;
     IFrameworkActionReq* mFrameworkActionReqObj;
     const MsgTask* mMsgTask;
+    SystemStatusOsObserver* mSSObserver;
 
-    inline SystemContext() :
-        mSubscriptionObj(NULL),
-        mFrameworkActionReqObj(NULL),
-        mMsgTask(NULL) {}
+    inline ObserverContext(const MsgTask* msgTask, SystemStatusOsObserver* observer) :
+            mSubscriptionObj(NULL), mFrameworkActionReqObj(NULL),
+            mMsgTask(msgTask), mSSObserver(observer) {}
 };
 
-typedef map<IDataItemObserver*, list<DataItemId>> ObserverReqCache;
-
 // Clients wanting to get data from OS/Framework would need to
 // subscribe with OSObserver using IDataItemSubscription interface.
 // Such clients would need to implement IDataItemObserver interface
 // to receive data when it becomes available.
-class SystemStatus;
 class SystemStatusOsObserver : public IOsObserver {
 
 public:
     // ctor
-    SystemStatusOsObserver(
-            SystemStatus* systemstatus, const MsgTask* msgTask);
+    inline SystemStatusOsObserver(SystemStatus* systemstatus, const MsgTask* msgTask) :
+            mSystemStatus(systemstatus), mContext(msgTask, this),
+            mAddress("SystemStatusOsObserver"),
+            mClientToDataItems(MAX_DATA_ITEM_ID), mDataItemToClients(MAX_DATA_ITEM_ID)
+#ifdef USE_GLIB
+            , mBackHaulConnectReqCount(0)
+#endif
+    {
+    }
+
     // dtor
     ~SystemStatusOsObserver();
 
+    template <typename CINT, typename COUT>
+    static COUT containerTransfer(CINT& s);
+    template <typename CINT, typename COUT>
+    inline static COUT containerTransfer(CINT&& s) {
+        return containerTransfer<CINT, COUT>(s);
+    }
+
     // To set the subscription object
     virtual void setSubscriptionObj(IDataItemSubscription* subscriptionObj);
 
@@ -96,38 +115,40 @@ public:
     }
 
     // IDataItemSubscription Overrides
-    virtual void subscribe(const list<DataItemId>& l, IDataItemObserver* client);
-    virtual void updateSubscription(const list<DataItemId>& l, IDataItemObserver* client);
-    virtual void requestData(const list<DataItemId>& l, IDataItemObserver* client);
-    virtual void unsubscribe(const list<DataItemId>& l, IDataItemObserver* client);
-    virtual void unsubscribeAll(IDataItemObserver* client);
+    inline virtual void subscribe(const list<DataItemId>& l, IDataItemObserver* client) override {
+        subscribe(l, client, false);
+    }
+    virtual void updateSubscription(const list<DataItemId>& l, IDataItemObserver* client) override;
+    inline virtual void requestData(const list<DataItemId>& l, IDataItemObserver* client) override {
+        subscribe(l, client, true);
+    }
+    virtual void unsubscribe(const list<DataItemId>& l, IDataItemObserver* client) override;
+    virtual void unsubscribeAll(IDataItemObserver* client) override;
 
     // IDataItemObserver Overrides
-    virtual void notify(const list<IDataItemCore*>& dlist);
-    inline virtual void getName(string& name) {
+    virtual void notify(const list<IDataItemCore*>& dlist) override;
+    inline virtual void getName(string& name) override {
         name = mAddress;
     }
 
     // IFrameworkActionReq Overrides
-    virtual void turnOn(DataItemId dit, int timeOut = 0);
-    virtual void turnOff(DataItemId dit);
+    virtual void turnOn(DataItemId dit, int timeOut = 0) override;
+    virtual void turnOff(DataItemId dit) override;
 #ifdef USE_GLIB
-    virtual bool connectBackhaul();
+    virtual bool connectBackhaul() override;
     virtual bool disconnectBackhaul();
 #endif
 
 private:
     SystemStatus*                                    mSystemStatus;
-    SystemContext                                    mContext;
+    ObserverContext                                  mContext;
     const string                                     mAddress;
-    IClientIndex<IDataItemObserver*, DataItemId>*    mClientIndex;
-    IDataItemIndex<IDataItemObserver*, DataItemId>*  mDataItemIndex;
-    map<DataItemId, IDataItemCore*>                  mDataItemCache;
-    map<DataItemId, int>                             mActiveRequestCount;
+    ClientToDataItems                                mClientToDataItems;
+    DataItemToClients                                mDataItemToClients;
+    DataItemIdToCore                                 mDataItemCache;
+    DataItemIdToInt                                  mActiveRequestCount;
 
     // Cache the subscribe and requestData till subscription obj is obtained
-    ObserverReqCache mSubscribeReqCache;
-    ObserverReqCache mReqDataCache;
     void cacheObserverRequest(ObserverReqCache& reqCache,
             const list<DataItemId>& l, IDataItemObserver* client);
 #ifdef USE_GLIB
@@ -135,13 +156,16 @@ private:
     int         mBackHaulConnectReqCount;
 #endif
 
+    void subscribe(const list<DataItemId>& l, IDataItemObserver* client, bool toRequestData);
+
     // Helpers
-    void sendFirstResponse(const list<DataItemId>& l, IDataItemObserver* to);
-    void sendCachedDataItems(const list<DataItemId>& l, IDataItemObserver* to);
-    void updateCache(IDataItemCore* d, bool& dataItemUpdated);
-    inline void logMe(const list<DataItemId>& l) {
-        for (auto id : l) {
-            LOC_LOGD("DataItem %d", id);
+    void sendCachedDataItems(const unordered_set<DataItemId>& s, IDataItemObserver* to);
+    bool updateCache(IDataItemCore* d);
+    inline void logMe(const unordered_set<DataItemId>& l) {
+        IF_LOC_LOGD {
+            for (auto id : l) {
+                LOC_LOGD("DataItem %d", id);
+            }
         }
     }
 };