---

system.hh

/*
*  Name:      system.hh
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Base operating system
*  Date:      $Date: 2003/08/08 23:30:34 $
*  Revision:  $Revision: 1.2 $
*
*  Copyright (C) 1994-2002  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  This program is free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  This program is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

#ifndef _MPCL_SYSTEM_SYSTEM__
#define _MPCL_SYSTEM_SYSTEM__

#include <cstdlib>
#include <vector>
#include "../text/string.hh"
#include "defs.hh"


namespace mpcl
{

  namespace system
  {

    using std::string;
    using std::vector;
    using text::TString;

    class ISystem
    {
    
      public:

        enum ELogLevel
        {
          eEmerg   , 
          eAlert   , 
          eCrit    , 
          eErr     , 
          eWarning , 
          eNotice  , 
          eInfo    , 
          eDebug     
        };

        enum ELogFacility
        {
          eAuthPriv ,  
          eCron     ,  
          eDaemon   ,  
          eKern     ,  
          eLocal0   ,  
          eLocal1   ,  
          eLocal2   ,  
          eLocal3   ,  
          eLocal4   ,  
          eLocal5   ,  
          eLocal6   ,  
          eLocal7   ,  
          eLpr      ,  
          eMail     ,  
          eNews     ,  
          eUser     ,  
          eUucp        
        };
        
        class TMachineDependent
        {
            
          protected:
            
            enum EEndianness
            {
              eLittleEndian , 
              eBigEndian      
            };

            EEndianness   eEndianType;


          public:
            
            //
            //  C O N S T R U C T O R S
            //
            
            TMachineDependent (void);
            
            virtual ~TMachineDependent (void) {}
            
            
          public:
            
            //
            //  S E L E C T O R S
            //
            
            bool isBigEndian (void) const
            {
              return ( eEndianType == eBigEndian );
            }
            
            bool isLittleEndian (void) const
            {
              return ( eEndianType == eLittleEndian );
            }
            
            long int getEndianIndependentLongInt ( EEndianness          eENDIAN_TYPE      ,
                                                   const unsigned char* pkucSOURCE_BUFFER ,
                                                   std::size_t          zLENGTH           ) const;
            
        };  // class TMachineDependent
        
        class TLittleEndianBuffer : private TMachineDependent
        {
      
          private:
      
            const unsigned char*   pkucBuffer;
            
            std::size_t            zLength;
            
      
          public:
            
            //
            //  C O N S T R U C T O R S
            //
            
            TLittleEndianBuffer ( const unsigned char* pkucSOURCE_BUFFER ,
                                  std::size_t          zLENGTH           ) :
              pkucBuffer (pkucSOURCE_BUFFER)                               ,
              zLength    (zLENGTH)                                         {}
            
            
          public:
            
            //
            //  S E L E C T O R S
            //
            
            virtual operator long int (void) const
            {
              return getEndianIndependentLongInt (eLittleEndian, pkucBuffer, zLength);
            }

        };  // class TLittleEndianBuffer
        
        class TBigEndianBuffer : private TMachineDependent
        {
      
          private:
            
            const unsigned char*   pkucBuffer;
            
            std::size_t            zLength;      
            
            
          public:
            
            //
            //  C O N S T R U C T O R S
            //
            
            TBigEndianBuffer ( const unsigned char* pkucSOURCE_BUFFER ,
                               std::size_t          zLENGTH           ) :
              pkucBuffer (pkucSOURCE_BUFFER)                            ,
              zLength    (zLENGTH)                                      {}


          public:
      
            //
            //  S E L E C T O R S
            //
      
            virtual operator long int (void) const
            {
              return getEndianIndependentLongInt (eBigEndian, pkucBuffer, zLength);
            }
      
        };  // class TBigEndianBuffer


      public:

        //
        //  C O N S T R U C T O R S
        //

        virtual ~ISystem (void) {}
        

      public:

        //
        //  S E L E C T O R S
        //

        virtual TString getCurrentDirectory (void) const = 0;

        virtual char getDirectorySeparator (void) const = 0;

        virtual std::size_t getFileSize (const char* pkcFILE_NAME) const = 0;

        virtual vector<TString> getPathItems (const string& rkySOURCE_PATH_COLLECTION) const;

        virtual char getPathSeparator (void) const = 0;

        virtual int getProcessId (void) const = 0;

        virtual void sleep (std::size_t zSECONDS, std::size_t zNANOSECONDS = 0) const = 0;

        virtual void writeLogEntry ( const string& rkyMESSAGE          ,
                                     ELogLevel     eLEVEL    = eNotice ,
                                     ELogFacility  eFACILITY = eUser   ) const = 0;

        virtual void yield (void) const = 0;

    };  // class ISystem

  }  // namespace system

}  // namespace mpcl


#endif  // not _MPCL_SYSTEM_SYSTEM__

---