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(uint) GetPid( void );
WINUX_FUNC_DECL(uint) GetTid( void );

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 = $T(""),
    String * stderrStr = NULL,
    bool closeStdinIfStdinStrEmpty = true
);



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

    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 = $T("") ) const { return this->hasParam(name) ? _params[name] : defValue; }
    Mixed const & getOption( String const & name, Mixed const & defValue = $T("") ) 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{
            { $T("params"), p->getParams() },
            { $T("options"), p->getOptions() },
            { $T("flags"), p->getFlags() },
            { $T("values"), p->getValues() },
        };
    }

    int getArgc() const { return _argc; }
    winux::tchar const ** getArgv() const { return _argv; }

private:
    int _argc; // main()命令行参数个数
    winux::tchar 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
{
public:
    ScopeGuard( ILockObj & lockObj ) : _lockObj(lockObj)
    {
        _lockObj.lock();
    }
    ~ScopeGuard()
    {
        _lockObj.unlock();
    }

private:
    ILockObj & _lockObj;
    DISABLE_OBJECT_COPY(ScopeGuard)
};

class WINUX_DLL MutexNative : public ILockObj
{
public:
    MutexNative();
    virtual ~MutexNative();
    virtual bool tryLock() override;
    virtual bool lock() override;
    virtual bool unlock() override;

private:
    PlainMembers<struct MutexLockObj_Data, 40> _self;

    DISABLE_OBJECT_COPY(MutexNative)
};

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;
    AnsiString _errStr;

    DISABLE_OBJECT_COPY(DllLoader)
};

enum FileMappingFlag
{
    fmfUnspec = 0,      
    fmfReadOnly = 1,    
    fmfWriteCopy = 2,   
    fmfReadWrite = 3,   
    fmfExecuteReadOnly = 5, 
    fmfExecuteWriteCopy = 6, 
    fmfExecuteReadWrite = 7, 
};

class FileMapping
{
public:
    FileMapping();

    FileMapping( String const & filePath, FileMappingFlag flag = fmfWriteCopy );

    FileMapping(
    #if defined(OS_WIN)
        HANDLE file,
    #else
        int file,
    #endif
        bool isPeekFile,
        FileMappingFlag flag
    );

    virtual ~FileMapping();

    bool create( String const & filePath, FileMappingFlag flag );

    bool create(
    #if defined(OS_WIN)
        HANDLE file,
    #else
        int file,
    #endif
        bool isPeekFile,
        FileMappingFlag flag
    );

    void destroy();

    bool loadFile( String const & filePath, FileMappingFlag flag );

    bool loadFile(
    #if defined(OS_WIN)
        HANDLE file,
    #else
        int file,
    #endif
        bool isPeekFile,
        FileMappingFlag flag
    );

    size_t getFileSize() const;

    void unloadFile();

    bool map( FileMappingFlag flag = fmfUnspec, size_t size = 0, offset_t offset = 0 );

    void unmap();

    void * get() const { return _p; }

    template < typename _Ty >
    _Ty * get() const { return reinterpret_cast<_Ty *>(_p); }

    size_t size() const { return _size; }

    operator bool() const;

private:
    // 零初始化
    void _zeroInit();

#if defined(OS_WIN)
    HANDLE _file;
    HANDLE _fileMapping;
#else
    int _file;
#endif
    void * _p; // 内存地址
    size_t _size; // 映射的大小
    FileMappingFlag _flag; // 记下创建标记
    bool _isPeekFile; // 是否为使用外部文件资源，即不管理文件资源

    DISABLE_OBJECT_COPY(FileMapping)
};

class WINUX_DLL SharedMemory
{
public:
    SharedMemory();

    SharedMemory( String const & shmName, size_t size );

    virtual ~SharedMemory();

    bool create( String const & shmName, size_t size );

    void destroy();

    void * lock();

    void unlock();

    void * get() { return _data ? _data : this->lock(); }


private:
    String _shmName;
#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( String const & shmName, size_t size = -1 )
    {
        this->create( shmName, size );
    }

    bool create( String const & shmName, size_t size = -1 )
    {
        return SharedMemory::create( shmName, size == -1 ? sizeof(_PodType) : size );
    }

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

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

} // namespace winux

#endif // __SYSTEM_HPP__