source/target.h

   1 #ifndef TARGET_H_
   2 #define TARGET_H_
   3
   4 #include <list>
   5 #include <map>
   6 #include <set>
   7 #include <string>
   8 #include <sigc++/signal.h>
   9 #include <msp/time/timestamp.h>
  10
  11 class Builder;
  12 class Component;
  13 class SourcePackage;
  14 class Task;
  15 class Tool;
  16
  17 /**
  18 Targets make up the build graph.  This class is a base for all target types and
  19 handles many common tasks.  See also FileTarget and VirtualTarget.
  20 */
  21 class Target
  22 {
  23 public:
  24         typedef std::list<Target *> Dependencies;
  25
  26 protected:
  27         enum State
  28         {
  29                 INIT,
  30                 PREPARING,
  31                 REBUILD,
  32                 BUILDING,
  33                 UPTODATE
  34         };
  35
  36 public:
  37         sigc::signal<void> signal_bubble_rebuild;
  38
  39 protected:
  40         Builder &builder;
  41         const SourcePackage *package;
  42         const Component *component;
  43         std::string name;
  44
  45         const Tool *tool;
  46         State state;
  47         std::string rebuild_reason;
  48
  49         Dependencies depends;
  50
  51         Target(Builder &, const std::string &);
  52 public:
  53         virtual ~Target() { }
  54
  55         virtual const char *get_type() const = 0;
  56         const std::string &get_name() const { return name; }
  57         const SourcePackage *get_package() const { return package; }
  58         const Component *get_component() const { return component; }
  59
  60         /** Adds a dependency for the target.  Order is preseved and is important
  61         for some target types.  It is an error to create dependency cycles, although
  62         this won't be detected until the targets are prepared. */
  63         void add_depend(Target &);
  64
  65 protected:
  66         /** Finds dependencies for the target.  Called during preparation.  If the
  67         target needs to recursively inspect its dependencies, it should prepare its
  68         direct dependencies first. */
  69         virtual void find_depends() { }
  70
  71 public:
  72         /// Returns the dependencies of the target, in the order they were added.
  73         const Dependencies &get_depends() const { return depends; }
  74
  75         /** Tries to locate a target that will help getting this target built.  If
  76         all dependencies are up-to-date, returns this target.  If there are no
  77         targets ready to be built (maybe because they are being built right now),
  78         returns 0. */
  79         virtual Target *get_buildable_target();
  80
  81         /** If this target is a proxy for another (such as InstalledFile), return
  82         that target.  Otherwise, return the target itself.  Implementors should call
  83         the function recursively to find the final target. */
  84         virtual Target *get_real_target() { return this; }
  85
  86         void set_tool(const Tool &);
  87
  88         /** Returns the tool used to build the target.  To actually build it, call
  89         the build() function. */
  90         const Tool *get_tool() const { return tool; }
  91
  92         /** Indicates if it's possible to build this target. */
  93         bool is_buildable() const { return tool!=0; }
  94
  95         /** Indicates if this target needs rebuilding.  Only makes sense after the
  96         target has been prepared. */
  97         bool needs_rebuild() const { return state>PREPARING && state<UPTODATE; }
  98
  99         /** Returns the reason for rebuilding this target.  Only makes sense after
 100         the target has been prepared. */
 101         const std::string &get_rebuild_reason() const { return rebuild_reason; }
 102
 103         /** Forces rebuild of the target. */
 104         void force_rebuild();
 105
 106 protected:
 107         /** Marks the target to be rebuilt and specified a reason for it. */
 108         void mark_rebuild(const std::string &);
 109
 110         /** Checks if the target needs to be rebuilt and why. */
 111         virtual void check_rebuild() = 0;
 112
 113 public:
 114         /** Prepares the target by finding dependencies, recursively preparing them
 115         and then checking whether rebuilding is needed. */
 116         virtual void prepare();
 117
 118         /** Invokes the associated Tool to build the target and returns the
 119         resulting Task.  The task must be started by the caller. */
 120         Task *build();
 121
 122 protected:
 123         /** Handler for Task::signal_finished. */
 124         virtual void build_finished(bool);
 125 };
 126
 127 #endif