lib/codegen/DependencySet.h

Go to the documentation of this file.

//===-- codegen/DependencySet.h ------------------------------- -*- C++ -*-===//
//
// This file is distributed under the MIT license. See LICENSE.txt for details.
//
// Copyright (C) 2009, Stephen Wilson
//
//===----------------------------------------------------------------------===//

//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//

#ifndef COMMA_CODEGEN_DEPENDENCYSET_HDR_GUARD
#define COMMA_CODEGEN_DEPENDENCYSET_HDR_GUARD

#include "llvm/ADT/UniqueVector.h"

#include <iterator>

namespace comma {

class DependencySet;
class DomainInstanceDecl;
class Domoid;

class DependencySetIterator
    : public std::iterator<std::bidirectional_iterator_tag,
                           const DomainInstanceDecl*> {

    const DependencySet *DS;
    unsigned index;

    DependencySetIterator(const DependencySet *DS) : DS(DS), index(0) { }

    DependencySetIterator(const DependencySet *DS, unsigned index)
        : DS(DS), index(index) { }

    friend class DependencySet;

public:
    bool operator ==(const DependencySetIterator &iter) const {
        return (DS == iter.DS && index == iter.index);
    }

    bool operator !=(const DependencySetIterator &iter) const {
        return !(*this == iter);
    }

    DependencySetIterator &operator++() {
        index++;
        return *this;
    }

    DependencySetIterator operator++(int) {
        DependencySetIterator res = *this;
        index++;
        return res;
    }

    DependencySetIterator &operator--() {
        index--;
        return *this;
    }

    DependencySetIterator operator--(int) {
        DependencySetIterator res = *this;
        index--;
        return res;
    }

    const DomainInstanceDecl *operator*() const;

    const DomainInstanceDecl *operator->() const;
};

class DependencySet {

    typedef llvm::UniqueVector<const DomainInstanceDecl*> DependenceVector;

    const Domoid *capsule;
    DependenceVector dependents;

public:
    DependencySet(const Domoid *domoid) : capsule(domoid) { scan(); }

    typedef DependencySetIterator iterator;
    iterator begin() const { return DependencySetIterator(this); }
    iterator end() const { return DependencySetIterator(this, size()); }

    // Returns the capsule this dependency set represents.
    const Domoid *getCapsule() const { return capsule; }

    unsigned getDependentID(iterator I) const {
        return dependents.idFor(*I) - 1;
    }

    const DomainInstanceDecl *getDependent(unsigned ID) const {
        return dependents[ID + 1];
    }

    iterator find(const DomainInstanceDecl *instance) const;

    unsigned size() const { return dependents.size(); }

private:
    void scan();
};

inline const DomainInstanceDecl *DependencySetIterator::operator*() const {
    return DS->getDependent(index);
}

inline const DomainInstanceDecl *DependencySetIterator::operator->() const {
    return DS->getDependent(index);
}

} // end comma namespace.

#endif

---