system.hpp

浏览该文件的文档.

#ifndef __SYSTEM_HPP__
#define __SYSTEM_HPP__

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

WINUX_FUNC_DECL(int) CommandLineToArgv( winux::String const & cmd, winux::StringArray * argv );

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

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

WINUX_FUNC_DECL(winux::String) GetExec(
    winux::String const & cmd,
    winux::String const & stdinStr = "",
    winux::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 = "=,:"
    );
    int getParamsCount() const { return _params.getCount(); }
    int getOptionsCount() const { return _options.getCount(); }
    int getFlagsCount() const { return _flags.getCount(); }
    int 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( int i ) const { return _flags[i]; }
    Mixed const & getValue( int i ) const { return _values[i]; }

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

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

    int getArgc() const { return _argc; }
    char const ** getArgv() const { return _argv; }
private:
    static void __MixedAppendToStringArray( Mixed const & mx, StringArray * arr );

    int _argc;
    char const ** _argv;
    StringArray _desiredParams;
    StringArray _desiredOptions;
    StringArray _desiredFlags;
    StringArray _optionSymbols;

    Mixed _params;  
    std::map< String, int > _paramIndexesInArgv;    
    Mixed _options; 
    std::map< String, int > _optionIndexesInArgv;   
    Mixed _flags;   
    std::map< String, int > _flagIndexesInArgv;     
    Mixed _values;  
    std::map< String, int > _valueIndexesInArgv;    
    DISABLE_OBJECT_COPY(CommandLineVars)
};

class WINUX_DLL CommandLine
{
    StringStringMap _params;
    StringArray _values;
    StringArray _flags;
    static bool _IsName( String const & arg, StringArray const & prefixes );
public:
    CommandLine( int argc, char * argv[], String const & paramPrefix = "- -- /" );
    int getParamCount() const { return (int)_params.size(); }
    int getValueCount() const { return (int)_values.size(); }
    int getFlagCount() const { return (int)_flags.size(); }
    bool hasParam( String const & name ) const { return isset( _params, name ); }
    bool hasValue( String const & value ) const { return std::find( _values.begin(), _values.end(), value ) != _values.end(); }
    bool hasFlag( String const & name ) const { return std::find( _flags.begin(), _flags.end(), name ) != _flags.end(); }
    String getParam( String const & name, String const & defValue = "" ) const { return isset( _params, name ) ? _params.at(name) : defValue; }
    String getValue( int i ) const { return _values[i]; }
    String getFlag( int i ) const { return _flags[i]; }

    DISABLE_OBJECT_COPY(CommandLine)
};

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();
    virtual bool lock();
    virtual bool unlock();
private:
    MembersWrapper<struct MutexLockObj_Data> _self;

    DISABLE_OBJECT_COPY(MutexLockObj)
};

class DllLoaderError : public Error
{
public:
    enum {
        DllLoader_FuncNotFound = 0x00000100,
        DllLoader_ModuleNoLoaded
    };

    DllLoaderError( int errType, AnsiString const & errStr ) throw() : Error( 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 winux::FuncTraits<PfnType>::ReturnType call( _ArgType&& ... arg )
        {
            if ( !_pfn ) throw DllLoaderError( DllLoaderError::DllLoader_FuncNotFound, _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 );
    }

    winux::String dllModuleFile; 
private:
    ModuleHandle _hDllModule;

    DISABLE_OBJECT_COPY(DllLoader)
};


} // namespace winux

#endif // __SYSTEM_HPP__