Remove most container typedefs and refactor others

[builder.git] / source / target.h

diff --git a/source/target.h b/source/target.h
index 62b67218480184d1888bd5a0d6c6a503ecf1f674..c4a822b48df43f5747479c67bc7e955ee0ce1031 100644 (file)
--- a/source/target.h
+++ b/source/target.h
@@ -9,6 +9,7 @@
 #include <msp/time/timestamp.h>
 
 class Builder;
+class BuildInfo;
 class Component;
 class SourcePackage;
 class Task;
@@ -17,11 +18,16 @@ class Tool;
 /**
 Targets make up the build graph.  This class is a base for all target types and
 handles many common tasks.  See also FileTarget and VirtualTarget.
+
+Targets can depend on other targets.  There are two kinds of dependencies:
+normal and transitive.  Normal dependencies will need to be built before the
+target itself, and will cause the target to be rebuilt if modified.  Transitive
+dependencies can be used by other targets further down the chain.
 */
 class Target
 {
 public:
-       typedef std::list<Target *> Dependencies;
+       using Dependencies = std::list<Target *>;
 
 protected:
        enum State
@@ -30,11 +36,13 @@ protected:
                PREPARING,
                REBUILD,
                BUILDING,
-               UPTODATE
+               UPTODATE,
+               BROKEN
        };
 
 public:
        sigc::signal<void> signal_bubble_rebuild;
+       sigc::signal<void> signal_modified;
 
 protected:
        Builder &builder;
@@ -42,11 +50,15 @@ protected:
        const Component *component;
        std::string name;
 
-       const Tool *tool;
+       Tool *tool;
        State state;
        std::string rebuild_reason;
+       std::list<std::string> problems;
 
        Dependencies depends;
+       Dependencies trans_depends;
+       Dependencies side_effects;
+       Target *primary_target;
 
        Target(Builder &, const std::string &);
 public:
@@ -60,17 +72,31 @@ public:
        /** Adds a dependency for the target.  Order is preseved and is important
        for some target types.  It is an error to create dependency cycles, although
        this won't be detected until the targets are prepared. */
-       void add_depend(Target &);
+       void add_dependency(Target &);
+
+       void add_transitive_dependency(Target &);
+
+       /** Adds a side effect for the target.  Side effects are not built on their
+       own, but together with their primary target. */
+       void add_side_effect(Target &);
 
 protected:
        /** Finds dependencies for the target.  Called during preparation.  If the
        target needs to recursively inspect its dependencies, it should prepare its
        direct dependencies first. */
-       virtual void find_depends() { }
+       virtual void find_dependencies() { }
 
 public:
        /// Returns the dependencies of the target, in the order they were added.
-       const Dependencies &get_depends() const { return depends; }
+       const Dependencies &get_dependencies() const { return depends; }
+
+       const Dependencies &get_transitive_dependencies() const { return trans_depends; }
+
+       /// Returns the side effects of the target.
+       const Dependencies &get_side_effects() const { return side_effects; }
+
+       /// Returns the primary target associated with a side effect target.
+       Target *get_primary_target() const { return primary_target; }
 
        /** Tries to locate a target that will help getting this target built.  If
        all dependencies are up-to-date, returns this target.  If there are no
@@ -83,12 +109,14 @@ public:
        the function recursively to find the final target. */
        virtual Target *get_real_target() { return this; }
 
-       void set_tool(const Tool &);
+       void set_tool(Tool &);
 
        /** Returns the tool used to build the target.  To actually build it, call
        the build() function. */
        const Tool *get_tool() const { return tool; }
 
+       virtual void collect_build_info(BuildInfo &) const;
+
        /** Indicates if it's possible to build this target. */
        bool is_buildable() const { return tool!=0; }
 
@@ -111,6 +139,10 @@ protected:
        virtual void check_rebuild() = 0;
 
 public:
+       bool is_broken() const { return state==BROKEN; }
+
+       const std::list<std::string> &get_problems() const { return problems; }
+
        /** Prepares the target by finding dependencies, recursively preparing them
        and then checking whether rebuilding is needed. */
        void prepare();
@@ -120,8 +152,18 @@ public:
        virtual Task *build();
 
 protected:
+       /** Targets can override this to do additional setup on the Task.  This is
+       also called on side effects, which normally do not get built by themselves. */
+       virtual void build(Task &) { }
+
        /** Handler for Task::signal_finished. */
        virtual void build_finished(bool);
+
+       virtual void modified() { }
+
+public:
+       /** Removes any results of building the target. */
+       virtual void clean() { }
 };
 
 #endif