This file is indexed.

/usr/include/gecode/kernel/brancher-val-commit.hpp is in libgecode-dev 4.4.0-5.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  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
/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
 *  Main author:
 *     Christian Schulte <schulte@gecode.org>
 *
 *  Copyright:
 *     Christian Schulte, 2012
 *
 *  Last modified:
 *     $Date: 2013-07-04 17:03:13 +0200 (Thu, 04 Jul 2013) $ by $Author: schulte $
 *     $Revision: 13801 $
 *
 *  This file is part of Gecode, the generic constraint
 *  development environment:
 *     http://www.gecode.org
 *
 *  Permission is hereby granted, free of charge, to any person obtaining
 *  a copy of this software and associated documentation files (the
 *  "Software"), to deal in the Software without restriction, including
 *  without limitation the rights to use, copy, modify, merge, publish,
 *  distribute, sublicense, and/or sell copies of the Software, and to
 *  permit persons to whom the Software is furnished to do so, subject to
 *  the following conditions:
 *
 *  The above copyright notice and this permission notice shall be
 *  included in all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */

namespace Gecode {

  /**
   * \defgroup TaskBranchValCommit Generic value commit for brancher based on view and value selection
   *
   * \ingroup TaskBranchViewVal
   */
  //@{
  /// Base class for value commit
  template<class _View, class _Val>
  class ValCommit {
  public:
    /// View type
    typedef _View View;
    /// Value type
    typedef _Val Val;
  public:
    /// Constructor for initialization
    ValCommit(Space& home, const ValBranch& vb);
    /// Constructor for cloning
    ValCommit(Space& home, bool shared, ValCommit<View,Val>& vs);
    /// Whether dispose must always be called (that is, notice is needed)
    bool notice(void) const;
    /// Delete value commit
    void dispose(Space& home);
  };

  /// Class for user-defined value commit
  template<class View>
  class ValCommitFunction : public 
  ValCommit<View,
            typename BranchTraits<typename View::VarType>::ValType> {
    typedef typename ValCommit<View,
                               typename BranchTraits<typename View::VarType>
                                 ::ValType>::Val Val;
  public:
    /// The corresponding variable type
    typedef typename View::VarType Var;
    /// The corresponding commit function
    typedef typename BranchTraits<Var>::Commit CommitFunction;
  protected:
    /// The user-defined commit function
    CommitFunction c;
  public:
    /// Constructor for initialization
    ValCommitFunction(Space& home, const ValBranch& vb);
    /// Constructor for cloning during copying
    ValCommitFunction(Space& home, bool shared, ValCommitFunction& vc);
    /// Perform user-defined commit
    ModEvent commit(Space& home, unsigned int a, View x, int i, Val n);
    /// Create no-good literal for alternative \a a
    NGL* ngl(Space& home, unsigned int a, View x, Val n) const;
    /// Print on \a o the alternative \a with view \a x at position \a i and value \a n
    void print(const Space& home, unsigned int a, View x, int i, 
               const Val& n, std::ostream& o) const;
  };
  //@}

  // Baseclass for value commit
  template<class View, class Val>
  forceinline
  ValCommit<View,Val>::ValCommit(Space&, const ValBranch&) {}
  template<class View, class Val>
  forceinline
  ValCommit<View,Val>::ValCommit(Space&, bool, ValCommit<View,Val>&) {}
  template<class View, class Val>
  forceinline bool
  ValCommit<View,Val>::notice(void) const {
    return false;
  }
  template<class View, class Val>
  forceinline void
  ValCommit<View,Val>::dispose(Space&) {}


  // User-defined value selection
  template<class View>
  forceinline
  ValCommitFunction<View>::ValCommitFunction(Space& home, 
                                             const ValBranch& vb) 
    : ValCommit<View,Val>(home,vb),
      c(function_cast<CommitFunction>(vb.commit())) {}
  template<class View>
  forceinline
  ValCommitFunction<View>::ValCommitFunction(Space& home, bool shared, 
                                             ValCommitFunction<View>& vc) 
    : ValCommit<View,Val>(home,shared,vc), c(vc.c) {}
  template<class View>
  forceinline ModEvent
  ValCommitFunction<View>::commit(Space& home, unsigned int a, View x, int i, 
                                  Val n) {
    typename View::VarType y(x.varimp());
    c(home,a,y,i,n);
    return home.failed() ? ES_FAILED : ES_OK;
  }
  template<class View>
  forceinline NGL*
  ValCommitFunction<View>::ngl(Space&, unsigned int, View, Val) const {
    return NULL;
  }
  template<class View>
  forceinline void
  ValCommitFunction<View>::print(const Space&, unsigned int, 
                                 View, int i, const Val&,
                                 std::ostream& o) const {
    o << "var[" << i << "] is user-defined.";
  }

}

// STATISTICS: kernel-branch