aboutsummaryrefslogtreecommitdiff
path: root/build/name
blob: ecf86cc38cb46e1508a07e9ac413ba1d6de11a24 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
// file      : build/name -*- C++ -*-
// copyright : Copyright (c) 2014-2015 Code Synthesis Ltd
// license   : MIT; see accompanying LICENSE file

#ifndef BUILD_NAME
#define BUILD_NAME

#include <string>
#include <vector>
#include <iosfwd>
#include <utility> // move()

#include <butl/path>

// Note: include <build/types> instead of this file directly.
//
namespace build
{
  using butl::dir_path;

  // A name is what we operate on by default. Depending on the context,
  // it can be interpreted as a target or prerequisite name. A name
  // without a type and directory can be used to represent any text.
  // A name with directory and empty value represents a directory.
  // A name may also be project-qualified. If the project name is
  // empty, then it means the name is in a project other than our
  // own (e.g., it is installed).
  //
  // If pair is not '\0', then this name and the next in the list
  // form a pair.
  //
  struct name
  {
    name () = default;

    explicit name (std::string v): value (std::move (v)) {}
    name& operator= (std::string v) {return *this = name (std::move (v));}

    explicit name (dir_path d): dir (std::move (d)) {}
    name& operator= (dir_path d) {return *this = name (std::move (d));}

    name (std::string t, std::string v)
        : type (std::move (t)), value (std::move (v)) {}

    name (dir_path d, std::string t, std::string v)
        : dir (std::move (d)), type (std::move (t)), value (std::move (v)) {}

    // The first argument should be from project_name_pool.
    //
    name (const std::string* p, dir_path d, std::string t, std::string v)
        : proj (p),
          dir (std::move (d)),
          type (std::move (t)),
          value (std::move (v)) {}

    bool
    qualified () const {return proj != nullptr;}

    bool
    unqualified () const {return proj == nullptr;}

    bool
    typed () const {return !type.empty ();}

    bool
    untyped () const {return type.empty ();}

    bool
    empty () const {return dir.empty () && value.empty ();}

    // Note that strictly speaking the following tests should be
    // orthogonal to qualification. However, the vast majority of
    // cases where we expect a simple or directory name, we also
    // expect it to be unqualified.
    //
    // Note also that empty name is simple but not a directory.
    //
    bool
    simple () const {return unqualified () && untyped () && dir.empty ();}

    bool
    directory () const
    {return unqualified () && untyped () && !dir.empty () && value.empty ();}

    const std::string* proj = nullptr; // Points to project_name_pool.
    dir_path dir;
    std::string type;
    std::string value;
    char pair = '\0'; // Pair symbol, if any.
  };

  inline bool
  operator== (const name& x, const name& y)
  {
    return x.proj == y.proj && // Pooled, so can just compare pointers.
      x.type == y.type &&
      x.dir == y.dir &&
      x.value == y.value;
  }

  inline bool
  operator!= (const name& x, const name& y) {return !(x == y);}

  typedef std::vector<name> names;

  std::ostream&
  operator<< (std::ostream&, const name&);

  std::ostream&
  operator<< (std::ostream&, const names&);
}

#endif // BUILD_NAME