Changeset 196


Ignore:
Timestamp:
05/18/11 17:47:46 (10 years ago)
Author:
hozdoba
Message:
 
Location:
XMLIO_V2/dev/dev_rv
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • XMLIO_V2/dev/dev_rv/Makefile.wk

    r190 r196  
    3131 
    3232ifeq ($(HOSTNAME), platine1076) 
    33         CSUITE = intel 
     33        CSUITE = gnu 
    3434        PFORME = platine-wk 
    3535endif 
  • XMLIO_V2/dev/dev_rv/src/xmlio/buffer.cpp

    r157 r196  
    2121      { 
    2222         this->idata = data; 
     23      } 
     24       
     25      CBuffer::CBuffer(const CBuffer & buffer) 
     26         : size(buffer.size), delIdata(true) 
     27      { 
     28         this->idata = new char[size](); 
     29         std::copy (buffer.idata, buffer.idata+size, this->idata); 
     30      } 
     31       
     32      CBuffer::CBuffer(const CBuffer * const buffer) 
     33         : size(buffer->size), delIdata(true) 
     34      { 
     35         this->idata = new char[size](); 
     36         std::copy (buffer->idata, buffer->idata+size, this->idata);        
    2337      } 
    2438 
     
    198212         ofs.close(); 
    199213      } 
    200  
     214       
     215      //--------------------------------------------------------------- 
     216       
    201217      void CBuffer::printToBinaryStream (StdOStream & ostr) 
    202       {  ostr.write (this->getData(), this->getSize()); } 
    203  
    204  
    205       StdSize CBuffer::getNextDataPosition(StdSize position) const 
     218      {   
     219         ostr.write (this->getData(), this->getSize());  
     220      } 
     221       
     222      //--------------------------------------------------------------- 
     223       
     224      StdSize CBuffer::getNextDataPosition(StdSize position) 
    206225      { 
    207226         CBufferData  bufdata; 
     227         this->updateBufferData(position); 
    208228         this->getBufferData(bufdata, position); 
    209229         return (bufdata.size + bufdata.position); 
     
    214234      template <> 
    215235         StdSize CBuffer::getRequestedSize(StdString data) const 
    216       { return (DATA_HEADER_SIZE + data.size() * sizeof (char)); } 
    217  
     236      {  
     237         return (DATA_HEADER_SIZE + data.size() * sizeof (char));  
     238      } 
     239       
     240      //--------------------------------------------------------------- 
     241       
     242      void CBuffer::updateBufferData(StdSize position) 
     243      { 
     244         CBufferData bufdata; 
     245         this->getBufferData(bufdata, position); 
     246         bufdata.position = position + DATA_HEADER_SIZE; 
     247         this->setBufferData(bufdata, position); 
     248      } 
     249       
    218250      ///-------------------------------------------------------------- 
    219251 
  • XMLIO_V2/dev/dev_rv/src/xmlio/buffer.hpp

    r179 r196  
    4141               inline StdSize getRequestedSize(ARRAY(T, 1) data) const; 
    4242 
    43             StdSize getNextDataPosition(StdSize position) const; 
     43            StdSize getNextDataPosition(StdSize position); 
    4444 
    4545         //-------------------------------------------------------------- 
     
    7979 
    8080            virtual void clear(void) = 0; 
     81            void updateBufferData(StdSize position); 
    8182 
    8283            /// Sortie fichier binaire /// 
     
    9697            CBuffer(char * data, StdSize size); 
    9798            explicit CBuffer(StdSize size); 
    98             CBuffer(const CBuffer & buffer);         // Not implemented yet. 
    99             CBuffer(const CBuffer * const buffer);   // Not implemented yet. 
     99            CBuffer(const CBuffer & buffer); 
     100            CBuffer(const CBuffer * const buffer); 
    100101 
    101102            /// Accesseurs protégés /// 
     
    108109 
    109110            /// Mutateurs protégés /// 
    110  
    111111            template <class T> 
    112112               inline void setData(const T & data, StdSize position); 
  • XMLIO_V2/dev/dev_rv/src/xmlio/buffer_list.cpp

    r178 r196  
    77      /// ////////////////////// Définitions ////////////////////// /// 
    88      CBufferList::CBufferList(MPIComm com_client_server) 
    9          : SuperClass() 
     9         : SuperClass(CMPIManager::GetCommSize(com_client_server) - 1) 
    1010         , com_client_server(com_client_server) 
    1111         , nbbuffer(CMPIManager::GetCommSize(com_client_server) - 1) 
    12       { 
    13          for (StdSize i = 0; i < this->nbbuffer; i++) 
    14             SuperClass::push_back(BufferType(BUFFER_SERVER_SIZE)); 
    15       } 
     12      { /* Ne rien faire de plus */ } 
    1613 
    1714      CBufferList::~CBufferList(void) 
     
    2825      } 
    2926 
    30       void CBufferList::recvRequests(void) 
     27      bool CBufferList::recvRequests(void) 
    3128      { 
    3229         while (!this->hasRequests()) 
     
    3835                  StdSize size = CMPIManager::GetReceivedDataSize(com_client_server, i); 
    3936                  if (SuperClass::operator[](i-1).isAvailable(size)) 
     37                  { 
     38                     std::cout << "b:" << i << std::endl; 
    4039                     CMPIManager::ReceiveCircularBuffer 
    4140                        (com_client_server, i, SuperClass::operator[](i-1)); 
     41                  } 
     42                  else 
     43                  { 
     44                     DEBUG ("Impossible d'écrire dans le tampon " << i  
     45                             << " (Taille requise : " << size << " octets," 
     46                             << " Taille du buffer circulaire : " 
     47                             << SuperClass::operator[](i-1).getSize() << " octets)"); 
     48                  } 
    4249               } 
    4350            } 
    4451         } 
     52         std::cout << "lol" << std::endl; 
     53         return (true); 
    4554      } 
    4655 
    47       std::vector<CLinearBuffer> CBufferList::getRequests(void) 
     56      void CBufferList::getRequests(std::vector<CLinearBuffer> & lbuffer) 
    4857      { 
    49          std::vector<CLinearBuffer> retvalue; 
    5058         for (StdSize i = 0; i < this->nbbuffer; i++) 
    51             retvalue.push_back(SuperClass::operator[](i).getNextRequest()); 
    52          return (retvalue); 
     59            lbuffer.push_back(SuperClass::operator[](i).getNextRequest()); 
    5360      } 
    5461 
  • XMLIO_V2/dev/dev_rv/src/xmlio/buffer_list.hpp

    r157 r196  
    3333 
    3434            /// Traitement /// 
    35             void recvRequests(void); 
     35            bool recvRequests(void); 
    3636 
    3737            /// Accesseurs /// 
    3838            StdSize getNumberOfBuffers(void) const; 
    39             std::vector<CLinearBuffer> getRequests(void); 
     39            void getRequests(std::vector<CLinearBuffer> & lbuffer); 
    4040 
    4141            /// Destructeur /// 
  • XMLIO_V2/dev/dev_rv/src/xmlio/buffer_pair.cpp

    r178 r196  
    2020      bool CBufferPair::mustBeSent(void) 
    2121      { 
    22          if (((currentBuffer == 0) && (first.getUsedSize() != 0) && 
    23               ((second_request == -1) || CMPIManager::Test (second_request))) || 
    24              ((currentBuffer == 1) && (second.getUsedSize() != 0) && 
    25               ((first_request == -1) || CMPIManager::Test (first_request)))) 
     22         if (((currentBuffer  ==  0) && (first.getUsedSize() != 0) && 
     23             ((second_request == -1) || CMPIManager::Test (second_request))) || 
     24             ((currentBuffer  == 1) && (second.getUsedSize() != 0) && 
     25             ((first_request == -1) || CMPIManager::Test (first_request)))) 
    2626            return (true); 
    2727         return (false); 
  • XMLIO_V2/dev/dev_rv/src/xmlio/buffer_pair.hpp

    r191 r196  
    6666                                          A1 * arg1, A2 * arg2, A3 * arg3, A4 * arg4) 
    6767      { 
    68          if (this->mustBeSent()) this->sendCurrentBuffer();        
     68         if (this->mustBeSent())  
     69            this->sendCurrentBuffer(); 
     70 
    6971            
    7072         CLinearBuffer & cbuffer = this->getCurrentBuffer(); 
  • XMLIO_V2/dev/dev_rv/src/xmlio/circular_buffer.cpp

    r152 r196  
    99      /// ////////////////////// Définitions ////////////////////// /// 
    1010      CCircularBuffer::CCircularBuffer(StdSize size) 
    11          : SuperClass(size), p_write(0), p_read(0), p_unused(0), nbrequest(0) 
     11         : SuperClass(size) 
     12         , p_write(0), p_read(0), p_unused(0) 
     13         , nbrequest(0) 
     14      { /* Ne rien faire de plus */ } 
     15 
     16      CCircularBuffer::CCircularBuffer(const CCircularBuffer & cbuffer) 
     17         : SuperClass(cbuffer) 
     18         , p_write(cbuffer.p_write), p_read(cbuffer.p_read), p_unused(cbuffer.p_unused) 
     19         , nbrequest(cbuffer.nbrequest) 
     20      { /* Ne rien faire de plus */ } 
     21       
     22      CCircularBuffer::CCircularBuffer(const CCircularBuffer * const cbuffer) 
     23         : SuperClass(cbuffer) 
     24         , p_write(cbuffer->p_write), p_read(cbuffer->p_read), p_unused(cbuffer->p_unused) 
     25         , nbrequest(cbuffer->nbrequest) 
    1226      { /* Ne rien faire de plus */ } 
    1327 
     
    4559         return (currsize); 
    4660      } 
    47  
     61       
     62      //------------------------------------------------------------- 
     63       
    4864      CLinearBuffer CCircularBuffer::getNextRequest(void) 
    4965      { 
     
    7490         return (SuperClass::getData(this->prepareNextDataPosition(data_size))); 
    7591      } 
    76  
     92       
     93      //------------------------------------------------------------- 
    7794 
    7895      StdSize CCircularBuffer::prepareNextDataPosition(StdSize data_size) 
     
    102119            this->clear(); 
    103120      } 
    104  
     121       
     122      //------------------------------------------------------------- 
     123       
    105124      void CCircularBuffer::movePWrite(StdSize data_size) 
    106125      { 
     
    128147 
    129148      bool CCircularBuffer::hasRequest(void) const 
    130       { return (this->nbrequest != 0); } 
    131  
     149      {  
     150         return (this->nbrequest != 0);  
     151      } 
     152       
     153      //------------------------------------------------------------- 
     154       
    132155      bool CCircularBuffer::isAvailable(StdSize data_size) const 
    133156      { 
     
    146169         ofs.close(); 
    147170      } 
    148  
     171       
     172      //------------------------------------------------------------- 
     173       
    149174      void CCircularBuffer::printToTextStream (StdOStream & ostr) 
    150175      { 
     
    184209      void CCircularBuffer::updateNbRequests(StdSize data_begin, StdSize data_end) 
    185210      { 
    186          StdSize position = data_begin; 
     211         StdSize position = data_begin, i = 0; 
    187212         while (position != data_end) 
    188213         { 
     214            i++; 
    189215            this->nbrequest++; 
    190216            position = SuperClass::getNextDataPosition(position); // manager id 
  • XMLIO_V2/dev/dev_rv/src/xmlio/circular_buffer.hpp

    r152 r196  
    2121 
    2222            /// Construteurs /// 
    23             explicit CCircularBuffer(StdSize size); 
    24             CCircularBuffer(const CCircularBuffer & cbuffer);         // Not implemented yet. 
    25             CCircularBuffer(const CCircularBuffer * const cbuffer);   // Not implemented yet. 
     23            explicit CCircularBuffer(StdSize size = BUFFER_SERVER_SIZE); 
     24            CCircularBuffer(const CCircularBuffer & cbuffer); 
     25            CCircularBuffer(const CCircularBuffer * const cbuffer); 
    2626 
    2727            /// Mutateurs /// 
  • XMLIO_V2/dev/dev_rv/src/xmlio/client.cpp

    r194 r196  
    4242                                       CLinearBuffer::NULL_ARG); 
    4343      // Pas d'argument à ajouter. 
     44      this->bpair.sendCurrentBuffer();  
    4445   } 
    4546    
  • XMLIO_V2/dev/dev_rv/src/xmlio/linear_buffer.cpp

    r178 r196  
    99      /// ////////////////////// Définitions ////////////////////// /// 
    1010      CLinearBuffer::CLinearBuffer(char * data, StdSize size) 
    11          : SuperClass(data, size), p_write(size) 
     11         : SuperClass(data, size), bdata(), p_write(size) 
    1212      { this->computeBufferData(); } 
    1313 
    1414      CLinearBuffer::CLinearBuffer(StdSize size) 
    15          : SuperClass(size), p_write(0) 
    16       { /* Ne rien faire de plus */ } 
    17  
     15         : SuperClass(size), bdata(), p_write(0) 
     16      { /* Ne rien faire de plus */ } 
     17       
     18      CLinearBuffer::CLinearBuffer(const CLinearBuffer & lbuffer) 
     19         : SuperClass(lbuffer), bdata(lbuffer.bdata), p_write(lbuffer.p_write) 
     20      { /* Ne rien faire de plus */ } 
     21       
     22      CLinearBuffer::CLinearBuffer(const CLinearBuffer * const lbuffer) 
     23         : SuperClass(lbuffer), bdata(lbuffer->bdata), p_write(lbuffer->p_write)       
     24      { /* Ne rien faire de plus */ } 
     25       
    1826      CLinearBuffer::~CLinearBuffer(void) 
    1927      { /* Ne rien faire de plus */ } 
     
    121129 
    122130      StdSize CLinearBuffer::getNumberOfStoredData(void) const 
    123       { return (this->bdata.size()); } 
    124  
     131      {  
     132         return (this->bdata.size());  
     133      } 
     134       
     135      //--------------------------------------------------------------- 
     136       
    125137      std::vector<StdSize> CLinearBuffer::getPositionsOfStoredData(void) const 
    126138      { 
     
    137149         return (retvalue); 
    138150      } 
    139  
     151       
     152      //--------------------------------------------------------------- 
     153       
    140154      std::vector<StdSize> CLinearBuffer::getSizesOfStoredData(void) const 
    141155      { 
     
    151165         return (retvalue); 
    152166      } 
    153  
     167       
     168      //--------------------------------------------------------------- 
     169       
    154170      std::vector<std::pair<CBuffer::CBufferDataType, bool> > 
    155171         CLinearBuffer::getTypesOfStoredData(void) const 
     
    179195         { 
    180196            bdata.push_back(this->p_write); 
     197            SuperClass::updateBufferData(this->p_write); 
    181198            SuperClass::getBufferData(bufdata, this->p_write); 
    182199            this->p_write = (bufdata.size + bufdata.position); 
  • XMLIO_V2/dev/dev_rv/src/xmlio/linear_buffer.hpp

    r152 r196  
    2828            /// Construteurs /// 
    2929 
    30             explicit CLinearBuffer(StdSize size); 
     30            explicit CLinearBuffer(StdSize size = BUFFER_CLIENT_SIZE); 
    3131            CLinearBuffer(char * data, StdSize size); 
    32             CLinearBuffer(const CLinearBuffer & lbuffer);         // Not implemented yet. 
    33             CLinearBuffer(const CLinearBuffer * const lbuffer);   // Not implemented yet. 
     32            CLinearBuffer(const CLinearBuffer & lbuffer); 
     33            CLinearBuffer(const CLinearBuffer * const lbuffer); 
    3434 
    3535            /// Accesseurs /// 
  • XMLIO_V2/dev/dev_rv/src/xmlio/main_server.cpp

    r190 r196  
    55#include "group_template_impl.hpp" 
    66 
     7#include "client.hpp" 
     8#include "server.hpp" 
     9 
    710#include "fake.hpp" 
    811 
     
    1013int main(int argc, char ** argv, char ** UNUSED(env)) 
    1114{ 
    12    /*try 
     15   try 
    1316   { 
    14       //comm::CMPIManager::Initialise(&argc, &argv); // < seulement en mode connecté 
     17      comm::CMPIManager::Initialise(&argc, &argv); // < seulement en mode connecté 
     18       
     19      if (comm::CMPIManager::IsMaster(comm::CMPIManager::GetCommWorld())) 
     20      { 
     21         comm::CServer server(comm::CMPIManager::GetCommWorld()); 
     22         server.run(); 
     23         std::cout << "fin serveur" << std::endl; 
     24          
     25      } 
     26      else 
     27      { 
     28         comm::CClient client(comm::CMPIManager::GetCommWorld()); 
     29         client.initialize(); 
     30         client.finalize(); 
     31      } 
     32       
     33      comm::CMPIManager::Finalize(); // < seulement en mode connecté 
     34       
    1535      
    16       CXIOSManager::Initialise(CXIOSManager::CLIENT_SERVER, &argc, &argv); 
     36      /*CXIOSManager::Initialise(CXIOSManager::CLIENT_SERVER, &argc, &argv); 
    1737       
    1838      CXIOSManager::AddClient("nemo"    , 4, 2, &nemo_fake_entry); 
     
    2040      //CXIOSManager::AddClient("lmdz"    , 4, 2, &lmdz_fake_entry); 
    2141      CXIOSManager::RunClientServer(comm::CMPIManager::GetCommWorld()); 
    22       CXIOSManager::Finalize(); 
     42      CXIOSManager::Finalize();*/ 
    2343       
    24       //comm::CMPIManager::Finalize(); // < seulement en mode connecté 
     44       
    2545 
    2646   } 
     
    3050      CMPIManager::Finalize(); 
    3151      return (EXIT_FAILURE); 
    32    }*/ 
     52   } 
    3353   return (EXIT_SUCCESS); 
    3454} 
  • XMLIO_V2/dev/dev_rv/src/xmlio/manager/mpi_manager.cpp

    r185 r196  
    239239         StdSize data_begin = buff.prepareNextDataPosition(data_size); 
    240240         CMPIManager::Receive(comm, src_rank, buff.getData(data_begin)); 
    241  
    242241         buff.updateNbRequests(data_begin, data_begin + data_size); 
    243242      } 
  • XMLIO_V2/dev/dev_rv/src/xmlio/node/domain.cpp

    r187 r196  
    201201               << " vérifiez les valeurs nj, nj_glo, jbegin, jend") ; 
    202202   } 
    203  
    204203 
    205204   //---------------------------------------------------------------- 
  • XMLIO_V2/dev/dev_rv/src/xmlio/server.cpp

    r190 r196  
    44namespace comm { 
    55 
     6   /// ////////////////////// Définitions ////////////////////// /// 
     7    
     8   CServer::CServer(MPIComm comm_client_server) 
     9      : blist(comm_client_server) 
     10   { /* Ne rien faire de plus */ }   
     11         
     12   CServer::~CServer(void) 
     13   { /* Ne rien faire de plus */ }  
     14    
     15   ///-------------------------------------------------------------- 
     16    
     17   const CBufferList & CServer::getBufferList(void) const  
     18   { 
     19      return (this->blist); 
     20   }    
     21    
     22   //--------------------------------------------------------------- 
     23    
     24   void CServer::run(void) 
     25   { 
     26      while (this->blist.recvRequests()) 
     27      { 
     28         long int managerId = 0, methodId  = 0, nbargs  = 0; 
     29         long int managerId_= 0, methodId_ = 0, nbargs_ = 0; 
     30         std::vector<CLinearBuffer> lbuffer; 
     31         this->blist.getRequests(lbuffer); 
     32         for (StdSize i = 0; i < lbuffer.size(); i++) 
     33         { 
     34            lbuffer[i].getRequestInfos(0, managerId, methodId, nbargs); 
     35            if (((managerId_ != managerId) || (methodId_ != methodId) || (nbargs_ != nbargs)) && (i != 0 )) 
     36            { 
     37               /*std::cout << managerId_ << "<->" << managerId << std::endl 
     38                           << methodId_  << "<->" << methodId  << std::endl 
     39                           << nbargs_    << "<->" << nbargs    << std::endl;*/ 
     40               ERROR("CServer::run(void)", << "[" << i << "] Les requêtes ne sont pas synchronisées !"); 
     41            } 
     42            managerId_ = managerId; 
     43            methodId_  = methodId; 
     44            nbargs_    = nbargs; 
     45         } 
     46             
     47         if (managerId == 0) 
     48         { 
     49            switch(methodId) 
     50            { 
     51               case (0) : 
     52                  this->initialize(); 
     53                  continue; 
     54               case (1) : 
     55                  this->finalize(); 
     56                  return; 
     57               default  : 
     58                  ERROR("CServer::run(void)",  
     59                     << "[ managerId = " << managerId << ", " 
     60                     << "[ methodId = "  << methodId  << ", " 
     61                     << "[ nbargs = "    << nbargs    << "] " 
     62                     << " Methode inconnue !"); 
     63            } 
     64         } 
     65         if (managerId == 1) 
     66         { 
     67            switch(methodId) 
     68            { 
     69               case (0) : 
     70                  this->setContext(lbuffer); 
     71                  continue; 
     72               case (1) : 
     73                  this->updateCalendar(lbuffer); 
     74                  continue; 
     75               default  : 
     76                  ERROR("CServer::run(void)",  
     77                     << "[ managerId = " << managerId << ", " 
     78                     << "[ methodId = "  << methodId  << ", " 
     79                     << "[ nbargs = "    << nbargs    << "] " 
     80                     << " Methode inconnue !"); 
     81            } 
     82         } 
     83         if (managerId == 2) 
     84         { 
     85            switch(methodId) 
     86            { 
     87               case (0) : 
     88                  this->writeData(lbuffer, 4); 
     89                  continue; 
     90               case (1) : 
     91                  this->writeData(lbuffer, 8); 
     92                  continue; 
     93               default  : 
     94                  ERROR("CServer::run(void)",  
     95                     << "[ managerId = " << managerId << ", " 
     96                     << "[ methodId = "  << methodId  << ", " 
     97                     << "[ nbargs = "    << nbargs    << "] " 
     98                     << " Methode inconnue !"); 
     99            } 
     100         } 
     101         ERROR("CServer::run(void)",  
     102                << "[ managerId = " << managerId << ", " 
     103                << "[ methodId = "  << methodId  << ", " 
     104                << "[ nbargs = "    << nbargs    << "] " 
     105                << " Methode inconnue !"); 
     106      } 
     107   } 
    6108 
    7  
     109   //-------------------------------------------------------------- 
     110    
     111   void CServer::initialize(void) // manager 0, method 0 
     112   { 
     113      std::cout << "initialize called " << std::endl; 
     114   } 
     115    
     116   //-------------------------------------------------------------- 
     117    
     118   void CServer::finalize(void) // manager 0, method 1 
     119   { 
     120      std::cout << "finalize called " << std::endl; 
     121   } 
     122    
     123    
     124   //-------------------------------------------------------------- 
     125              
     126   void CServer::setContext(const std::vector<CLinearBuffer> & buffer) // manager 1, method 0 
     127   { 
     128      std::cout << "setContext called " << std::endl; 
     129   } 
     130    
     131   //-------------------------------------------------------------- 
     132    
     133   void CServer::updateCalendar(const std::vector<CLinearBuffer> & buffer) // manager 1, method 1 
     134   { 
     135      std::cout << "updateCalendar called " << std::endl; 
     136   } 
     137    
     138   //-------------------------------------------------------------- 
     139          
     140   void CServer::writeData(const std::vector<CLinearBuffer> & buffer, int prec)  // manager 2, method 0 - 1 
     141   { 
     142      std::cout << "writeData called " << std::endl; 
     143   } 
     144   
     145   ///-------------------------------------------------------------- 
     146    
     147    
    8148} // namespace comm 
    9149} // namespace xmlioserver 
  • XMLIO_V2/dev/dev_rv/src/xmlio/server.hpp

    r190 r196  
    44/// xmlioserver headers /// 
    55#include "xmlioserver_spl.hpp" 
     6#include "mpi_manager.hpp" 
     7#include "buffer_list.hpp" 
     8#include "array.hpp" 
    69 
    710namespace xmlioserver { 
    811namespace comm { 
    912 
    10  
     13   /// ////////////////////// Déclarations ////////////////////// /// 
     14    
     15   class CServer 
     16   { 
     17      public : 
     18       
     19         /// Constructeurs /// 
     20         CServer(MPIComm comm_client_server); 
     21                 
     22         /// Destructeur /// 
     23         ~CServer(void); 
     24          
     25         void run(void); 
     26          
     27      protected :  
     28       
     29         /// Accesseur /// 
     30         const CBufferList & getBufferList(void) const; 
     31          
     32      public : 
     33       
     34         /// Appels distants///    
     35         void initialize(void); // manager 0, method 0 
     36         void finalize(void);   // manager 0, method 1 
     37              
     38         void setContext(const std::vector<CLinearBuffer> & buffer);     // manager 1, method 0 
     39         void updateCalendar(const std::vector<CLinearBuffer> & buffer); // manager 1, method 1 
     40          
     41         void writeData(const std::vector<CLinearBuffer> & buffer, int prec); // manager 2, method 0 - 1 
     42       
     43      private : 
     44       
     45         /// Propriété privée /// 
     46         CBufferList blist; 
     47       
     48   }; // class CServer   
    1149 
    1250} // namespace comm 
Note: See TracChangeset for help on using the changeset viewer.