smart_filename.h

Go to the documentation of this file.

/* Author(s)     : Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date : 2011-09-12
 * Last modified : 2011-09-12
 *
 * Copyright (C) 2011 Francois Mauger <mauger@lpccaen.in2p3.fr>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 * Description:
 *
 *   Automated incremental filenames
 *
 */
#ifndef DATATOOLS_SMART_FILENAME_H
#define DATATOOLS_SMART_FILENAME_H

// Standard Library:
#include <iostream>
#include <string>
#include <vector>

// Third Party:
// - Boost:
#include <boost/cstdint.hpp>

// This Project:
#include <datatools/properties.h>
#include <datatools/logger.h>

namespace datatools {

  class smart_filename
  {
  public:
    static const int MODE_INCREMENTAL_UNRANGED          = -1;
    static const int MODE_INCREMENTAL_DEFAULT_START     =  0;
    static const int MODE_INCREMENTAL_DEFAULT_INCREMENT =  1;

    enum mode_t {
      MODE_INVALID     =  0,
      MODE_SINGLE      =  0x1,
      MODE_LIST        =  0x2,
      MODE_INCREMENTAL =  0x4
    };

    struct labels {
      static const std::string & mode_single();
      static const std::string & mode_list();
      static const std::string & mode_incremental();
    };

    typedef std::vector<std::string>  list_type;
    typedef list_type::const_iterator const_iterator;

    smart_filename();

    virtual ~smart_filename();

    void set_logging_priority(datatools::logger::priority p_);

    datatools::logger::priority get_logging_priority() const;

    int get_mode() const;

    bool is_initialized() const;

    bool is_single() const;

    bool is_list() const;

    bool is_incremental() const;

    bool is_valid() const;

    bool is_ranged() const;

    bool is_expand_path() const;

    size_t size() const;

    size_t current_size() const;

    const_iterator begin() const;

    const_iterator end() const;

    const std::string & operator[](int index_) const;

    const std::string & get_filename(int index_) const;

    bool has_filename(const std::string & name_, bool expand_ = true) const;

    void set(const std::string & filename_);

    void set_single(const std::string & filename_);

    void add(const std::string & filename_);

    void add_to_list(const std::string & filename_);

    void reset();

    void build_incremental_filename(int increment_index_,
                                    std::string & filename_) const;

    void dump(std::ostream & out_ = std::clog) const;

    void initialize(const properties & config_);

    void print_list_of_filenames(std::ostream & out_ = std::clog) const;

    void store_list_of_filenames(const std::string & list_filename_,
                                 bool append_ = true) const;

    static void make_single(smart_filename & smart_filename_,
                            const std::string & filename_,
                            bool expand_path_ = true);

    static void make_list(smart_filename & smart_filename_,
                          bool allow_duplication_ = false,
                          bool expand_path_ = true);

    static void make_list(smart_filename & smart_filename_,
                          const std::string & list_file_,
                          bool allow_duplication_ = false,
                          bool expand_path_ = true);

    static void make_incremental(smart_filename & smart_filename_,
                                 const std::string & path_,
                                 const std::string & prefix_,
                                 const std::string & extension_,
                                 int stopping_index_,
                                 int starting_index_ = 0,
                                 int increment_index_ = 1,
                                 const std::string & suffix_ = "",
                                 int incremental_index_ndigit_ = 0,
                                 bool expand_path_ = true);

    static void make_unranged_incremental(smart_filename & smart_filename_,
                                          const std::string & path_,
                                          const std::string & prefix_,
                                          const std::string & extension_,
                                          int starting_index_ = 0,
                                          int increment_index_ = 1,
                                          const std::string & suffix_ = "",
                                          int incremental_index_ndigit_ = 0,
                                          bool expand_path_ = true);

  protected:

    void set_mode(int);

    void add_list(const std::string & filename_);

    void set_list_allow_duplication(bool);

    void set_current_index(int);

  private:

    datatools::logger::priority _logging_;    
    uint32_t    _mode_;                       
    bool        _expand_path_;                
    list_type   _list_;                       
    bool        _list_allow_duplication_;     
    bool        _ranged_;                     
    std::string _incremental_path_;           
    std::string _incremental_prefix_;         
    std::string _incremental_suffix_;         
    std::string _incremental_extension_;      
    int32_t     _incremental_starting_index_; 
    int32_t     _incremental_stopping_index_; 
    int32_t     _incremental_increment_;      
    uint32_t    _incremental_index_ndigit_;   
  };

}  // end of namespace datatools

/***************
 * OCD support *
 ***************/
#include <datatools/ocd_macros.h>
DOCD_CLASS_DECLARATION(datatools::smart_filename)

#endif // DATATOOLS_SMART_FILENAME_H

// Local Variables: --
// mode: c++ --
// c-file-style: "gnu" --
// tab-width: 2 --
// End: --