clientdatamap.cpp

/***************************************************************************
 * The contents of this file are subject to the Mozilla Public             *
 * License Version 1.1 (the "License"); you may not use this file          *
 * except in compliance with the License. You may obtain a copy of         *
 * the License at http://www.mozilla.org/MPL/                              *
 *                                                                         *
 * Software distributed under the License is distributed on an "AS         *
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or              *
 * implied. See the License for the specific language governing            *
 * rights and limitations under the License.                               *
 *                                                                         *
 * The Original Code is Game Network Framework (GaNeF).                    *
 *                                                                         *
 * The Initial Developers of the Original Code are                         *
 * Lars Langer and Emanuel Greisen                                         *
 * Copyright (C) 2005. Lars Langer & Emanuel Greisen                       *
 * All Rights Reserved.                                                    *
 *                                                                         *
 * Contributor(s):                                                         *
 *   none yet....                                                          *
 *                                                                         *
 ***************************************************************************/
#include "clientdatamap.h"
#include "clientdata.h"
#include <map.h>

ClientDataMap::ClientDataMap()
{
   pointing_map.clear();
   pointee_map.clear();
}


ClientDataMap::~ClientDataMap()
{
}

void ClientDataMap::unregisterData( ClientData * data )
{
   //update the references in the reference map to NULL
   if(pointee_map.find(data->getFrameworkId()) != pointee_map.end())
   {
      PPMap & ppmap = pointee_map[data->getFrameworkId()];
      unsigned int i ;
      for (PPMap::iterator it = ppmap.begin() ; it != ppmap.end(); it++)
      {
         PtrPtrVec & ptrptrvec = it->second;
         for(PtrPtrVec::iterator vit = ptrptrvec.begin(); vit != ptrptrvec.end(); vit++)
         {
            ClientData ** ptrptr = *vit;
            if(*ptrptr == data)
               *ptrptr = NULL;
         }
      }
   }

   // remove from pointee maps via pointing map - if this object no longer exists noone needs to wait for it
   // and set its pointer when it arrives
   if(pointing_map.find(data->getFrameworkId()) != pointing_map.end())
   {
      PPMap & ppmap = pointing_map[data->getFrameworkId()].ppmap;
      unsigned int i ;
      for (PPMap::iterator it = ppmap.begin() ; it != ppmap.end(); it++)
      {

         unsigned int pointee_entry = it->first;
         pointee_map[pointee_entry].erase(data->getFrameworkId());
         if(pointee_map[pointee_entry].empty());
         {
            pointee_map.erase(pointee_entry);
         }

      }
         //and last, but not least, remove the entry from the pointing map
      pointing_map.erase(data->getFrameworkId());
   }
   //std::cout << "unregisterData( FrameworkData * data : " << data->getFrameworkId() << ")" << std::endl;
}

void ClientDataMap::registerPointer( unsigned int receiver, unsigned int missing, ClientData ** ptrptr )
{
   pointing_map[receiver].ppmap[missing].push_back(ptrptr);
   pointing_map[receiver].ptr2pointee[ptrptr] = missing;

      // Register that someone is missing 'missing' (its 'receiver')
   pointee_map[missing][receiver].push_back(ptrptr);

   //std::cout << "registerPointer( resv: "<<receiver<<", miss: "<<missing<<", ptrptr: " <<ptrptr<<" )" << std::endl;
}


bool ClientDataMap::unregisterPointer(unsigned int receiver, unsigned int new_objid, ClientData **ptrptr)
{
   // Either the pointing object is unknown
   if(pointing_map.find(receiver) == pointing_map.end())
      return true;

   // Or this pointer has not been set before
   if(pointing_map[receiver].ptr2pointee.find(ptrptr) == pointing_map[receiver].ptr2pointee.end())
      return true;

   // Ok, it is set, lets see who it's pointing at
   unsigned int pointee_entry = pointing_map[receiver].ptr2pointee[ptrptr];

   // We want the ptrptr to point at the same object - no need to change
   if(pointee_entry == new_objid)
      return false;

   // If we are about the read a null-pointer we might as well clean up the pointing_map
   //if(new_objid == 0)
   {
      pointing_map[receiver].ptr2pointee.erase(ptrptr);

      PtrPtrVec & ptrptrvec = pointing_map[receiver].ppmap[pointee_entry];
      for(PtrPtrVec::iterator vit = ptrptrvec.begin(); vit != ptrptrvec.end(); vit++)
      {
         if(*vit == ptrptr)
         {
            ptrptrvec.erase(vit);
            if(ptrptrvec.empty())
               pointing_map[receiver].ppmap.erase(pointee_entry);

            if(pointing_map[receiver].isEmpty())
               pointing_map.erase(receiver);

            break;
         }
      }
   }

   // Sanity check: make sure pointee is also in the pointee-map
   if(pointee_map.find(pointee_entry) != pointee_map.end())
   {
      PPMap & ppmap = pointee_map[pointee_entry];
      if(ppmap.find(receiver) == ppmap.end())
         throw new FrameworkError("Pointing object did not exist in pointee map");

      PtrPtrVec & ptrptrvec = ppmap[receiver];
      for(PtrPtrVec::iterator vit = ptrptrvec.begin(); vit != ptrptrvec.end(); vit++)
      {
         if(*vit == ptrptr)
         {
            ptrptrvec.erase(vit);

            if(ptrptrvec.empty())
               pointee_map[pointee_entry].erase(receiver);
            if(pointee_map[pointee_entry].empty())
               pointee_map.erase(pointee_entry);

            break;
         }
      }
   }
   else
   {
      std::cerr << "Pointee ["<<pointee_entry<<"] did not exist in pointee map"<<std::endl;
      throw new FrameworkError("Pointee did not exist in pointee map");
   }
   return true;
}

void ClientDataMap::printDebug( )
{
   std::cout << "----------: Pointer pointer table thingy :----------"<<std::endl;

   // The pointing objects
   for(PointingMap::const_iterator it = pointing_map.begin(); it != pointing_map.end(); ++it)
   {
      std::cout << "Pointing Obj["<<it->first<<"]:\n";
      std::cout << " -PPMAP:";
      for(PPMap::const_iterator ppit = it->second.ppmap.begin();ppit != it->second.ppmap.end(); ++ppit)
      {
         std::cout << "["<<ppit->first<<":<";
         for(PtrPtrVec::const_iterator ptrit = ppit->second.begin(); ptrit != ppit->second.end(); ++ptrit)
         {
            std::cout << (*ptrit) << ",";
         }
         std::cout << ">]";
      }
      std::cout << std::endl;
      std::cout << " -PtrPtrMap:";
      std::map<ClientData **, unsigned int>::const_iterator ptrit;
      for(ptrit = it->second.ptr2pointee.begin(); ptrit != it->second.ptr2pointee.end(); ++ptrit)
      {
         std::cout << "["<<ptrit->first<<":"<<ptrit->second<<"],";
      }
      std::cout << std::endl;
   }


   // The pointees
   for(PointeeMap::const_iterator it = pointee_map.begin(); it != pointee_map.end(); ++it)
   {
      std::cout << "Pointee Obj["<<it->first<<"]:\n";
      std::cout << " -PPMAP:";
      for(PPMap::const_iterator ppit = it->second.begin();ppit != it->second.end(); ++ppit)
      {
         std::cout << "["<<ppit->first<<":<";
         for(PtrPtrVec::const_iterator ptrit = ppit->second.begin(); ptrit != ppit->second.end(); ++ptrit)
         {
            std::cout << (*ptrit) << ",";
         }
         std::cout << ">]";
      }
      std::cout << std::endl;
   }
   std::cout << "----------: Pointer pointer table thingy :----------"<<std::endl;
}

---