utils.hpp

Go to the documentation of this file.

 
#ifndef ARGS__UTILS_HPP__INCLUDED
#define ARGS__UTILS_HPP__INCLUDED
 
// Args include.
#include "types.hpp"
 
// C++ include.
#include <algorithm>
#include <type_traits>
 
 
namespace Args {
 
 
//
// DISABLE_COPY
//
 
#define DISABLE_COPY( Class ) \
    Class( const Class & ) = delete; \
    Class & operator= ( const Class & ) = delete;
 
 
//
// UNUSED
//
 
#define UNUSED( Var ) (void)Var;
 
 
namespace details {
 
//
// asConst
//
 
template< typename T >
constexpr typename std::add_const< T >::type &
asConst( T & t ) noexcept
{
    return t;
}
 
template < typename T >
void asConst( const T && ) = delete;
 
 
//
// isArgument
//
 
static inline bool
isArgument( const String & word )
{
    return ( word.find( SL( "--" ) ) == 0 );
} // isArgument
 
 
//
// isFlag
//
 
static inline bool
isFlag( const String & word )
{
    if( !isArgument( word ) )
    {
        if( word.find( SL( '-' ) ) == 0 )
            return true;
    }
 
    return false;
} // isFlag
 
 
//
// isCorrectFlag
//
 
static inline bool
isCorrectFlag( const String & flag )
{
    if( flag.empty() || flag.length() > 1 )
        return false;
 
    static const String availableSymbols( SL( "0123456789"
        "abcdefghijklmnopqrstuvwxyz"
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ" ) );
 
    return ( availableSymbols.find( flag ) != String::npos );
} // isCorrectFlag
 
 
//
// isCorrectName
//
 
static inline bool
isCorrectName( const String & name )
{
    if( name.empty() )
        return false;
 
    static const String availableSymbols( SL( "0123456789"
        "abcdefghijklmnopqrstuvwxyz"
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ-_" ) );
 
    for( const Char & c : asConst( name ) )
    {
        if( availableSymbols.find( c ) == String::npos )
            return false;
    }
 
    return true;
} // isCorrectName
 
 
//
// isMisspelledName
//
 
static inline bool
isMisspelledName( const String & misspelled,
    const String & correct )
{
    if( !misspelled.empty() && !correct.empty() )
    {
        String ms = misspelled;
        String cs = correct;
 
        std::sort( ms.begin(), ms.end() );
        std::sort( cs.begin(), cs.end() );
 
        return ( ms == cs );
    }
    else
        return false;
}
 
template< typename T = void >
struct DummyString {
    static const String c_string;
};
 
template< typename T >
const String DummyString< T >::c_string;
 
} /* namespace details */
 
} /* namespace Args */
 
#endif // ARGS__UTILS_HPP__INCLUDED