seqan3::input_file_validator< file_t > Class Template Reference

A validator that checks if a given path is a valid input file. More...

#include <seqan3/argument_parser/validators.hpp>

Inheritance diagram for seqan3::input_file_validator< file_t >:

Public Types
using	option_value_type = std::string
	Type of values that are tested by validator.
Public Types inherited from seqan3::file_validator_base
using	option_value_type = std::string
	Type of values that are tested by validator.

Public Member Functions
std::string	get_help_page_message () const
	Returns a message that can be appended to the (positional) options help page info.
virtual void	operator() (std::filesystem::path const &file) const override
	Tests whether path is an existing regular file and is readable. More...
Constructors, destructor and assignment
	input_file_validator ()
	Default constructor. More...
	input_file_validator (input_file_validator const &)=default
	Defaulted.
	input_file_validator (input_file_validator &&)=default
	Defaulted.
input_file_validator &	operator= (input_file_validator const &)=default
	Defaulted.
input_file_validator &	operator= (input_file_validator &&)=default
	Defaulted.
virtual	~input_file_validator ()=default
	Virtual destructor.
	input_file_validator (std::vector< std::string > extensions)
	Constructs from a given collection of valid extensions. More...
	file_validator_base ()=default
	Defaulted.
	file_validator_base (file_validator_base const &)=default
	Defaulted.
	file_validator_base (file_validator_base &&)=default
	Defaulted.
Public Member Functions inherited from seqan3::file_validator_base
template<std::ranges::forward_range range_type>
void	operator() (range_type const &v) const
	Tests whether every path in list v passes validation. See operator()(option_value_type const & value) for further information. More...
	file_validator_base ()=default
	Defaulted.
	file_validator_base (file_validator_base const &)=default
	Defaulted.
	file_validator_base (file_validator_base &&)=default
	Defaulted.
file_validator_base &	operator= (file_validator_base const &)=default
	Defaulted.
file_validator_base &	operator= (file_validator_base &&)=default
	Defaulted.
virtual	~file_validator_base ()=default

Additional Inherited Members
Protected Member Functions inherited from seqan3::file_validator_base
bool	case_insensitive_string_ends_with (std::string_view str, std::string_view suffix) const
	Helper function that checks if a string is a suffix of another string. Case insensitive. More...
std::string	valid_extensions_help_page_message () const
	Returns the information of valid file extensions.
void	validate_filename (std::filesystem::path const &path) const
	Validates the given filename path based on the specified extensions. More...
void	validate_readability (std::filesystem::path const &path) const
	Checks if the given path is readable. More...
void	validate_writeability (std::filesystem::path const &path) const
	Checks if the given path is writable. More...
Protected Attributes inherited from seqan3::file_validator_base
std::vector< std::string >	extensions {}
	Stores the extensions.
Related Functions inherited from validator
using	option_value_type
	The type of value on which the validator is called on. More...
void	operator() (option_value_type const &cmp) const
	Validates the value 'cmp' and throws a seqan3::validation_error on failure. More...

Detailed Description

template<typename file_t = void>
class seqan3::input_file_validator< file_t >

A validator that checks if a given path is a valid input file.

Template Parameters

file_t

The type of the file to get the valid extensions for; void on default.

On construction, the validator can receive a list (std::vector over std::string) of valid file extensions. The class acts as a functor that throws a seqan3::validation_error exception whenever a given filename's extension (std::filesystem::path) is not in the given list of valid file extensions, if the file does not exist, or if the file does not have the proper read permissions.

#include <seqan3/argument_parser/all.hpp>
#include <seqan3/core/debug_stream.hpp>
#include <seqan3/std/filesystem>
 
int main(int argc, const char ** argv)
{
    seqan3::argument_parser myparser{"Test", argc, argv}; // initialize
 
    std::filesystem::path myfile{};
 
    myparser.add_option(myfile,'f',"file","The input file containing the sequences.",
                        seqan3::option_spec::standard, seqan3::input_file_validator{{"fa","fasta"}});
 
    // an exception will be thrown if the user specifies a filename
    // that does not have one of the extensions ["fa","fasta"] or if the file does not exist/is not readable.
    try
    {
        myparser.parse();
    }
    catch (seqan3::argument_parser_error const & ext) // the user did something wrong
    {
        std::cerr << "[PARSER ERROR] " << ext.what() << "\n"; // customize your error message
        return -1;
    }
 
    seqan3::debug_stream << "filename given by user passed validation: " << myfile << "\n";
    return 0;
}

The valid extensions can also be obtained from a seqan3 formatted file type, e.g. seqan3::sequence_input_file, if it is given as template argument to this class. The following snippet demonstrates the different ways to instantiate the seqan3::input_file_validator.

#include <seqan3/argument_parser/validators.hpp>
#include <seqan3/io/sequence_file/input.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main(int argc, const char ** argv)
{
    // Default constructed validator has an empty extension list.
    seqan3::input_file_validator validator1{};
    seqan3::debug_stream << validator1.get_help_page_message() << "\n";
 
    // Specify your own extensions for the input file.
    seqan3::input_file_validator validator2{std::vector{std::string{"exe"}, std::string{"fasta"}}};
    seqan3::debug_stream << validator2.get_help_page_message() << "\n";
 
    // Give the seqan3 file type as a template argument to get all valid extensions for this file.
    seqan3::input_file_validator<seqan3::sequence_file_input<>> validator3{};
    seqan3::debug_stream << validator3.get_help_page_message() << "\n";
 
    return 0;
}

Note

The validator works on every type that can be implicitly converted to std::filesystem::path.

Constructor & Destructor Documentation

input_file_validator() [1/2]

template<typename file_t = void>

seqan3::input_file_validator< file_t >::input_file_validator ( )

inline

Default constructor.

If the class' template argument file_t names a valid seqan3 file type that contains a static member valid_formats, e.g. seqan3::sequence_input_file::valid_formats, then it generates the list of valid extensions from this file. Otherwise the extensions list is empty.

input_file_validator() [2/2]

template<typename file_t = void>

seqan3::input_file_validator< file_t >::input_file_validator ( std::vector< std::string >  extensions )

inlineexplicit

Constructs from a given collection of valid extensions.

Parameters

[in]

extensions

The valid extensions to validate for.

This constructor is only available if file_t does not name a valid seqan3 file type that contains a static member valid_formats.

Member Function Documentation

operator()()

template<typename file_t = void>

virtual void seqan3::input_file_validator< file_t >::operator() ( std::filesystem::path const &  file ) const

inlineoverridevirtual

Tests whether path is an existing regular file and is readable.

Parameters

file	The input value to check.

Exceptions

seqan3::validation_error

if the validation process failed. Might be nested with std::filesystem::filesystem_error on unhandled OS API errors.

Implements seqan3::file_validator_base.

---

The documentation for this class was generated from the following file:

• seqan3/argument_parser/validators.hpp