pprocess.h

Go to the documentation of this file.

/*
 * pprocess.h
 *
 * Operating System Process (running program executable) class.
 *
 * Portable Windows Library
 *
 * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Portable Windows Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
 * All Rights Reserved.
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 20385 $
 * $Author: rjongbloed $
 * $Date: 2008-06-04 10:40:38 +0000 (Wed, 04 Jun 2008) $
 */

#ifndef _PPROCESS
#define _PPROCESS

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <ptlib/mutex.h>
#include <ptlib/syncpoint.h>
#include <ptlib/thread.h>
#include <ptlib/pfactory.h>

#include <queue>

#ifdef P_VXWORKS
#define PCREATE_PROCESS(cls) \
  PProcess::PreInitialise(0, NULL, NULL); \
  cls instance; \
  instance._main();
#elif defined(P_RTEMS)
#define PCREATE_PROCESS(cls) \
extern "C" {\
   void* POSIX_Init( void* argument) \
     { PProcess::PreInitialise(0, 0, 0); \
       static cls instance; \
       exit( instance._main() ); \
     } \
}
#elif defined(_WIN32_WCE)
#define PCREATE_PROCESS(cls) \
  int WinMain(HINSTANCE, HINSTANCE, LPWSTR, int) \
    { cls *pInstance = new cls(); \
      int terminationValue = pInstance->_main(); \
      delete pInstance; \
      return terminationValue; \
    }
#else
#define PCREATE_PROCESS(cls) \
  int main(int argc, char ** argv, char ** envp) \
    { PProcess::PreInitialise(argc, argv, envp); \
      cls *pInstance = new cls(); \
      int terminationValue = pInstance->_main(); \
      delete pInstance; \
      return terminationValue; \
    }
#endif // P_VXWORKS

/*$MACRO PDECLARE_PROCESS(cls,ancestor,manuf,name,major,minor,status,build)
   This macro is used to declare the components necessary for a user PWLib
   process. This will declare the PProcess descendent class, eg PApplication,
   and create an instance of the class. See the #PCREATE_PROCESS# macro
   for more details.
 */
#define PDECLARE_PROCESS(cls,ancestor,manuf,name,major,minor,status,build) \
  class cls : public ancestor { \
    PCLASSINFO(cls, ancestor); \
    public: \
      cls() : ancestor(manuf, name, major, minor, status, build) { } \
    private: \
      virtual void Main(); \
  };


class PTimerList : public PObject
/* This class defines a list of #PTimer# objects. It is primarily used
   internally by the library and the user should never create an instance of
   it. The #PProcess# instance for the application maintains an instance
   of all of the timers created so that it may decrements them at regular
   intervals.
 */
{
  PCLASSINFO(PTimerList, PObject);

  public:
    // Create a new timer list
    PTimerList();

    /* Decrement all the created timers and dispatch to their callback
       functions if they have expired. The #PTimer::Tick()# function
       value is used to determine the time elapsed since the last call to
       Process().

       The return value is the number of milliseconds until the next timer
       needs to be despatched. The function need not be called again for this
       amount of time, though it can (and usually is).
       
       @return
       maximum time interval before function should be called again.
     */
    PTimeInterval Process();

    PTimer::IDType GetNewTimerId() const { return ++timerId; }

    class RequestType {
      public:
        enum Action {
          Stop,
          Start
        } action;

        RequestType(Action _action, PTimer * _timer) : action(_action), timer(_timer), id(timer->GetTimerId()), sync(NULL) { }

        PTimer * timer;
        PTimer::IDType id;
        PSyncPoint * sync;
    };

    typedef std::queue<RequestType> RequestQueueType;
    typedef std::vector<RequestType> RequestListType;

    void QueueRequest(RequestType::Action action, PTimer * timer, bool _isSync = true);

  private:
    mutable PAtomicInteger timerId; 

    // map used to store timer information
    PMutex timerListMutex;
    struct TimerInfoType {
      TimerInfoType(PTimer * _timer) : timer(_timer)  { removed = false; }
      PTimer * timer;
      bool removed;
    };
    typedef std::map<PTimer::IDType, TimerInfoType> TimerInfoMapType;
    TimerInfoMapType activeTimers;
    PThread * timerThread;

    // queue of timer action requests
    PMutex queueMutex;
    RequestQueueType requestQueue;
    RequestListType addQueue;

    // The last system timer tick value that was used to process timers.
    PTimeInterval lastSample;
};


// PProcess

class PProcess : public PThread
{
  PCLASSINFO(PProcess, PThread);

  public:

    enum CodeStatus {
      AlphaCode,    
      BetaCode,     
      ReleaseCode,  
      NumCodeStatuses
    };

    PProcess(
      const char * manuf = "",         
      const char * name = "",          
      WORD majorVersion = 1,           
      WORD minorVersion = 0,           
      CodeStatus status = ReleaseCode, 
      WORD buildNumber = 1             
    );

    Comparison Compare(
      const PObject & obj   
    ) const;

    virtual void Terminate();

    virtual PString GetThreadName() const;

    virtual void SetThreadName(
      const PString & name        
    );

    static PProcess & Current();

    virtual void OnThreadStart(
      PThread & thread
    );

    virtual void OnThreadEnded(
      PThread & thread
    );

    static PBoolean IsInitialised();

    void SetTerminationValue(
      int value  
    );

    int GetTerminationValue() const;

    PArgList & GetArguments();

    virtual const PString & GetManufacturer() const;

    virtual const PString & GetName() const;

    virtual PString GetVersion(
      PBoolean full = PTrue 
    ) const;

    const PFilePath & GetFile() const;

    DWORD GetProcessID() const;

    PTime GetStartTime() const;

    PString GetUserName() const;

    PBoolean SetUserName(
      const PString & username, 
      PBoolean permanent = PFalse    
    );

    PString GetGroupName() const;

    PBoolean SetGroupName(
      const PString & groupname, 
      PBoolean permanent = PFalse     
    );

    int GetMaxHandles() const;

    PBoolean SetMaxHandles(
      int newLimit  
    );

#ifdef P_CONFIG_FILE

    virtual PString GetConfigurationFile();
#endif

    void SetConfigurationPath(
      const PString & path   
    );

    static PString GetOSClass();

    static PString GetOSName();

    static PString GetOSHardware();

    static PString GetOSVersion();

    static PDirectory GetOSConfigDir();

    PTimerList * GetTimerList();

    static void PreInitialise(
      int argc,     // Number of program arguments.
      char ** argv, // Array of strings for program arguments.
      char ** envp  // Array of string for the system environment
    );

    static void PreShutdown();
    static void PostShutdown();

    virtual int _main(void * arg = NULL);

    class HostSystemURLHandlerInfo 
    {
      public:
        HostSystemURLHandlerInfo()
        { }

        HostSystemURLHandlerInfo(const PString & _type)
          : type(_type)
        { }

        static bool RegisterTypes(const PString & _types, bool force = true);

        void SetIcon(const PString & icon);
        PString GetIcon() const;

        void SetCommand(const PString & key, const PString & command);
        PString GetCommand(const PString & key) const;

        bool GetFromSystem();
        bool CheckIfRegistered();

        bool Register();

        PString type;

    #if _WIN32
        PString iconFileName;
        PStringToString cmds;
    #endif
    };

  private:
    void Construct();

  // Member variables
    static int p_argc;
    static char ** p_argv;
    static char ** p_envp;
    // main arguments

    int terminationValue;
    // Application return value

    PString manufacturer;
    // Application manufacturer name.

    PString productName;
    // Application executable base name from argv[0]

    WORD majorVersion;
    // Major version number of the product
    
    WORD minorVersion;
    // Minor version number of the product
    
    CodeStatus status;
    // Development status of the product
    
    WORD buildNumber;
    // Build number of the product

    PFilePath executableFile;
    // Application executable file from argv[0] (not open)

    PStringArray configurationPaths;
    // Explicit file or set of directories to find default PConfig

    PArgList arguments;
    // The list of arguments

    PTimerList timers;
    // List of active timers in system

    PTime programStartTime;
    // time at which process was intantiated, i.e. started

    int maxHandles;
    // Maximum number of file handles process can open.


  friend class PThread;


// Include platform dependent part of class
#ifdef _WIN32
#include "msos/ptlib/pprocess.h"
#else
#include "unix/ptlib/pprocess.h"
#endif
};

/*
 *  one instance of this class (or any descendants) will be instantiated
 *  via PGenericFactory<PProessStartup> one "main" has been started, and then
 *  the OnStartup() function will be called. The OnShutdown function will
 *  be called after main exits, and the instances will be destroyed if they
 *  are not singletons
 */
class PProcessStartup : public PObject
{
  PCLASSINFO(PProcessStartup, PObject)
  public:
    virtual void OnStartup()  { }
    virtual void OnShutdown() { }
};

typedef PFactory<PProcessStartup> PProcessStartupFactory;

#if PTRACING

// using an inline definition rather than a #define crashes gcc 2.95. Go figure
#define P_DEFAULT_TRACE_OPTIONS ( PTrace::Blocks | PTrace::Timestamp | PTrace::Thread | PTrace::FileAndLine )

template <unsigned _level, unsigned _options = P_DEFAULT_TRACE_OPTIONS >
class PTraceLevelSetStartup : public PProcessStartup
{
  public:
    void OnStartup()
    { PTrace::Initialise(_level, NULL, _options); }
};

#endif // PTRACING

#endif

// End Of File ///////////////////////////////////////////////////////////////

---