win32glue.cpp

"More for C++" is a class library that provides some features that are usually common for object ori

//
//  This file is part of the "More for C++" library
//
//  Copyright (c) 1999-2003 by Thorsten Goertz ([e-mail])
//
//  The "More for C++" library is free software; you can redistribute it and/or
//  modify it under the terms of the license that comes with this package.
//
//  Read "license.txt" for more details.
//
//  THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
//  WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES
//  OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

////////////////////////////////////////////////////////////////////////////////

#ifndef _WIN32
#define _WIN32
#endif

#ifndef _MT
#define _MT
#endif

#include <windows.h>
#include <process.h>
#include <more/os/osglue.hpp>
#include <more/create.hpp>
#include <more/os/sharedmemory.hpp>
#include <more/os/win32/win32registry.hpp>
#include <more/os/win32/win32service.hpp>
#include "win32condition.hpp"
#include "win32file.hpp"
#include "win32mutex.hpp"
#include "win32process.hpp"
#include "win32registryimpl.hpp"
#include "win32semaphore.hpp"
#include "win32serviceimpl.hpp"
#include "win32socket.hpp"
#include "win32thread.hpp"

using namespace more;
using namespace more::os;
using namespace more::os::win32;
using namespace more::util;

////////////////////////////////////////////////////////////////////////////////

void OSGlue::init( )
{
  static WSADATA wsaData;

  WSAStartup( 257, &wsaData );
}

////////////////////////////////////////////////////////////////////////////////

void OSGlue::shutDown( )
{
  WSACleanup( );
}

////////////////////////////////////////////////////////////////////////////////

Condition::TimeOut::operator const char* ( ) const
{
  return "Time out from Condition::wait( )";
}

////////////////////////////////////////////////////////////////////////////////

p<Condition> Condition::create( )
{
  return CREATE Win32Condition( );
}

////////////////////////////////////////////////////////////////////////////////

Condition::~Condition( )
{
}

////////////////////////////////////////////////////////////////////////////////

Directory::Entry::~Entry( )
{
}

////////////////////////////////////////////////////////////////////////////////

p<Directory> Directory::create
(
  const p<Directory>& pParent,
  const String&       sName
)
{
  p<Directory> pResult;

  if( pParent != 0 )
  {
    pResult = CREATE Win32Directory( pParent, sName );
  }

  return pResult;
}

////////////////////////////////////////////////////////////////////////////////

p<Directory> Directory::create
(
  const p<Entry>& pDescriptor
)
{
  p<Directory> pResult;

  if( pDescriptor != 0 )
  {
    pResult = CREATE Win32Directory( pDescriptor );
  }

  return pResult;
}

////////////////////////////////////////////////////////////////////////////////

p<Directory> Directory::create
(
  const String& sFullName
)
{
  return CREATE Win32Directory( sFullName );
}

////////////////////////////////////////////////////////////////////////////////

p<Directory> Directory::getCurrentDirectory( )
{
  return CREATE Win32Directory( "." );
}

////////////////////////////////////////////////////////////////////////////////

Directory::~Directory( )
{
}

////////////////////////////////////////////////////////////////////////////////

p<File> File::create
(
  const p<Directory>& pParent,
  const String&       sName
)
{
  p<File> pResult;

  if( pParent != 0 )
  {
    pResult = CREATE Win32File( pParent, sName );
  }

  return pResult;
}

////////////////////////////////////////////////////////////////////////////////

p<File> File::create
(
  const p<Directory::Entry>& pDescriptor
)
{
  p<File> pResult;

  if( pDescriptor != 0 )
  {
    pResult = CREATE Win32File( pDescriptor );
  }

  return pResult;
}

////////////////////////////////////////////////////////////////////////////////

p<File> File::create
(
  const String& sFullName
)
{
  return CREATE Win32File( sFullName );
}

////////////////////////////////////////////////////////////////////////////////

File::~File( )
{
}

////////////////////////////////////////////////////////////////////////////////

Process::SignalHandler::~SignalHandler( )
{
}

////////////////////////////////////////////////////////////////////////////////

size_t Process::getId( )
{
  return GetCurrentProcessId( );
}

////////////////////////////////////////////////////////////////////////////////

void Process::setSignalHandler
(
  Signal                  eSignal,
  const p<SignalHandler>& pSignalHandler
)
{
  if( eSignal == Process::SIGNAL_CTRL_BREAK )
  {
    Win32Process::setConsoleCtrlHandler( pSignalHandler );
  }
}

////////////////////////////////////////////////////////////////////////////////

p<Process> Process::create
(
  const p<File>& pBinary
)
{
  return CREATE Win32Process( pBinary );
}

////////////////////////////////////////////////////////////////////////////////

Process::~Process( )
{
}

////////////////////////////////////////////////////////////////////////////////

p<Mutex> Mutex::create( )
{
  return CREATE Win32Mutex( );
}

////////////////////////////////////////////////////////////////////////////////

Mutex::~Mutex( )
{
}

////////////////////////////////////////////////////////////////////////////////

Semaphore::TimeOut::operator const char* ( ) const
{
  return "Time out from Semaphore::wait( )";
}

////////////////////////////////////////////////////////////////////////////////

p<Semaphore> Semaphore::create
(
  size_t nNoOfResources
)
{
  return CREATE Win32Semaphore( nNoOfResources );
}

////////////////////////////////////////////////////////////////////////////////

Semaphore::~Semaphore( )
{
}

////////////////////////////////////////////////////////////////////////////////

SharedMemory::Object::~Object( )
{
}

////////////////////////////////////////////////////////////////////////////////

p<SharedMemory::Object> SharedMemory::createObject
(
  size_t  nRootKey,
  size_t  nSize
)
{
  return 0;
}

////////////////////////////////////////////////////////////////////////////////

p<SharedMemory::Object> SharedMemory::retrieveObject
(
  const String& sObjectId
)
{
  return 0;
}

////////////////////////////////////////////////////////////////////////////////

p<AcceptorSocket> AcceptorSocket::create( )
{
  return CREATE Win32AcceptorSocket( );
}

////////////////////////////////////////////////////////////////////////////////

AcceptorSocket::~AcceptorSocket( )
{
}

////////////////////////////////////////////////////////////////////////////////

p<Socket> Socket::create( )
{
  return CREATE Win32Socket( );
}

////////////////////////////////////////////////////////////////////////////////

Socket::~Socket( )
{
}

////////////////////////////////////////////////////////////////////////////////

size_t Thread::getId( )
{
  return GetCurrentThreadId( );
}

////////////////////////////////////////////////////////////////////////////////

void Thread::joinRemainingThreads( )
{
  Win32Thread::joinRemainingThreads( );
}

////////////////////////////////////////////////////////////////////////////////

void Thread::sleep
(
  long nMilliseconds
)
{
  Sleep( nMilliseconds );
}

////////////////////////////////////////////////////////////////////////////////

p<Thread> Thread::create( )
{
  return CREATE Win32Thread( );
}

////////////////////////////////////////////////////////////////////////////////

Thread::~Thread( )
{
}

////////////////////////////////////////////////////////////////////////////////

Thread::Controller::~Controller( )
{
}

////////////////////////////////////////////////////////////////////////////////

Thread::Runnable::~Runnable( )
{
}

////////////////////////////////////////////////////////////////////////////////

Win32Registry::InvalidKey::operator const char* ( ) const
{
  return "Win32Registry: invalid key";
}

////////////////////////////////////////////////////////////////////////////////

Win32Registry::KeyAlreadyExists::operator const char* ( ) const
{
  return "Win32Registry: key already exists";
}

////////////////////////////////////////////////////////////////////////////////

Win32Registry::InvalidValueName::operator const char* ( ) const
{
  return "Win32Registry: invalid name for value";
}

////////////////////////////////////////////////////////////////////////////////

Win32Registry::ValueAlreadyExists::operator const char* ( ) const
{
  return "Win32Registry: value already exists";
}

////////////////////////////////////////////////////////////////////////////////

p<Win32Registry> Win32Registry::create
(
  const String& sBaseKey

) throw( InvalidKey )
{
  p<Win32Registry> pResult;

  if( sBaseKey == "HKEY_CLASSES_ROOT" )
  {
    pResult = CREATE Win32RegistryImpl( HKEY_CLASSES_ROOT );
  }
  else if( sBaseKey == "HKEY_CURRENT_CONFIG" )
  {
    pResult = CREATE Win32RegistryImpl( HKEY_CURRENT_CONFIG );
  }
  else if( sBaseKey == "HKEY_CURRENT_USER" )
  {
    pResult = CREATE Win32RegistryImpl( HKEY_CURRENT_USER );
  }
  else if( sBaseKey == "HKEY_LOCAL_MACHINE" )
  {
    pResult = CREATE Win32RegistryImpl( HKEY_LOCAL_MACHINE );
  }
  else if( sBaseKey == "HKEY_USERS" )
  {
    pResult = CREATE Win32RegistryImpl( HKEY_PERFORMANCE_DATA );
  }
  else if( sBaseKey == "HKEY_PERFORMANCE_DATA" )
  {
    pResult = CREATE Win32RegistryImpl( HKEY_USERS );
  }
  else
  {
    throw InvalidKey( );
  }

  return pResult;
}

////////////////////////////////////////////////////////////////////////////////

Win32Registry::~Win32Registry( )
{
}

////////////////////////////////////////////////////////////////////////////////

Win32Service::Servant::~Servant( )
{
}

////////////////////////////////////////////////////////////////////////////////

p<Win32Service> Win32Service::create
(
  const String& sName

) throw( Win32Service::NotSupported )
{
  return CREATE Win32ServiceImpl( sName );
}

////////////////////////////////////////////////////////////////////////////////

Win32Service::~Win32Service( )
{
}

////////////////////////////////////////////////////////////////////////////////