PDG_Filter.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * COMMENTS:
 */

#ifndef PDG_FILTER_H
#define PDG_FILTER_H

#include "PDG_API.h"
#include "PDG_Types.h"
 
/**
 * An item id filter that describes what static item ids to cook. The filter is
 * either a single id, a range of ids or a set of ids.
 */
class PDG_API PDG_Filter
{
public:
    /// Storage method the filter uses to keep track of ids
    enum Type
    {
        eSingle,    /// A single item id
        eRange,     /// An inclusive range of item ids
        eSet,       /// A set of aribitrary ids, possibly disjoint
        eInvalid,   /// An invalid filter that cannot be used
    };


    /// Constructs a new filter, which is all by default
    PDG_Filter()
        : myType(eSingle)
        , myIsStrict(false)
    {
    }

    /// Constructs a filter with a specific value for the Strict flag. A Strict
    /// filter will cook exactly the desired static item set, not the set +
    /// other dependencies
    PDG_Filter(bool is_strict)
        : myType(eSingle)
        , myIsStrict(is_strict)
    {
    }

    /// Returns true if the filter is set to cook all static items
    bool isAll() const
    {
        return (myType != eInvalid) && mySet.empty();
    }

    /// Returns true if the given id matches that ones that this filter
    /// wishes to cook
    bool apply(PDG_WorkItemID id) const
    {
        if (myType == eInvalid)
            return false;
        else if (mySet.size() == 0)
            return true;

        return mySet.contains(id);
    }

    /// Configures the filter to cook nothing
    void setNone()
    {
        myType = eInvalid;
        mySet.clear();
    }

    /// Configures the filter so that it specifies all static items
    void setAll()
    {
        myType = eSingle;
        mySet.clear();
    }

    /// Configures the filter to cook a single static item
    void setSingle(PDG_WorkItemID single)
    {
        myType = eSingle;

        mySet.clear();
        mySet.insert(single);
    }

    /// Configures the filter to cook an inclusive range of work items
    void setRange(PDG_WorkItemID start, PDG_WorkItemID end)
    {
        myType = eRange;

        mySet.clear();
        for (int i = start; i <= end; i++)
            mySet.insert(i);
    }

    /// Configures the filter to cook a set of items
    void setSet(const PDG_WorkItemIDSet& set)
    {
        myType = eSet;
        mySet = set;
    }

    /// Appends an id to the set of static items to cook
    void appendToSet(PDG_WorkItemID id)
    {
        if (myType != eSingle || !mySet.empty())
        {
            myType = eSet;
            mySet.insert(id);
        }
    }

    void eraseFromSet(PDG_WorkItemID id)
    {
        mySet.erase(id);
    }

    /// Returns the filter cook type
    Type                        type() const    { return myType; }

    /// Returns the filter id set
    const PDG_WorkItemIDSet&    set() const     { return mySet; }

    /// Returns true if the filter is strict
    bool                        strict() const  { return myIsStrict; }

private:
    Type                        myType;
    PDG_WorkItemIDSet           mySet;
    bool                        myIsStrict;
};

#endif