Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 2348 for code/branches/network


Ignore:
Timestamp:
Dec 6, 2008, 12:28:14 AM (16 years ago)
Author:
scheusso
Message:

still not complete yet but much better i hope…

Location:
code/branches/network/src/network
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • code/branches/network/src/network/Synchronisable.h

    r2034 r2348  
    114114    inline unsigned int getObjectID(){return objectID;}
    115115    inline unsigned int getClassID(){return classID;}
     116    inline unsigned int getPriority(){ return objectFrequency_;}
    116117  protected:
    117118    Synchronisable(orxonox::BaseObject* creator);

  • code/branches/network/src/network/TrafficControl.cc

    r2341 r2348  
    3131#include <cassert>
    3232#include <boost/bind.hpp>
     33#include "Synchronisable.h"
     34#include "ClientInformation.h"
    3335
    3436namespace network {
    … …  
    6365*/
    6466
    65         /**
    66                 *eigener sortieralgorithmus
    67         */
    68         bool TrafficControl::priodiffer(obj i, obj j)
    69         {
    70           std::map<unsigned int, objInfo>::iterator iti;
    71           std::map<unsigned int, objInfo>::iterator itj;
    72           iti=listToProcess_.find(i.objID);
    73           itj=listToProcess_.find(j.objID);
    74           return iti->second.objValuePerm < itj->second.objValuePerm;
    75         }
    76 
     67  /**
     68          *eigener sortieralgorithmus
     69  */
     70//   bool TrafficControl::priodiffer(obj i, obj j)
     71//   {
     72//     std::map<unsigned int, objInfo>::iterator iti;
     73//     std::map<unsigned int, objInfo>::iterator itj;
     74//     iti=listToProcess_.find(i.objID);
     75//     itj=listToProcess_.find(j.objID);
     76//     return iti->second.objValuePerm < itj->second.objValuePerm;
     77//   }
     78 
     79  /**
     80  * eigener sortieralgorithmus
     81  */
     82  bool TrafficControl::priodiffer(uint32_t clientID, obj i, obj j)
     83  {
     84    assert(clientListPerm_.find(clientID) != clientListPerm_.end());  //make sure the client exists in our list
     85    assert(clientListPerm_[clientID].find(i.objID) != clientListPerm_[clientID].end()); // make sure the object i is in the client list
     86    assert(clientListPerm_[clientID].find(j.objID) != clientListPerm_[clientID].end()); // make sure the object j is in the client list
     87   
     88    return clientListPerm_[clientID][i.objID].objID < clientListPerm_[clientID][j.objID].objID;
     89  }
    7790
    7891
    … …  
    8295          currentClientID=clientID;
    8396          currentGamestateID=gamestateID;
    84           evaluateList(list);
     97          evaluateList(clientID, list);
    8598          //list hatte vorher ja vielmehr elemente, nach zuweisung nicht mehr... speicherplatz??
    8699          *list=copiedVector;
    87           //später wird copiedVector ja überschrieben, ist das ein problem für list-dh. für gamestatemanager?
     100    //später wird copiedVector ja überschrieben, ist das ein problem für list-dh. für gamestatemanager?
    88101          return list;
    89102        }
    … …  
    91104        void TrafficControl::processAck(unsigned int clientID, unsigned int gamestateID)
    92105        {
    93           std::map<unsigned int, std::map<unsigned int, std::vector<objInfo> > >::iterator itperm;//iterator clientListPerm
    94           std::map<unsigned int, std::vector<objInfo> >::iterator itpermObjectIDList;//iterator over objectid
    95     std::vector<objInfo>::iterator itpermObjectID;
    96     std::map<unsigned int, std::map<unsigned int, std::vector<obj> > >::iterator ittemp;//iterator clientListTemp, iterates over clientIDs
    97           std::map<unsigned int, std::vector<obj> >::iterator ittempgs;//iterator that iterates over gsIDs of a client
    98           std::vector<obj>::iterator itvec;
    99           //following code helps to put clientListTemp infos into clientListPerm infos
    100           ittemp = clientListTemp_.find(clientID);
    101           assert(ittemp != clientListTemp_.end() ); //muss da nicht was anderes überprüft werden? -> nein
    102           itperm = clientListPerm_.find(clientID);
    103           assert(itperm != clientListPerm_.end() );
    104           ittempgs = ittemp->second.find(gamestateID);
    105           assert( ittempgs != ittemp->second.end() );//gleiche frage wie vorher -> nein
    106           for(itvec = ittempgs->second.begin(); itvec != ittempgs->second.end(); itvec++)
     106          std::vector<obj>::iterator itvec;  // iterator to iterate through the acked objects
     107   
     108    //assertions to make sure the maps already exist
     109    assert(clientListTemp_.find(clientID) != clientListTemp_.end() );
     110    assert(clientListPerm_.find(clientID) != clientListPerm_.end() );
     111          assert( clientListTemp_[clientID].find(gamestateID) != clientListTemp_[clientID].end() );
     112   
     113    for(itvec = clientListTemp_[clientID][gamestateID].begin(); itvec != clientListTemp_[clientID][gamestateID].end(); itvec++)
    107114          {
    108       bool alreadyExisting = false;
    109       itpermObjectIDList = itperm->second.find(gamestateID);
    110       assert(itpermObjectIDList != itperm->second.end());
    111       for (itpermObjectID = itpermObjectIDList->second.begin(); itpermObjectID != itpermObjectIDList->second.end(); itpermObjectID++ )
    112       {
    113         if ( (*itpermObjectID).objID == (*itvec).objID)
    114         {
    115           (*itpermObjectID).objCurGS = gamestateID;
    116           alreadyExisting = true;
    117           break;
    118         }
    119         if ( !alreadyExisting )
    120         {
    121           objInfo objinf;    // TODO: is this initialisation complete ?
    122           objinf.objCurGS = gamestateID;
    123           objinf.objID = (*itvec).objID;
    124           insertinClientListPerm(clientID, (*itvec).objID, objinf);
    125         }
     115      if(clientListPerm_[clientID].find((*itvec).objID) != clientListPerm_[clientID].end()) // check whether the obj already exists in our lists
     116      {
     117        clientListPerm_[clientID][(*itvec).objID].objID = gamestateID;
     118      }
     119      else
     120      {
     121        clientListPerm_[clientID][(*itvec).objID].objCurGS = gamestateID;
     122        clientListPerm_[clientID][(*itvec).objID].objID = (*itvec).objID;
     123        clientListPerm_[clientID][(*itvec).objID].objCreatorID = (*itvec).objCreatorID;
     124        clientListPerm_[clientID][(*itvec).objID].objSize = (*itvec).objSize;
    126125      }
    127126          }
    128127           // remove temporary vector (with acked objects) from the map
    129     ittemp->second.erase(ittempgs);
     128    clientListTemp_[clientID].erase( clientListTemp_[clientID].find(gamestateID) );
    130129        }
    131130
    … …  
    138137        *copyList gets vector of Gamestate Manager and turns it to *listToProcess
    139138        */
    140         void TrafficControl::copyList(std::vector<obj> *list)
    141         {
    142           std::vector<obj>::iterator itvec;
    143           for(itvec = (*list).begin(); itvec != (*list).end(); itvec++)
    144           {
    145             objInfo objectA;
    146             objectA.objCreatorID=(*itvec).objCreatorID;
    147             objectA.objSize = (*itvec).objSize;
    148             listToProcess_.insert(pair<currentClientID, map<(*itvec).objID,objectA>>);//unsicher: ob map<...> so richtig ist
    149           }
    150         }
     139//      void TrafficControl::copyList(std::vector<obj> *list)
     140//      {
     141//        std::vector<obj>::iterator itvec;
     142//        for(itvec = (*list).begin(); itvec != (*list).end(); itvec++)
     143//        {
     144//          objInfo objectA;
     145//          objectA.objCreatorID=(*itvec).objCreatorID;
     146//          objectA.objSize = (*itvec).objSize;
     147//          listToProcess_.insert(std::pair<currentClientID, map<(*itvec).objID,objectA>>);//unsicher: ob map<...> so richtig ist
     148//        }
     149//      }
    151150        /**
    152151        *updateReferenceList compares the sent list by GSmanager with the current *reference list and updates it.
    153152        *returns void
    154153        */
    155         void TrafficControl::updateReferenceList(std::map<unsigned int, objInfo> *list)
    156         {
    157           std::map<unsigned int, Synchronisable*>::iterator itref;
    158           std::map<unsigned int, objInfo>::iterator itproc;
    159           for(itproc=(*listToProcess_).begin();itproc != (*listToProcess_).end(); itproc++)
    160           {
    161             //itproc->first=objectid that is looked for
    162             if(referenceList_->find(itproc->first))
    163             {
    164               continue;
    165             }
    166             else
    167             {
    168               (*referenceList_).insert(pair<unsigned int,          Synchronisable*>((*itproc).first,Synchronisable::getSynchronisable((*itproc).first)));//important: how to get adress of an object!
    169               insertinClientListPerm(currentClientID,itproc->first,itproc->second);
    170             }
    171           }
    172         }
     154//      void TrafficControl::updateReferenceList(std::map<unsigned int, objInfo> *list)
     155//      {
     156//        std::map<unsigned int, Synchronisable*>::iterator itref;
     157//        std::map<unsigned int, objInfo>::iterator itproc;
     158//        for(itproc=listToProcess_.begin(); itproc != listToProcess_.end(); itproc++)
     159//        {
     160//          //itproc->first=objectid that is looked for
     161//          if(referenceList_->find(itproc->first))
     162//          {
     163//            continue;
     164//          }
     165//          else
     166//          {
     167//            (*referenceList_).insert(pair<unsigned int,          Synchronisable*>((*itproc).first,Synchronisable::getSynchronisable((*itproc).first)));//important: how to get adress of an object!
     168//            insertinClientListPerm(currentClientID,itproc->first,itproc->second);
     169//          }
     170//        }
     171//      }
    173172        /**
    174173        *updateClientListPerm
    175174        *returns void
    176175        */
    177         void TrafficControl::insertinClientListPerm(unsigned int clientid, unsigned int objid, objInfo objinf)
     176        void TrafficControl::insertinClientListPerm(unsigned int clientID, obj objinf)
    178177        {
    179           std::map<unsigned int,std::map<unsigned int, objInfo>>::iterator itperm;//iterator clientListPerm over clientIDs
    180           itperm = (clientListPerm_).find(clientiD);
    181           assert(itperm != clientListPerm_.end() );
    182           (*itperm).insert(pair<unsigned int, objInfo>(objid,objinf));
    183           (permObjPrio_).insert(objid,objinf.objValuePerm);
    184         }
    185        
    186         /**
    187         *updateClientListTemp
    188         *takes the shortened vector which will be sent to the gsmanager and puts the *info into clientListTemp
    189         */     
    190         TrafficControl::updateClientListTemp(std::vector<obj> *list)
     178          std::map<unsigned int,std::map<unsigned int, objInfo> >::iterator itperm;//iterator clientListPerm over clientIDs
     179//        itperm = (clientListPerm_).find(clientID);
     180//        assert(itperm != clientListPerm_.end() );
     181    unsigned int gsid=GAMESTATEID_INITIAL, gsdiff=currentGamestateID, prioperm=Synchronisable::getSynchronisable(objinf.objID)->getPriority(), priomom=0;
     182    clientListPerm_[clientID][objinf.objID] = objInfo(objinf.objID, objinf.objCreatorID,gsid,gsdiff, objinf.objSize,prioperm,priomom);
     183//        itperm->second.insert(std::pair<unsigned int, objInfo>(objid,objinf));
     184//     permObjPrio_.insert(objid, objinf.objValuePerm);
     185        }
     186       
     187  /**
     188  * updateClientListTemp
     189  * takes the shortened vector which will be sent to the gsmanager and puts the *info into clientListTemp
     190  */   
     191  void TrafficControl::updateClientListTemp(std::vector<obj> *list)
     192  {
     193    clientListTemp_[currentClientID][currentGamestateID] = std::vector<obj>(*list);
     194//     std::vector<obj>::iterator itvec;
     195//     std::map<unsigned int,std::map<unsigned int, obj> >::iterator ittemp;
     196//     std::map<unsigned int, obj>::iterator ittempgs;
     197//     ittemp = clientListTemp_.find(currentClientID);
     198//     ittempgs = (*ittemp).find(currentGamestateID);
     199//     for(itvec = list.begin(); itvec!=list.end(), itvec++)
     200//     {
     201//       ittempgs.insert(itvec);
     202//     }
     203  }
     204
     205  /**
     206  *cut
     207  *takes the current vector that has to be returned to the gsmanager and shortens it in criteria of bandwidth of clientID(XY)
     208  */
     209  void TrafficControl::cut(std::vector<obj> *list, unsigned int targetsize)
     210  {
     211    unsigned int size=0;
     212    std::vector<obj>::iterator itvec;
     213    itvec = list->begin();
     214//     unsigned int i=0;
     215    for(itvec = list->begin(); itvec != list->end() && size<targetsize; itvec++)
     216//     while(size<targetsize && (itvec!=list.end()))
     217    {
     218      size = size + (*itvec).objSize;//objSize is given in bytes!??
     219//       i++;
     220//       itvec = list.begin()+i;
     221    }
     222    list->erase(itvec, list->end());
     223  }
     224
     225
     226        /**
     227        *evaluateList evaluates whether new obj are there, whether there are things to be updatet and manipulates all this.
     228        */
     229        void TrafficControl::evaluateList(unsigned int clientID, std::vector<obj> *list)
     230        {
     231          //copyList(list);
     232       
     233          //now the sorting
     234       
     235          //compare listToProcess vs clientListPerm
     236    //if listToProcess contains new Objects, add them to clientListPerm
     237          std::map<unsigned int, objInfo>::iterator itproc;
     238    std::vector<obj>::iterator itvec;
     239          std::map<unsigned int, std::map<unsigned int, objInfo> >::iterator itperm;
     240//        std::map<unsigned int, objInfo>::iterator itpermobj;
     241          unsigned int permprio;
     242          for( itvec=list->begin(); itvec != list->end(); itvec++)
     243          {
     244            itperm = clientListPerm_.find(clientID);
     245            if ( clientListPerm_[clientID].find( (*itvec).objID) != clientListPerm_[clientID].end() )
     246      {
     247        // we already have the object in our map
     248        //obj bleibt in liste und permanente prio wird berechnet
     249        clientListPerm_[clientID][(*itvec).objID].objDiffGS = currentGamestateID - clientListPerm_[clientID][(*itvec).objID].objCurGS;
     250//         ((*itpermobj).second).objDiffGS = ((*itpermobj).second).objCurGS - currentGamestateID;
     251//         permprio = clientListPerm_[clientID][(*itproc).first].objValuePerm;
     252//         itpermprio = (permObjPrio_).find((*itproc).first);
     253//         ((*itpermobj).second).objValuePerm = ((*itpermobj).second).objDiffGS * (*itpermprio).second;
     254        continue;//check next objId
     255      }
     256      else
     257      {
     258        // insert the object into clientListPerm
     259        insertinClientListPerm(clientID,*itvec);
     260//         itpermobj=(*itperm).find((*itproc).first)
     261//         ((*itpermobj).second).objDiffGS = ((*itpermobj).second).objCurGS - currentGamestateID;
     262//         itpermprio = (permObjPrio_).find((*itproc).first);
     263//         ((*itpermobj).second).objValuePerm = ((*itpermobj).second).objDiffGS * (*itpermprio).second;
     264        continue;//check next objId
     265      }
     266    }
     267          //end compare listToProcess vs clientListPerm
     268       
     269    //listToProc vs clientListTemp
     270    //TODO: uncomment it again and change some things
     271    /*
     272    std::map<unsigned int, std::map<unsigned int, unsigned int> >::iterator ittemp;
     273    std::map<unsigned int, unsigned int>::iterator ittempgs;
     274    for( itproc=listToProcess_.begin(); itproc != listToProcess_.end();itproc++)
     275    {
     276      ittemp = clientListTemp_->find(currentClientID);
     277      if( ittempgs = (*ittemp).find(currentGamestateID))
     278      {
     279        if((*itproc).first == (*ittempgs).find((*itproc).first))//ja, dann ist objekt schon in der zu sendenden liste-muss nicht nochmal gesendet werden
    191280        {
    192           vector<obj>::iterator itvec;
    193           map<unsigned int,std::map<unsigned int, obj>>::iterator ittemp;
    194           map<unsigned int, obj>::iterator ittempgs;
    195           ittemp = (clientListTemp_).find(currentClientID);
    196           ittempgs = (*ittemp).find(currentGamestateID);
    197           for(itvec=list.begin();itvec!=list.end(),itvec++)
    198           {
    199             ittempgs.insert(itvec);
    200           }
     281          (listToProcess_).erase (itproc);
    201282        }
    202 
    203         /**
    204         *cut
    205         *takes the current vector that has to be returned to the gsmanager and shortens it in criteria of bandwidth of clientID(XY)
    206         */
    207         TrafficControl::cut(std::vector<obj> *list,int targetsize)
    208         {
    209           unsigned int size=0;
    210           vector<obj>::iterator itvec;
    211           itvec = list.begin();
    212           unsigned int i=0;
    213           while(size<targetsize && (itvec!=list.end()))
    214           {
    215             size = size + (*itvec).objSize;//objSize is given in bytes!??
    216             i++;
    217             itvec = list.begin()+i;
    218           }
    219           list.erase(itvec, list.end());
    220         }
    221 
    222 
    223         /**
    224         *evaluateList evaluates whether new obj are there, whether there are things to be updatet and manipulates all this.
    225         */
    226         void TrafficControl::evaluateList(std::vector<obj> *list)
    227         {
    228           copyList(list);
    229        
    230           //now the sorting
    231        
    232           //compare listToProcess vs clientListPerm
    233           //if listToProcess contains new Objects, add them to clientListPerm
    234           std::map<unsigned int, objInfo>::iterator itproc;
    235           std::map<unsigned int, std::map<unsigned int, objInfo> >::iterator itperm;
    236           std::map<unsigned int, objInfo>::iterator itpermobj;
    237           std::map<unsigned int, unsigned int>::iterator itpermprio;
    238           for((*itproc)=(listToProcess_).begin(); itproc != (listToProcess_).end();it++)
    239           {
    240             itperm=(clientListPerm_).find(currentClientID);
    241             if(itpermobj=(*itperm).find((*itproc).first))
    242             {
    243              if(currentGamestateID > ((*itpermobj).second).objCurGS)
    244               {
    245               //obj bleibt in liste und permanente prio wird berechnet
    246                 ((*itpermobj).second).objDiffGS = ((*itpermobj).second).objCurGS - currentGamestateID;
    247                 itpermprio = (permObjPrio_).find((*itproc).first);
    248                 ((*itpermobj).second).objValuePerm = ((*itpermobj).second).objDiffGS * (*itpermprio).second;
    249                 continue;//check next objId
    250               }
    251               else
    252               {
    253                 (listToProcess_).erase(itproc);
    254               }
    255              }
    256              else
    257              {
    258                insertinClientListPerm(currentClientID,(*itproc).first,(*itproc).second);
    259                itpermobj=(*itperm).find((*itproc).first)
    260                ((*itpermobj).second).objDiffGS = ((*itpermobj).second).objCurGS - currentGamestateID;
    261                itpermprio = (permObjPrio_).find((*itproc).first);
    262                ((*itpermobj).second).objValuePerm = ((*itpermobj).second).objDiffGS * (*itpermprio).second;
    263                continue;//check next objId
    264              }
    265             }
    266           //end compare listToProcess vs clientListPerm
    267        
    268         //listToProc vs clientListTemp
    269         map<unsigned int, std::map<unsigned int, unsigned int> >::iterator ittemp;
    270         map<unsigned int, unsigned int>::iterator ittempgs;
    271         for((itproc=listToProcess_).begin(); itproc != (listToProcess_).end();itproc++)
    272         {
    273           ittemp = clientListTemp_->find(currentClientID);
    274           if(ittempgs = (*ittemp).find(currentGamestateID))
    275           {
    276             if((*itproc).first == (*ittempgs).find((*itproc).first))//ja, dann ist objekt schon in der zu sendenden liste-muss nicht nochmal gesendet werden
    277             {
    278               (listToProcess_).erase (itproc);
    279             }
    280             else continue;
    281           }
    282           else continue;
    283         }
    284         //end listToProc vs clientListTemp
    285        
    286         //listToProcess contains obj to send now, and since we give gsmanager the copiedvector and not listToProcess shorten copiedvector therefor too.
    287         vector<obj>::iterator itvec;
    288         for(itvec = copiedVector.begin(); itvec < copiedVector.end(); itvec++)
    289         {
    290           if((listToProcess_).find(itvec->objID))
    291           {
    292             continue;//therefore object wasnt thrown out yet and has to be sent back to gsmanager
    293           }
    294           else
    295           {
    296             copiedVector.remove(itvec);
    297           }
    298         }
    299         //sort copied vector aufgrund der objprioperm in clientlistperm
    300         // use boost bind here because we need to pass a memberfunction to stl sort
    301         sort(copiedvector.begin(), copiedvector.end(), boost::bind(&TrafficControl::priodiffer,this,_1,_2) );
    302         //swappen aufgrund von creator oder ganz rausnehmen!?
    303         for(itvec = copiedVector.begin(); itvec < copiedVector.end(); itvec++)
    304         {
    305           itproc = (listToProcess_).find((*itvec).objID);
    306           if((*itproc).second.objCreatorID)
    307           {
    308           //vor dem child in copiedvector einfügen, wie?
    309             copiedVector.insert(copiedVector.find((*itproc).first),(*itproc).second.objCreatorID);
    310           }
    311           else continue;
    312         }
    313           //end of sorting
    314           //now the cutting, work the same obj out in processobjectlist and copiedvector, compression rate muss noch festgelegt werden.
    315           cut(copiedVector,targetSize);
    316           //diese Funktion updateClientList muss noch gemacht werden
    317           updateClientListTemp(copiedVector);
    318           //end of sorting
    319       }
     283        else
     284          continue;
     285      }
     286      else
     287        continue;
     288    }*/
     289    //end listToProc vs clientListTemp
     290   
     291    //TODO: check whether we need this, cause i don't think so.
     292    //listToProcess contains obj to send now, and since we give gsmanager the copiedvector and not listToProcess shorten copiedvector therefor too.
     293    /*std::vector<obj>::iterator itvec;
     294    for(itvec = copiedVector.begin(); itvec != copiedVector.end(); itvec++)
     295    {
     296      if ( listToProcess_.find(itvec->objID) )
     297      {
     298        continue;//therefore object wasnt thrown out yet and has to be sent back to gsmanager
     299      }
     300      else
     301      {
     302        copiedVector.remove(itvec);
     303      }
     304    }*/
     305    //sort copied vector aufgrund der objprioperm in clientlistperm
     306    // use boost bind here because we need to pass a memberfunction to stl sort
     307    sort(list->begin(), list->end(), boost::bind(&TrafficControl::priodiffer, this, clientID, _1, _2) );
     308    //swappen aufgrund von creator oder ganz rausnehmen!?
     309    for(itvec = list->begin(); itvec != list->end(); itvec++)
     310    {
     311      //TODO: TODO TODO TODO
     312      itproc = (listToProcess_).find((*itvec).objID);
     313      if((*itproc).second.objCreatorID)
     314      {
     315      //vor dem child in copiedvector einfügen, wie?
     316        copiedVector.insert(copiedVector.find((*itproc).first),(*itproc).second.objCreatorID);
     317      }
     318      else continue;
     319    }
     320    //end of sorting
     321    //now the cutting, work the same obj out in processobjectlist and copiedvector, compression rate muss noch festgelegt werden.
     322    cut(copiedVector,targetSize);
     323    //diese Funktion updateClientList muss noch gemacht werden
     324    updateClientListTemp(list);
     325    //end of sorting
     326  }
    320327
    321328

  • code/branches/network/src/network/TrafficControl.h

    r2341 r2348  
    5353  unsigned int objValuePerm;
    5454  unsigned int objValueSched;
     55  objInfo(uint32_t ID, uint32_t creatorID, int32_t curGsID, int32_t diffGsID, uint32_t size, unsigned int prioperm, unsigned int priosched)
     56    { objID = ID; objCreatorID = creatorID; objCurGS = curGsID; objDiffGS = diffGsID; objSize = size; objValuePerm = prioperm; objValueSched = priosched; }
    5557};
    5658
    … …  
    9092    *permanent client list: contains client ids, object ids and objectInfos (in this order)
    9193    */
    92     std::map<unsigned int, std::map<unsigned int, std::vector<objInfo> > > clientListPerm_;
     94    std::map<unsigned int, std::map<unsigned int, objInfo > > clientListPerm_;
    9395    //has to be created with constructor and then needs to be updated by evaluateList().
    9496
    … …  
    100102    *static priority list: contains obj id, basic priority (in this order)
    101103    */
    102     std::map<unsigned int, unsigned int> permObjPrio_;
     104//     std::map<unsigned int, unsigned int> permObjPrio_;
    103105    /**
    104106    *dynamic priority list: contains obj id, dynamic priority (eg scheduled) (in this order)
    105107    */
    106     std::map<unsigned int, unsigned int> schedObjPrio_;
     108//     std::map<unsigned int, unsigned int> schedObjPrio_;
    107109    //end: lists to be used
    108110
    … …  
    118120    std::vector<obj> copiedVector;
    119121
    120     void updateReferenceList(std::map<unsigned int, objInfo> *list);//done
    121     void insertinClientListPerm(unsigned int clientid, unsigned int objid, objInfo objinf);//done
     122//     void updateReferenceList(std::map<unsigned int, objInfo> *list);//done
     123    void insertinClientListPerm(unsigned int clientID, obj objinf);//done
    122124    /**
    123125    *creates listToProcess, which can be easialy compared with other lists
    124126    */
    125     void copyList(std::vector<obj> *list);//done
     127//     void copyList(std::vector<obj> *list);//done
    126128   
    127     void cut(std::vector<obj> *list,int targetsize);
     129    void cut(std::vector<obj> *list, unsigned int targetsize);
    128130    void updateClientListTemp(std::vector<obj> *list);//done
    129131    /**
    130132    *evaluates Data given (vector) and produces result(->Data to be updated)
    131133    */
    132     void evaluateList(std::vector<obj> *list);//done
     134    void evaluateList(unsigned int clientID, std::vector<obj> *list);//done
    133135
    134136  protected:
    … …  
    150152    void deleteObject(unsigned int objectID);                           // this function gets called when an object has been deleted (in order to clean up lists and maps)
    151153   
    152     bool priodiffer(obj i, obj j);
     154    bool priodiffer(uint32_t clientID, obj i, obj j);
    153155};
    154156
Note: See TracChangeset for help on using the changeset viewer.