urn_to_path_resolver_service.h

Go to the documentation of this file.

//
// Copyright (c) 2017 by Francois Mauger <mauger@lpccaen.in2p3.fr>
// Copyright (c) 2017 by Université de Caen
//
// This file is part of Bayeux/datatools.
//
// Bayeux/datatools 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.
//
// Bayeux/datatools 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 Bayeux/datatools. If not, see <http://www.gnu.org/licenses/>.

#ifndef DATATOOLS_URN_TO_PATH_RESOLVER_SERVICE_H
#define DATATOOLS_URN_TO_PATH_RESOLVER_SERVICE_H

// Standard Library
#include <string>
#include <vector>
#include <map>
#include <iostream>
#include <set>

// This project
#include <datatools/properties.h>
#include <datatools/base_service.h>
#include <datatools/urn_to_path.h>

namespace datatools {

  class urn_to_path_resolver_service
    : public ::datatools::base_service
  {
  public:

    static const std::set<std::string> & default_known_categories();

    // \brief Resolver map entry
    //
    // The category is a string which documents the type of informations accessible
    // from the path. Default set of values supports:
    // - "data" : generic data
    // - "configuration" : set of configuration parameters (configuration file)
    // - "graphics" : graphical information (icons, images...)
    // - "archive" : a container for other resources (tar, zip...)
    // - "log" : logging informations
    // struct resolver_entry {
    //   std::string urn;      //!< URN representation
    //   std::string category; //!< Resource file category
    //   std::string path;     //!< Resource path (may be a filesystem path or any kind of  URL)
    //   std::string mime;     //!< MIME type
    // };
    // \brief Resolver map entry
    typedef urn_to_path resolver_entry;

    typedef std::map<std::string, resolver_entry> urn_lookup_table_type;

    urn_to_path_resolver_service();

    virtual ~urn_to_path_resolver_service();

    void add_known_category(const std::string & cat_);

    void remove_known_category(const std::string & cat_);

    void clear_known_categories();

    const std::set<std::string> & get_known_categories() const;

    bool is_allow_overloading() const;

    void set_allow_overloading(bool);

    void add_map(const std::string &);

    virtual bool is_initialized() const;

    virtual int initialize(const datatools::properties & config_,
                           datatools::service_dict_type & services_);

    virtual int reset();

    virtual void tree_dump(std::ostream& out = std::clog,
                           const std::string & title = "",
                           const std::string & indent = "",
                           bool inherit = false) const;

    void load_map(const std::string & map_filename_);

    bool urn_is_known(const std::string & urn_) const;

    std::string resolve(const std::string & urn_) const;

    void add_entry(const std::string & urn_,
                   const std::string & category_,
                   const datatools::properties & infos_);

    void add_entry(const std::string & urn_,
                   const std::string & category_,
                   const std::string & path_,
                   const std::string & mime_ = "");

    void remove(const std::string & urn_);

    std::size_t size() const;

    const resolver_entry & get_entry(const std::string & urn_) const;

    const std::string & get_category(const std::string & urn_) const;

    const std::string & get_path(const std::string & urn_) const;

    const std::string & get_mime(const std::string & urn_) const;

    void print_lookup_table(std::ostream & = std::clog, const uint32_t flags_ = 0) const;

    const urn_lookup_table_type & get_urn_lookup_table() const;

    void kernel_push(const std::string & = "");

    void kernel_pop();

    bool is_kernel_pushed() const;

  private:

    void _init_();

    void _reset_();

  private:

    // Management:
    bool _initialized_ = false; 

    // Configuration:
    bool _allow_overloading_ = false; 
    std::vector<std::string> _map_filenames_; 
    std::set<std::string> _known_categories_; 

    // Private data:
    urn_lookup_table_type _urn_lookup_table_; 

    DATATOOLS_SERVICE_REGISTRATION_INTERFACE(urn_to_path_resolver_service)

  };

}

#endif // DATATOOLS_URN_TO_PATH_RESOLVER_SERVICE_H

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