system.hpp

浏览该文件的文档.

#ifndef __SYSTEM_HPP__
#define __SYSTEM_HPP__
//
// system 提供一些系统平台相关的功能
//

namespace winux
{
class SystemError : public Error
{
public:
    enum {
        sysNoError,    
    };

    SystemError( int errType, AnsiString const & errStr ) throw() : Error( errType, errStr ) { }
};


#if defined(OS_WIN)
    typedef HANDLE HPipe;
    typedef HANDLE HProcess;
#else
    typedef int HPipe;
    typedef pid_t HProcess;
#endif


WINUX_FUNC_DECL(size_t) CommandLineToArgvA( AnsiString const & cmd, AnsiStringArray * argv );
WINUX_FUNC_DECL(size_t) CommandLineToArgvW( UnicodeString const & cmd, UnicodeStringArray * argv );
#if defined(_UNICODE) || defined(UNICODE)
inline size_t CommandLineToArgv( UnicodeString const & cmd, UnicodeStringArray * argv ) { return CommandLineToArgvW( cmd, argv ); }
#else
inline size_t CommandLineToArgv( AnsiString const & cmd, AnsiStringArray * argv ) { return CommandLineToArgvA( cmd, argv ); }
#endif

WINUX_FUNC_DECL(HProcess) ExecCommandEx(
    String const & cmd,
    HPipe * hStdinWritePipe,
    HPipe * hStdoutReadPipe,
    HPipe * hStderrReadPipe = NULL,
    bool closeStdinIfStdinWritePipeIsNull = true
);

WINUX_FUNC_DECL(int) ExecCommand(
    String const & cmd,
    String const & stdinStr,
    String * stdoutStr,
    String * stderrStr = NULL,
    bool closeStdinIfStdinStrEmpty = true
);

WINUX_FUNC_DECL(String) GetExec(
    String const & cmd,
    String const & stdinStr = "",
    String * stderrStr = NULL,
    bool closeStdinIfStdinStrEmpty = true
);



class WINUX_DLL CommandLineVars
{
public:
    CommandLineVars(
        int argc,
        char const ** argv,
        Mixed const & desiredParams,
        Mixed const & desiredOptions,
        Mixed const & desiredFlags,
        Mixed const & optionSymbols = "=,:"
    );

    size_t getParamsCount() const { return _params.getCount(); }
    size_t getOptionsCount() const { return _options.getCount(); }
    size_t getFlagsCount() const { return _flags.getCount(); }
    size_t getValuesCount() const { return _values.getCount(); }

    bool hasParam( String const & name ) const { return _params.has(name); }
    bool hasOption( String const & name ) const { return _options.has(name); }
    bool hasFlag( String const & name ) const { return _flags.has(name); }
    bool hasValue( String const & value ) const { return _values.has(value); }

    Mixed const & getParam( String const & name, Mixed const & defValue = "" ) const { return this->hasParam(name) ? _params[name] : defValue; }
    Mixed const & getOption( String const & name, Mixed const & defValue = "" ) const { return this->hasOption(name) ? _options[name] : defValue; }
    Mixed const & getFlag( size_t i ) const { return _flags[i]; }
    Mixed const & getValue( size_t i ) const { return _values[i]; }

    size_t getParamIndexInArgv( String const & name ) const { return _paramIndexesInArgv.find(name) != _paramIndexesInArgv.end() ? _paramIndexesInArgv.at(name) : npos; }
    size_t getOptionIndexInArgv( String const & name ) const { return _optionIndexesInArgv.find(name) != _optionIndexesInArgv.end() ? _optionIndexesInArgv.at(name) : npos; }
    size_t getFlagIndexInArgv( String const & name ) const { return _flagIndexesInArgv.find(name) != _flagIndexesInArgv.end() ? _flagIndexesInArgv.at(name) : npos; }
    size_t getValueIndexInArgv( String const & value ) const { return _valueIndexesInArgv.find(value) != _valueIndexesInArgv.end() ? _valueIndexesInArgv.at(value) : npos; }

    Mixed & getParams() { return _params; }
    Mixed & getOptions() { return _options; }
    Mixed & getFlags() { return _flags; }
    Mixed & getValues() { return _values; }

    Mixed dump() const
    {
        CommandLineVars * p = const_cast<CommandLineVars *>(this);
        return $c{
            { "params", p->getParams() },
            { "options", p->getOptions() },
            { "flags", p->getFlags() },
            { "values", p->getValues() },
        };
    }

    int getArgc() const { return _argc; }
    char const ** getArgv() const { return _argv; }

private:
    int _argc; // main()命令行参数个数
    char const ** _argv; // main()命令行参数

    StringArray _desiredParams; // 要识别的参数名
    StringArray _desiredOptions; // 要识别的选项名
    StringArray _desiredFlags; // 要识别的旗标名
    StringArray _optionSymbols; // 选项赋值符号

    Mixed _params;  // 参数Collection
    std::map< String, size_t > _paramIndexesInArgv;    // 参数在argv中的索引
    Mixed _options; // 选项Collection
    std::map< String, size_t > _optionIndexesInArgv;   // 选项在argv中的索引
    Mixed _flags;   // 旗标Array
    std::map< String, size_t > _flagIndexesInArgv;     // 旗标在argv中的索引
    Mixed _values;  // 值Array
    std::map< String, size_t > _valueIndexesInArgv;    // 值在argv中的索引

    DISABLE_OBJECT_COPY(CommandLineVars)
};

class WINUX_DLL ILockObj
{
public:
    virtual ~ILockObj() { }
    virtual bool tryLock() = 0;
    virtual bool lock() = 0;
    virtual bool unlock() = 0;
};

class WINUX_DLL ScopeGuard
{
    ILockObj & _lockObj;
public:
    ScopeGuard( ILockObj & lockObj ) : _lockObj(lockObj)
    {
        _lockObj.lock();
    }
    ~ScopeGuard()
    {
        _lockObj.unlock();
    }
    DISABLE_OBJECT_COPY(ScopeGuard)
};

class WINUX_DLL MutexLockObj : public ILockObj
{
public:
    MutexLockObj();
    virtual ~MutexLockObj();
    virtual bool tryLock() override;
    virtual bool lock() override;
    virtual bool unlock() override;
private:
    MembersWrapper<struct MutexLockObj_Data> _self;

    DISABLE_OBJECT_COPY(MutexLockObj)
};

class DllLoaderError : public SystemError
{
public:
    enum {
        dllFuncNotFound = 0x00000100,    
        dllModuleNoLoaded                
    };

    DllLoaderError( int errType, AnsiString const & errStr ) throw() : SystemError( errType, errStr ) { }
};

class WINUX_DLL DllLoader
{
public:

#if defined(OS_WIN)
    typedef HMODULE ModuleHandle;
#else
    typedef void * ModuleHandle;
#endif

    static String GetModulePath( void * funcInModule );

    DllLoader();
    DllLoader( String const & dllName );

    ~DllLoader();

    operator bool() const { return _hDllModule != NULL; }
    operator ModuleHandle() const { return _hDllModule; }

    char const * errStr() const;

    template < typename _PfnType >
    class Function
    {
    public:
        typedef _PfnType PfnType;
    private:
        AnsiString _funcName;
        PfnType _pfn;
    public:
        Function() : _funcName(""), _pfn(0) { }
        Function( AnsiString const & funcName, PfnType pfn ) : _funcName(funcName), _pfn(pfn) { }

        operator bool() const { return _pfn != NULL; }

        AnsiString const & getFuncName() const { return _funcName; }

        void * get() const { return reinterpret_cast<void *>(_pfn); }

        template < typename... _ArgType >
        typename FuncTraits<PfnType>::ReturnType call( _ArgType&& ... arg )
        {
            if ( !_pfn ) throw DllLoaderError( DllLoaderError::dllFuncNotFound, _funcName + " is not found" );
            return (*_pfn)( std::forward<_ArgType>(arg)... );
        }
    };

    void (* funcAddr( AnsiString const & funcName ) )();

    template < typename _PfnType >
    Function<_PfnType> func( AnsiString const & funcName )
    {
        _PfnType pfn = (_PfnType)this->funcAddr(funcName);
        return Function<_PfnType>( funcName, pfn );
    }

    String dllModuleFile; 
private:
    ModuleHandle _hDllModule;
    String _errStr;

    DISABLE_OBJECT_COPY(DllLoader)
};

class WINUX_DLL SharedMemory
{
public:
    SharedMemory();

    SharedMemory( int shmKey, size_t size );

    virtual ~SharedMemory();

    bool create( int shmKey, size_t size );

    void destroy();

    void * lock();

    void unlock();

    void * get();

private:
#if defined(OS_WIN)
    HANDLE _shm;
#else
    int _shm;
#endif
    void * _data;
    size_t _size;

    DISABLE_OBJECT_COPY(SharedMemory)
};

template < typename _PodType >
class SharedMemoryT : public SharedMemory
{
public:
    SharedMemoryT() { }

    SharedMemoryT( int shmKey, size_t size = -1 )
    {
        this->create( shmKey, size );
    }

    bool create( int shmKey, size_t size = -1 )
    {
        return SharedMemory::create( shmKey, size == -1 ? sizeof(_PodType) : size );
    }

    _PodType * operator -> ()
    {
        return reinterpret_cast<_PodType *>( this->get() );
    }
};

} // namespace winux

#endif // __SYSTEM_HPP__