This file is indexed.

/usr/include/hfst/implementations/ComposeIntersectLexicon.h is in libhfst45-dev 3.10.0~r2798-3.

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
// Copyright (c) 2016 University of Helsinki                          
//                                                                    
// This library is free software; you can redistribute it and/or      
// modify it under the terms of the GNU Lesser General Public         
// License as published by the Free Software Foundation; either       
// version 3 of the License, or (at your option) any later version.
// See the file COPYING included with this distribution for more      
// information.
#ifndef COMPOSE_INTERSECT_LEXICON_H
#define COMPOSE_INTERSECT_LEXICON_H

#include <queue>
#include <set>

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include "ComposeIntersectFst.h"
#include "ComposeIntersectRulePair.h"

namespace hfst
{
  namespace implementations
  {
    class ComposeIntersectLexicon : public ComposeIntersectFst
    {
    public:
      typedef ComposeIntersectFst::SymbolTransitionMap SymbolTransitionMap;
      ComposeIntersectLexicon(const HfstBasicTransducer &);
      ComposeIntersectLexicon(void);
      HfstBasicTransducer compose_with_rules(ComposeIntersectRule *);
    protected:
      typedef std::pair<HfstState,HfstState> StatePair;
      typedef std::map<StatePair,HfstState> StatePairMap;
      typedef std::set<HfstState> StateSet;

      typedef std::vector<StatePair> PairVector;
      typedef std::queue<HfstState> StateQueue;


      StatePairMap state_pair_map;
      PairVector   pair_vector;
      StateQueue   agenda;
      HfstBasicTransducer result;
      StateSet lexicon_non_epsilon_states;

      bool is_flag_diacritic(size_t);
      HfstState get_state(const StatePair &, bool allow_lexicon_epsilons=true);
      StatePair get_pair(HfstState);
      void clear_all_info(void);
      HfstState map_state_and_add_to_agenda(const StatePair &, 
                                            bool allow_lexicon_epsilons);
      HfstBasicTransducer &compute_composition_result
    (ComposeIntersectRule *);
      void compute_state(HfstState state,ComposeIntersectRule *,
                         bool allow_lexicon_epsilons);
      bool can_have_lexicon_epsilons(HfstState s);
      void set_final_state_weights(ComposeIntersectRule *);
      void lexicon_skip_symbol_compose
    (const TransitionSet &,HfstState,HfstState);
      void rule_skip_symbol_compose(const TransitionSet &,HfstState,HfstState);
      void compose(const TransitionSet &,const TransitionSet &,HfstState);
      void add_transition
    (HfstState, size_t,size_t,float,HfstState);
      void identity_compose
    (const TransitionSet &,const HfstBasicTransition &,HfstState);
    };
  }
}

#endif