home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / VSCPPv8.zip / VACPP / IBMCPP / samples / IOC / DSKUSAGE / DSUR.H < prev   
Text File  |  1995-03-15  |  4KB  |  132 lines
  1. /*************************************************************************
  2.   IBM C/C++ Tools Version 3.00 - Collection Class Library
  3.  (C) Copyright IBM Corporation 1992 ,1995, Licensed Program-Property of
  4.  IBM.  All Rights Reserved.  US Government Users Restricted Rights - Use,
  5.  duplication or disclosure restricted by GSA ADP Schedule Contract with
  6.  IBM Corp.
  7.  *************************************************************************/
  8.  
  9. /*-------------------------------------------------------------*\
  10. |  dsur.h  -  Class for Disk Space Usage Records                |
  11. |             This is used by the coding sample for the         |
  12. |             Sorted Map and the Sorted Relation.               |
  13. \*-------------------------------------------------------------*/
  14.  
  15.   #include <fstream.h>
  16.   #include <string.h>
  17.  
  18.   #include <iglobals.h>
  19.  
  20.   const int bufSize = 60;
  21.  
  22.   class DiskSpaceUR    {
  23.      int       blocks;
  24.      char*     name;
  25.  
  26.    public:
  27.      DiskSpaceUR() {}
  28.  
  29.      DiskSpaceUR (DiskSpaceUR const& dsur)  {
  30.         init(dsur);
  31.      }
  32.  
  33.      void operator= (DiskSpaceUR const& dsur)   {
  34.         deInit();
  35.         init(dsur);
  36.      }
  37.  
  38.      DiskSpaceUR (istream& DSURfile)     {
  39.         DSURfile >> *this;
  40.      }
  41.  
  42.      ~DiskSpaceUR () { deInit(); }
  43.  
  44.      IBoolean operator == (DiskSpaceUR const& dsur) const  {
  45.        return (blocks == dsur.blocks)
  46.            && strcmp (name, dsur.name) == 0;
  47.      }
  48.  
  49.  
  50.      friend istream& operator >> (istream& DSURfile,
  51.                                   DiskSpaceUR& dsur)     {
  52.          DSURfile >> dsur.blocks;
  53.  
  54.          char temp[bufSize];
  55.          DSURfile.get(temp, bufSize);
  56.  
  57.          if (DSURfile.good())  {
  58.                                 // Remove leading tabs and blanks
  59.             for (int cnt=0;
  60.                  (temp[cnt] == '\t') || (temp[cnt] == ' ');
  61.                  cnt++) {}
  62.             dsur.name = new char[strlen(temp+cnt)+1];
  63.             strcpy(dsur.name, temp+cnt);
  64.          }
  65.          else   {
  66.             dsur.setInvalid();
  67.             dsur.name = new char[1];
  68.             dsur.name[0] = '\0';
  69.          }
  70.  
  71.          return DSURfile;
  72.      }
  73.  
  74.      friend ostream& operator << (ostream& outstream,
  75.                                   DiskSpaceUR& dsur)     {
  76.          outstream.width(bufSize);
  77.          outstream.setf(ios::left, ios::adjustfield);
  78.          outstream << dsur.name;
  79.  
  80.          outstream.width(9);
  81.          outstream.setf(ios::right, ios::adjustfield);
  82.          outstream << dsur.blocks;
  83.  
  84.          return outstream;
  85.      }
  86.  
  87.      inline int const& space () const {return blocks;}
  88.  
  89.      inline char* const& id () const {return name;}
  90.  
  91.      inline IBoolean isValid () const {return (blocks > 0);}
  92.  
  93.    protected:
  94.  
  95.      inline void init (DiskSpaceUR const& dsur)     {
  96.         blocks = dsur.blocks;
  97.         name = new char[strlen(dsur.name) + 1];
  98.         strcpy(name, dsur.name);
  99.      }
  100.  
  101.      inline void deInit() {  delete[] name;  }
  102.  
  103.      inline void setInvalid () { blocks = -1;}
  104.   };
  105.  
  106.  
  107.      // Key access on name
  108.   inline  char* const& key (DiskSpaceUR const& dsur)  {
  109.      return dsur.id();
  110.   }
  111.  
  112.      // Key access on space used
  113.      // Since we can not have two key functions with same args
  114.      // in global name space, we need to use an operations class.
  115.   #include <istdops.h>
  116.      // We can inherit all from the default operations class
  117.      // and then define just the key access function ourselfes.
  118.      // We can not use StdKeyOps here, because the in turn
  119.      // use the key function in global name space, which is
  120.      // already defined for keys of type char* above.
  121.   class DSURBySpaceOps :  public IStdMemOps,
  122.                           public IStdAsOps< DiskSpaceUR >,
  123.                           public IStdEqOps< DiskSpaceUR >    {
  124.     public:
  125.        IStdCmpOps < int > keyOps;
  126.  
  127.      // Key Access
  128.        int const& key (DiskSpaceUR const& dsur) const
  129.        { return dsur.space(); }
  130.   };
  131.  
  132.