Software.h

Go to the documentation of this file.

#ifndef __ARC_SOFTWAREVERSION_H__
#define __ARC_SOFTWAREVERSION_H__

#include <list>
#include <utility>
#include <string>
#include <ostream>

#include <arc/Logger.h>

namespace Arc {

  class ApplicationEnvironment;


  class Software {
  public:

    typedef bool (Software::*ComparisonOperator)(const Software&) const;


    Software() : family(""), name(""), version("") {};


    Software(const std::string& name_version);


    Software(const std::string& name, const std::string& version);


    Software(const std::string& family, const std::string& name, const std::string& version);


    enum ComparisonOperatorEnum {
      NOTEQUAL = 0, 
      EQUAL = 1, 
      GREATERTHAN = 2, 
      LESSTHAN = 3, 
      GREATERTHANOREQUAL = 4, 
      LESSTHANOREQUAL = 5 
    };


    static ComparisonOperator convert(const ComparisonOperatorEnum& co);


    bool empty() const { return name.empty(); }


    bool operator==(const Software& sw) const { return family  == sw.family &&
                                                       name    == sw.name &&
                                                       version == sw.version; }

    bool operator!=(const Software& sw) const { return !operator==(sw); }
     

    bool operator> (const Software& sw) const;

    bool operator< (const Software& sw) const { return sw.operator>(*this); }

    bool operator>=(const Software& sw) const { return (*this == sw ? true : *this > sw); }

    bool operator<=(const Software& sw) const { return (*this == sw ? true : *this < sw); }


    friend std::ostream& operator<<(std::ostream& out, const Software& sw) { out << sw(); return out; }


    std::string operator()() const;

    operator std::string(void) const { return operator()(); }


    const std::string& getFamily() const { return family; }

    const std::string& getName() const { return name; }

    const std::string& getVersion() const { return version; }

    const std::list<std::string>& getOptions() const { return option; }

    void addOption(const std::string& opt) { option.push_back(opt); }

    void addOptions(const std::list<std::string>& opts) { option.insert(option.end(),opts.begin(),opts.end()); }


    static std::string toString(ComparisonOperatorEnum co);


    static const std::string VERSIONTOKENS;

  private:
    std::string family;
    std::string name;
    std::string version;
    std::list<std::string> tokenizedVersion;
    std::list<std::string> option;

    static Logger logger;
  };



  class SoftwareRequirement {
  public:

    SoftwareRequirement() {}


    SoftwareRequirement(const Software& sw, Software::ComparisonOperatorEnum co);


    SoftwareRequirement& operator=(const SoftwareRequirement& sr);


    SoftwareRequirement(const SoftwareRequirement& sr) { *this = sr; }


    void add(const Software& sw, Software::ComparisonOperatorEnum co);


    bool isSatisfied(const Software& sw) const { return isSatisfied(std::list<Software>(1, sw)); }

    bool isSatisfied(const std::list<Software>& swList) const { return isSatisfiedSelect(swList); }

    bool isSatisfied(const std::list<ApplicationEnvironment>& swList) const;


    bool selectSoftware(const Software& sw) { return selectSoftware(std::list<Software>(1, sw)); }

    bool selectSoftware(const std::list<Software>& swList);

    bool selectSoftware(const std::list<ApplicationEnvironment>& swList);


    bool isResolved() const;


    bool empty() const { return softwareList.empty(); }

    void clear() { softwareList.clear(); comparisonOperatorList.clear(); }


    const std::list<Software>& getSoftwareList() const { return softwareList; }

    const std::list<Software::ComparisonOperatorEnum>& getComparisonOperatorList() const { return comparisonOperatorList; }

  private:
    std::list<Software> softwareList;
    std::list<Software::ComparisonOperatorEnum> comparisonOperatorList;

    bool isSatisfiedSelect(const std::list<Software>&, SoftwareRequirement* = NULL) const;

    static Logger logger;
  };
} // namespace Arc

#endif // __ARC_SOFTWAREVERSION_H__