libpuma-dev 1:1.1+svn20120529-2 / usr / include / lexertl / partition / equivset.hpp

This file is indexed.

/usr/include/lexertl/partition/equivset.hpp is in libpuma-dev 1:1.1+svn20120529-2.

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
// equivset.hpp
// Copyright (c) 2005-2011 Ben Hanson (http://www.benhanson.net/)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef LEXERTL_EQUIVSET_HPP
#define LEXERTL_EQUIVSET_HPP

#include <algorithm>
#include "../parser/tree/node.hpp"
#include <set>

namespace lexertl
{
namespace detail
{
template<typename id_type>
struct basic_equivset
{
    typedef std::set<id_type> index_set;
    typedef std::vector<id_type> index_vector;
    // Not owner of nodes:
    typedef basic_node<id_type> node;
    typedef std::vector<node *> node_vector;

    index_vector _index_vector;
    id_type _id;
    bool _greedy;
    node_vector _followpos;

    basic_equivset () :
        _id (0),
        _greedy (true)
    {
    }

    basic_equivset (const index_set &index_set_, const id_type id_,
        const bool greedy_, const node_vector &followpos_) :
        _index_vector (index_set_.begin (), index_set_.end ()),
        _id (id_),
        _greedy (greedy_),
        _followpos (followpos_)
    {
    }

    bool empty () const
    {
        return _index_vector.empty () && _followpos.empty ();
    }

    void intersect (basic_equivset &rhs_, basic_equivset &overlap_)
    {
        intersect_indexes (rhs_._index_vector, overlap_._index_vector);

        if (!overlap_._index_vector.empty ())
        {
            // Note that the LHS takes priority in order to
            // respect rule ordering priority in the lex spec.
            overlap_._id = _id;
            overlap_._greedy = _greedy;
            overlap_._followpos = _followpos;

            typename node_vector::const_iterator overlap_begin_ =
                overlap_._followpos.begin ();
            typename node_vector::const_iterator overlap_end_ =
                overlap_._followpos.end ();
            typename node_vector::const_iterator rhs_iter_ =
                rhs_._followpos.begin ();
            typename node_vector::const_iterator rhs_end_ =
                rhs_._followpos.end ();

            for (; rhs_iter_ != rhs_end_; ++rhs_iter_)
            {
                node *node_ = *rhs_iter_;

                if (std::find (overlap_begin_, overlap_end_, node_) ==
                    overlap_end_)
                {
                    overlap_._followpos.push_back (node_);
                    overlap_begin_ = overlap_._followpos.begin ();
                    overlap_end_ = overlap_._followpos.end ();
                }
            }

            if (_index_vector.empty ())
            {
                _followpos.clear ();
            }

            if (rhs_._index_vector.empty ())
            {
                rhs_._followpos.clear ();
            }
        }
    }

private:
    void intersect_indexes (index_vector &rhs_, index_vector &overlap_)
    {
        typename index_vector::iterator iter_ = _index_vector.begin ();
        typename index_vector::iterator end_ = _index_vector.end ();
        typename index_vector::iterator rhs_iter_ = rhs_.begin ();
        typename index_vector::iterator rhs_end_ = rhs_.end ();

        while (iter_ != end_ && rhs_iter_ != rhs_end_)
        {
            const id_type index_ = *iter_;
            const id_type rhs_index_ = *rhs_iter_;

            if (index_ < rhs_index_)
            {
                ++iter_;
            }
            else if (index_ > rhs_index_)
            {
                ++rhs_iter_;
            }
            else
            {
                overlap_.push_back (index_);
                iter_ = _index_vector.erase (iter_);
                end_ = _index_vector.end ();
                rhs_iter_ = rhs_.erase (rhs_iter_);
                rhs_end_ = rhs_.end ();
            }
        }
    }
};
}
}

#endif

APT Browse - Built by Thomas Orozco.