src/external/3rd/library/perforce/include/handler.h

   1 /*
   2  * Copyright 1995, 1996 Perforce Software.  All rights reserved.
   3  *
   4  * This file is part of Perforce - the FAST SCM System.
   5  */
   6
   7 /*
   8  * handler.h - last chance handlers to keep track of loose objects
   9  *
  10  * Handlers provide a way of associating an object with a string so
  11  * context can be retained across RPC dispatched function calls.
  12  * This is used for file transfers, which are carried out in a series
  13  * of RPC calls.  The sender picks a handle name and then uses that
  14  * consistenly during the transfer.  The receiver uses the provided handle
  15  * name to stash and retrieve the object the represents the open file.
  16  *
  17  * Handlers also provide a means of tracking across objects.  If any
  18  * object encounters an error, it can mark the handle so that a subsequent
  19  * call to AnyErrors() can report so.
  20  *
  21  * Public classes:
  22  *
  23  *      Handlers - a list of LastChance objects
  24  *      LastChance - a virtual base class that gets deleted with the
  25  *                      handlers.
  26  */
  27
  28 class LastChance;
  29
  30 struct Handler {
  31             StrBuf      name;
  32             int         anyErrors;
  33             LastChance  *lastChance;
  34 } ;
  35
  36 class LastChance {
  37
  38     public:
  39                         LastChance()
  40                         {
  41                             handler = 0;
  42                             isError = 0;
  43                         }
  44
  45         virtual         ~LastChance();
  46
  47         void            Install( Handler *h )
  48                         {
  49                             handler = h;
  50                             handler->lastChance = this;
  51                         }
  52
  53         void            SetError()
  54                         {
  55                             isError = 1;
  56                         }
  57
  58         void            SetError( Error *e )
  59                         {
  60                             if( e->Test() ) isError = 1;
  61                         }
  62
  63         int             IsError()
  64                         {
  65                             return isError;
  66                         }
  67
  68     private:
  69         Handler         *handler;
  70         int             isError;
  71
  72 } ;
  73
  74 const int maxHandlers = 3;
  75
  76 class Handlers {
  77
  78     public:
  79                         Handlers();
  80                         ~Handlers();
  81
  82         void            Install( const StrPtr *name,
  83                                 LastChance *lastChance,
  84                                 Error *e );
  85
  86         LastChance *    Get( const StrPtr *name, Error *e );
  87
  88         int             AnyErrors( const StrPtr *nane );
  89
  90     private:
  91
  92         int             numHandlers;
  93         Handler         table[maxHandlers];
  94         Handler         *Find( const StrPtr *handle, Error *e = 0 );
  95 } ;
  96