pid_path.h

Go to the documentation of this file.

/*      File: pid_path.h
 *       This file is part of the program pid-rpath
 *       Program description : Default package of PID, used to manage runtime
 * path of executables
 *       Copyright (C) 2015 -  Robin Passama (LIRMM). All Right reserved.
 *
 *       This software is free software: you can redistribute it and/or modify
 *       it under the terms of the CeCILL-C license as published by
 *       the CEA CNRS INRIA, either version 1
 *       of the License, or (at your option) any later version.
 *       This software 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
 *       CeCILL-C License for more details.
 *
 *       You should have received a copy of the CeCILL-C License
 *       along with this software. If not, it can be found on the official
 * website
 *       of the CeCILL licenses family (http://www.cecill.info/index.en.html).
 */
 
#pragma once
 
#include <set>
#include <string>
namespace pid {
 
class PidVersion {
private:
    unsigned int major_, minor_, patch_;
 
public:
    PidVersion();
    PidVersion(const PidVersion& version);
    PidVersion(const std::string& version);
    PidVersion& operator=(const PidVersion&);
    PidVersion& operator=(const std::string&);
    bool operator<(const PidVersion& other) const;
    bool operator>(const PidVersion& other) const;
    bool operator==(const PidVersion& other) const;
    bool operator!=(const PidVersion& other) const;
    bool operator<=(const PidVersion& other) const;
    bool operator>=(const PidVersion& other) const;
    friend std::ostream& operator<<(std::ostream& stream,
                                    const PidVersion& ver);
 
    bool from_String(const std::string& value);
 
    std::string to_String() const;
};
 
class PidVersionConstraint {
private:
    typedef enum {
        NO_CONSTRAINT,
        EXACT_VERSION,
        IN_RANGE_VERSION, // max version is used
        ANY_VERSION,
        OLDER_EQUAL_THAN_VERSION, // max version is used
        NEWER_EQUAL_THAN_VERSION
    } VersionConstraintType;
 
    VersionConstraintType constraint_; // if exact only min is considered
    PidVersion min_or_exact_version_;
    PidVersion max_version_;
 
public:
    PidVersionConstraint();
    PidVersionConstraint(const PidVersionConstraint& version);
    PidVersionConstraint(const std::string& expression);
    PidVersionConstraint& operator=(const PidVersionConstraint&);
    PidVersionConstraint& operator=(const std::string& expression);
    bool operator!=(const PidVersionConstraint&) const;
    bool operator==(const PidVersionConstraint&) const;
    friend std::ostream& operator<<(std::ostream& stream,
                                    const PidVersionConstraint& ver);
 
    const PidVersion& min() const;
 
    const PidVersion& exact() const;
 
    const PidVersion& max() const;
 
    PidVersion
    select(const std::set< PidVersion >& all_possible_versions) const;
 
    bool from_String(const std::string& value);
 
    std::string to_String() const;
 
    bool undefined() const;
};
 
class PidPath {
 
public:
    PidPath();
    PidPath(const PidPath&);
    virtual ~PidPath();
    bool operator==(const PidPath& compared) const;
    PidPath& operator=(const PidPath& copied);
 
    explicit PidPath(const std::string& str);
 
    PidPath& operator=(const std::string& str);
 
    bool from_String(const std::string& value);
 
    std::string to_String() const;
 
    void set_Dynamic_Path(const std::string& package,
                          const std::string& version, const std::string& path,
                          bool write_new_file);
    void set_Static_Path(const std::string& path, bool write_new_file);
    void set_Dynamic_Component(const std::string& package,
                               const std::string& version,
                               const std::string& component,
                               bool is_executable);
    void set_Static_Component(const std::string& package,
                              const std::string& component, bool is_executable);
 
    std::string resolve();
 
    bool is_Absolute() const;
    bool is_Package_Relative() const;
 
    void write_Target();
 
    bool is_Target_Component() const;
 
    bool is_Target_Executable_Component() const;
 
    bool is_Target_Module_Component() const;
 
    bool is_Target_Written() const;
 
    const std::string& get_Path_Expression() const;
    const std::string& get_Package() const;
 
    const PidVersionConstraint& get_Version() const;
 
private:
    std::string package_;
    PidVersionConstraint version_;
    std::string path_;
    bool write_new_file_;
    bool is_absolute_;
    unsigned char is_component_;
 
    enum RuntimeComponentType { IS_NOT_COMPONENT, IS_MODULE, IS_EXE };
};
} // namespace pid