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
|
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Copyright 2005-2010 Google, Inc.
// Author: jpr@google.com (Jake Ratkiewicz)
// Definitions of 'scriptable' versions of pdt operations, that is,
// those that can be called with FstClass-type arguments.
// See comments in nlp/fst/script/script-impl.h for how the registration
// mechanism allows these to work with various arc types.
#include <vector>
using std::vector;
#include <utility>
using std::pair; using std::make_pair;
#include <fst/extensions/pdt/compose.h>
#include <fst/extensions/pdt/expand.h>
#include <fst/extensions/pdt/pdtscript.h>
#include <fst/extensions/pdt/replace.h>
#include <fst/extensions/pdt/reverse.h>
#include <fst/extensions/pdt/shortest-path.h>
#include <fst/script/script-impl.h>
namespace fst {
namespace script {
void PdtCompose(const FstClass &ifst1,
const FstClass &ifst2,
const vector<pair<int64, int64> > &parens,
MutableFstClass *ofst,
const ComposeOptions &copts,
bool left_pdt) {
if (!ArcTypesMatch(ifst1, ifst2, "PdtCompose") ||
!ArcTypesMatch(ifst1, *ofst, "PdtCompose")) return;
PdtComposeArgs args(ifst1, ifst2, parens, ofst, copts, left_pdt);
Apply<Operation<PdtComposeArgs> >("PdtCompose", ifst1.ArcType(), &args);
}
void PdtExpand(const FstClass &ifst,
const vector<pair<int64, int64> > &parens,
MutableFstClass *ofst, const PdtExpandOptions &opts) {
PdtExpandArgs args(ifst, parens, ofst, opts);
Apply<Operation<PdtExpandArgs> >("PdtExpand", ifst.ArcType(), &args);
}
void PdtExpand(const FstClass &ifst,
const vector<pair<int64, int64> > &parens,
MutableFstClass *ofst, bool connect) {
PdtExpand(ifst, parens, ofst, PdtExpandOptions(connect));
}
void PdtReplace(const vector<pair<int64, const FstClass*> > &fst_tuples,
MutableFstClass *ofst,
vector<pair<int64, int64> > *parens,
const int64 &root) {
for (unsigned i = 0; i < fst_tuples.size() - 1; ++i) {
if (!ArcTypesMatch(*(fst_tuples[i].second),
*(fst_tuples[i+1].second), "PdtReplace")) return;
}
if (!ArcTypesMatch((*fst_tuples[0].second), *ofst, "PdtReplace")) return;
PdtReplaceArgs args(fst_tuples, ofst, parens, root);
Apply<Operation<PdtReplaceArgs> >("PdtReplace", ofst->ArcType(), &args);
}
void PdtReverse(const FstClass &ifst,
const vector<pair<int64, int64> > &parens,
MutableFstClass *ofst) {
PdtReverseArgs args(ifst, parens, ofst);
Apply<Operation<PdtReverseArgs> >("PdtReverse", ifst.ArcType(), &args);
}
void PdtShortestPath(const FstClass &ifst,
const vector<pair<int64, int64> > &parens,
MutableFstClass *ofst,
const PdtShortestPathOptions &opts) {
PdtShortestPathArgs args(ifst, parens, ofst, opts);
Apply<Operation<PdtShortestPathArgs> >("PdtShortestPath",
ifst.ArcType(), &args);
}
void PrintPdtInfo(const FstClass &ifst,
const vector<pair<int64, int64> > &parens) {
PrintPdtInfoArgs args(ifst, parens);
Apply<Operation<PrintPdtInfoArgs> >("PrintPdtInfo", ifst.ArcType(), &args);
}
// Register operations for common arc types.
REGISTER_FST_PDT_OPERATIONS(StdArc);
REGISTER_FST_PDT_OPERATIONS(LogArc);
REGISTER_FST_PDT_OPERATIONS(Log64Arc);
} // namespace script
} // namespace fst
|
