client-int-int.cc

Fichier texte: [client-int-int.cc]

// -*- coding: latin-1 -*-

#include "libsocket.hh"
#include "proto-int-int.hh"
#include <cstddef>
#include <iostream>
#include <cstdlib>

using namespace std;

//==============================================================================
// class Reply
//
// Un objet Reply permet de représenter toutes les réponses possibles à nos
// requêtes.
//
// Attributs:
//     status: le status de la réponse
//     k     : si status==OK1, c'est la valeur retournée
//             si status==OKN, c'est la taille de l'attribut table
//             sinon n'est pas utilisé
//     table : si status==OKN, c'est un pointeur vers un tableau de taille k
//                             contenant les valeurs retournées
//             sinon n'est pas utilisé et vaut NULL
//==============================================================================

class Reply
{
public:
  status_t status;
  int k;
  int * table;

  Reply();
  void clear();
};

//------------------------------------------------------------------------------
// constructeur pour initialiser les attributs
//------------------------------------------------------------------------------

Reply::Reply() ???

//------------------------------------------------------------------------------
// clear() doit remettre les attributs à "zéro".  Il faut en particulier qu'il
// libère la table si elle a été créée.   Cette méthode est utile lorsqu'on veut
// réutiliser le même objet Reply pour obtenir et traiter successivement les
// réponses à plusieurs requêtes.
//------------------------------------------------------------------------------

void Reply::clear()
{
  ???
}

//------------------------------------------------------------------------------
// On veut que (cout << reply << endl) affiche quelque chose de facilement
// intelligible.  Ceci nous permettra d'afficher les réponses reçues.
//------------------------------------------------------------------------------

ostream& operator << (ostream& ostr, Reply& reply)
{
  ???
}

//==============================================================================
// class ClientIntInt
//
// Il faut bien comprendre que l'envoi d'une requête et la réception d'une
// réponse sont deux opérations.  On peut très bien envoyer plusieurs requêtes
// d'un coup, puis lire leurs réponses ensuite si on veut.
//
// L'envoi d'une requête est réalisé par les méthodes send_XXX(...).  La
// réception d'une réponse est réalisée par la méthode recv(Reply&).
//==============================================================================

class ClientIntInt : public Client
{
public:
  ClientIntInt();
  virtual int interaction();
protected:
  int send_QUIT();
  int send_DEL(int i);
  int send_PUT(int i, int k);
  int send_GET(int i);
  int send_PUTN(int n, int* is, int* ks);
  int send_GETN(int n, int* is);

  int recv(Reply& reply);
};

//------------------------------------------------------------------------------
// constructeur
//------------------------------------------------------------------------------

ClientIntInt::ClientIntInt() ???

//------------------------------------------------------------------------------
// recv(Reply& reply)
//
// Cette méthode réalise la réception d'une réponse.  On lui passe un objet
// Reply, et elle remplit les champs de cet objet selon la réponse qui est
// reçue.
//------------------------------------------------------------------------------

int ClientIntInt::recv(Reply& reply)
{
  ???
}

//------------------------------------------------------------------------------
// envoie la requête QUIT()
//------------------------------------------------------------------------------

int ClientIntInt::send_QUIT()
{
  ???
}

//------------------------------------------------------------------------------
// envoie la requête DEL(i)
//------------------------------------------------------------------------------

int ClientIntInt::send_DEL(int i)
{
  ???
}

//------------------------------------------------------------------------------
// envoie la requête PUT(i,k)
//------------------------------------------------------------------------------

int ClientIntInt::send_PUT(int i, int k)
{
  ???
}

//------------------------------------------------------------------------------
// envoie la requête GET(i)
//------------------------------------------------------------------------------

int ClientIntInt::send_GET(int i)
{
  ???
}

//------------------------------------------------------------------------------
// envoie la requête PUTN(n,i1,k1,...,in,kn)
//
// Pour que la méthode soit plus facile à utiliser dans un programme, on lui
// passe, outre "n", un tableau "is" contenant {i1,...,in} et un tableau "ks"
// contenant {k1,...,kn}
//------------------------------------------------------------------------------

int ClientIntInt::send_PUTN(int n, int* is, int* ks)
{
  ???
}

//------------------------------------------------------------------------------
// envoie la requête GETN(n,i1,...,in)
//
// On passe à cette méthode "n" et un tableau "is" contenant {i1,...,in}
//------------------------------------------------------------------------------

int ClientIntInt::send_GETN(int n, int* is)
{
  ???
}

//==============================================================================
// L'interaction avec le serveur.  Pour tester, vous lui ferez faire la
// séquence d'opérations suivante:
//
//     PUT(3,77)
//     PUT(-1,99)
//     lire et afficher 2 réponses
//
//     GET(3)
//     GET(-1)
//     GET(2)
//
//     lire et afficher 3 réponses
//
//     PUTN(3, 0,90, 1,91, 2,92)
//     PUTN(3, 3,190, 4,191, 5,192)
//     GETN(4, 0,1,2,3)
//     lire et afficher 3 réponses
//
//     DEL(3)
//     DEL(-1)
//     GET(3)
//     lire et afficher 3 réponses
//
//     QUIT()
//     lire et afficher 1 réponse
//
// vous testerez cela sur un serveur invoqué avec les paramêtres suivants:
//
//     server-int-int 8080 5
//
// c'est à dire avec une capacité de 5.
//==============================================================================

int ClientIntInt::interaction()
{
  ???
}

//==============================================================================
// client-int-int HOST PORT
//==============================================================================

int main(int argc, char** argv)
{
  ???
}