File: restrictions.hh

package info (click to toggle)
monotone 0.48-3
  • links: PTS
  • area: main
  • in suites: squeeze
  • size: 20,096 kB
  • ctags: 8,077
  • sloc: cpp: 81,000; sh: 6,402; perl: 1,241; lisp: 1,045; makefile: 655; python: 566; sql: 112; ansic: 52
file content (171 lines) | stat: -rw-r--r-- 5,239 bytes parent folder | download
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
// Copyright (C) 2005 Derek Scherger <derek@echologic.com>
//
// This program is made available under the GNU GPL version 2.0 or
// greater. See the accompanying file COPYING for details.
//
// This program is distributed WITHOUT ANY WARRANTY; without even the
// implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE.

#ifndef __RESTRICTIONS_HH__
#define __RESTRICTIONS_HH__

// the following commands accept file arguments and --exclude and --depth
// options used to define a restriction on the files that will be processed:
//
// ls unknown
// ls ignored
// ls missing
// ls known
// status
// diff
// commit
// revert
// log
//
// it is important that these commands operate on the same set of files given
// the same restriction specification.  this allows for destructive commands
// (commit and revert) to be "tested" first with non-destructive commands
// (ls unknown/ignored/missing/known, status, diff)

#include <set>
#include "vocab.hh"
#include "rev_types.hh"
#include "paths.hh"

// between any two related revisions, A and B, there is a set of changes (a
// cset) that describes the operations required to get from A to B. for
// example:
//
// revision A ... changes ... revision B
//
// a restriction is a means of masking off some of these changes to produce
// a third revision, X that lies somewhere between A and B.  changes
// included by the restriction when applied to revision A would produce
// revision X.  changes excluded by the restriction when applied to revision
// X would produce revision B.
//
// conceptually, a restriction allows for something like a sliding control
// for selecting the changes between revisions A and B. when the control is
// "all the way to the right" all changes are included and X == B. when then
// control is "all the way to the left" no changes are included and
// X == A. when the control is somewhere between these extremes X is a new
// revision.
//
// revision A ... included ... revision X ... excluded ... revision B

namespace restricted_path
{
  enum status
    {
      included,
      excluded,
      required, 
      included_required,
      excluded_required
    };
}

class restriction
{
 public:
  bool empty() const
  { return included_paths.empty() && excluded_paths.empty(); }

  enum include_rules
    {
      explicit_includes, 
      implicit_includes
    };

 protected:
  restriction() : depth(-1) {}

  restriction(std::vector<file_path> const & includes,
              std::vector<file_path> const & excludes,
              long depth);

  std::set<file_path> included_paths, excluded_paths;
  long depth;
};

class node_restriction : public restriction
{
 public:
  node_restriction() : restriction() {}

  node_restriction(std::vector<file_path> const & includes,
                   std::vector<file_path> const & excludes,
                   long depth,
                   roster_t const & roster,
                   path_predicate<file_path> const & ignore_file
                   = path_always_false<file_path>());

  node_restriction(std::vector<file_path> const & includes,
                   std::vector<file_path> const & excludes,
                   long depth,
                   roster_t const & roster1,
                   roster_t const & roster2,
                   path_predicate<file_path> const & ignore_file
                   = path_always_false<file_path>(),
                   include_rules const & rules = implicit_includes);

  node_restriction(std::vector<file_path> const & includes,
                   std::vector<file_path> const & excludes,
                   long depth,
                   parent_map const & rosters1,
                   roster_t const & roster2,
                   path_predicate<file_path> const & ignore_file
                   = path_always_false<file_path>());

  bool includes(roster_t const & roster, node_id nid) const;

  node_restriction & operator=(node_restriction const & other)
  {
    included_paths = other.included_paths;
    excluded_paths = other.excluded_paths;
    depth = other.depth;
    known_paths = other.known_paths;
    node_map = other.node_map;
    return *this;
  }

 private:
  std::set<file_path> known_paths;
  std::map<node_id, restricted_path::status> node_map;
};

class path_restriction : public restriction
{
 public:
  enum skip_check_t { skip_check };

  path_restriction() : restriction() {}

  path_restriction(std::vector<file_path> const & includes,
                   std::vector<file_path> const & excludes,
                   long depth,
                   path_predicate<file_path> const & ignore_file
                   = path_always_false<file_path>());

  // Skipping validity checks makes the path_predicate irrelevant.
  path_restriction(std::vector<file_path> const & includes,
                   std::vector<file_path> const & excludes,
                   long depth,
                   skip_check_t);

  bool includes(file_path const & sp) const;

 private:
  std::map<file_path, restricted_path::status> path_map;
};

#endif  // header guard

// Local Variables:
// mode: C++
// fill-column: 76
// c-file-style: "gnu"
// indent-tabs-mode: nil
// End:
// vim: et:sw=2:sts=2:ts=2:cino=>2s,{s,\:s,+s,t0,g0,^-2,e-2,n-2,p2s,(0,=s: