relation.hpp

Go to the documentation of this file.

/**************************************************************************
*   Copyright (C) 2010 by Eugene V. Lyubimkin                             *
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License                  *
*   (version 3 or above) as published by the Free Software Foundation.    *
*                                                                         *
*   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 GPL                        *
*   along with this program; if not, write to the                         *
*   Free Software Foundation, Inc.,                                       *
*   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA               *
**************************************************************************/
#ifndef CUPT_CACHE_RELATION_SEEN
#define CUPT_CACHE_RELATION_SEEN
 
 
#include <cupt/common.hpp>
 
namespace cupt {
namespace cache {
 
struct CUPT_API Relation
{
 private:
    CUPT_LOCAL const char* p_parseVersionPart(const char*, const char*);
    CUPT_LOCAL const char* p_parseRelationSymbols(const char*, const char*);
    CUPT_LOCAL const char* p_parsePackagePart(const char*, const char*);
    CUPT_LOCAL const char* __init(const char*, const char*);
 protected:
    Relation(pair<const char*, const char*> input, char const* * end);
 public:
    struct Types
    {
        enum Type { Less, Equal, More, LessOrEqual, MoreOrEqual, LiteralyEqual, None };
        static const string strings[];
    };
    string packageName;
    string architecture;
    Types::Type relationType;
    string versionString;
 
 
    explicit Relation(pair< const char*, const char* > input);
    Relation(Relation&&) = default;
    Relation(const Relation&) = default;
    Relation& operator=(Relation&&) = default;
    Relation& operator=(const Relation&) = default;
    virtual ~Relation();
    string toString() const;
 
    bool isSatisfiedBy(const string& otherVersionString) const;
 
    bool operator==(const Relation& other) const;
};
 
struct CUPT_API ArchitecturedRelation: public Relation
{
 private:
    CUPT_LOCAL const char* p_parseArchitectures(const char*, const char*);
    CUPT_LOCAL const char* p_parseProfiles(const char*, const char*);
    CUPT_LOCAL void __init(const char*, const char*, const char*);
 public:
    vector<string> architectureFilters;
    vector<vector<string>> buildProfiles;
 
 
    explicit ArchitecturedRelation(pair< const char*, const char* > input);
    ArchitecturedRelation(ArchitecturedRelation&&) = default;
    ArchitecturedRelation(const ArchitecturedRelation&) = default;
    ArchitecturedRelation& operator=(ArchitecturedRelation&&) = default;
    ArchitecturedRelation& operator=(const ArchitecturedRelation&) = default;
    string toString() const;
};
 
struct CUPT_API RelationExpression: public vector< Relation >
{
 private:
    CUPT_LOCAL void __init(const char*, const char*);
 public:
    string toString() const;
    string getHashString() const;
 
    RelationExpression();
 
    explicit RelationExpression(const string& input);
 
    explicit RelationExpression(pair< const char*, const char* > input);
    RelationExpression(RelationExpression&&) = default;
    RelationExpression(const RelationExpression&) = default;
    RelationExpression& operator=(RelationExpression&&) = default;
    RelationExpression& operator=(const RelationExpression&) = default;
    virtual ~RelationExpression();
};
 
struct CUPT_API ArchitecturedRelationExpression: public vector< ArchitecturedRelation >
{
 private:
    CUPT_LOCAL void __init(const char*, const char*);
 public:
    string toString() const;
 
    ArchitecturedRelationExpression();
 
    explicit ArchitecturedRelationExpression(const string& input);
 
    explicit ArchitecturedRelationExpression(pair< const char*, const char* > input);
    ArchitecturedRelationExpression(ArchitecturedRelationExpression&&) = default;
    ArchitecturedRelationExpression(const ArchitecturedRelationExpression&) = default;
    ArchitecturedRelationExpression& operator=(ArchitecturedRelationExpression&&) = default;
    ArchitecturedRelationExpression& operator=(const ArchitecturedRelationExpression&) = default;
    virtual ~ArchitecturedRelationExpression();
};
 
struct CUPT_API RelationLine: public vector< RelationExpression >
{
 private:
    CUPT_LOCAL void __init(const char*, const char*);
 public:
    string toString() const;
 
    RelationLine();
 
    explicit RelationLine(const string& input);
 
    explicit RelationLine(pair< const char*, const char* > input);
    RelationLine(RelationLine&&) = default;
    RelationLine(const RelationLine&) = default;
    RelationLine& operator=(RelationLine&&);
    RelationLine& operator=(const RelationLine&) = default;
    virtual ~RelationLine();
};
 
struct CUPT_API ArchitecturedRelationLine: public vector< ArchitecturedRelationExpression >
{
 private:
    CUPT_LOCAL void __init(const char*, const char*);
 public:
    string toString() const;
 
    ArchitecturedRelationLine();
 
    explicit ArchitecturedRelationLine(const string& input);
 
    explicit ArchitecturedRelationLine(pair< const char*, const char* > input);
    ArchitecturedRelationLine(ArchitecturedRelationLine&&) = default;
    ArchitecturedRelationLine(const ArchitecturedRelationLine&) = default;
    ArchitecturedRelationLine& operator=(ArchitecturedRelationLine&&);
    ArchitecturedRelationLine& operator=(const ArchitecturedRelationLine&) = default;
 
    RelationLine toRelationLine(const string& currentArchitecture) const;
    virtual ~ArchitecturedRelationLine();
};
 
}
}
 
#endif