unixglue.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.

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

#include <more/create.hpp>
#include <more/os/osglue.hpp>
#include "unixcondition.hpp"
#include "unixfile.hpp"
#include "unixmutex.hpp"
#include "unixprocess.hpp"
#include "unixsemaphore.hpp"
#include "unixsharedmemory.hpp"
#include "unixsocket.hpp"
#include "unixthread.hpp"

using namespace more;
using namespace more::io;
using namespace more::os;
using namespace more::os::unix_;
using namespace more::util;

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

void OSGlue::init( )
{
}

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

void OSGlue::shutDown( )
{
}

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

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

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

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

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

Condition::~Condition( )
{
}

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

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

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

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

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

  return pResult;
}

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

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

  if( pDirEntry != 0 )
  {
    pResult = CREATE UnixDirectory( pDirEntry );
  }

  return pResult;
}

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

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

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

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

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

Directory::~Directory( )
{
}

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

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

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

  return pResult;
}

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

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

  if( pDirEntry != 0 )
  {
    pResult = CREATE UnixFile( pDirEntry );
  }

  return pResult;
}

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

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

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

File::~File( )
{
}

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

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

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

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

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

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

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

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

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

Process::~Process( )
{
}

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

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

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

Mutex::~Mutex( )
{
}

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

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

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

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

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

Semaphore::~Semaphore( )
{
}

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

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

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

p<SharedMemory::Object> SharedMemory::createObject
(
  size_t  nRootKey,
  size_t  nSize
)
{
  p<SharedMemory::Object> pResult = CREATE UnixSharedMemory::Object( nRootKey, nSize );

  if( !pResult -> isValid( ) )
  {
    pResult = 0;
  }

  return pResult;
}

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

p<SharedMemory::Object> SharedMemory::retrieveObject
(
  const String& sObjectId
)
{
  p<SharedMemory::Object> pResult = CREATE UnixSharedMemory::Object( sObjectId );

  if( !pResult -> isValid( ) )
  {
    pResult = 0;
  }

  return pResult;
}

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

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

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

AcceptorSocket::~AcceptorSocket( )
{
}

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

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

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

Socket::~Socket( )
{
}

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

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

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

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

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

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

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

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

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

Thread::~Thread( )
{
}

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

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

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

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

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