weight.cc
3.84 KB
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
#include <fst/weight.h>
DEFINE_string(fst_weight_separator, ",",
"Character separator between printed composite weights; "
"must be a single character");
DEFINE_string(fst_weight_parentheses, "",
"Characters enclosing the first weight of a printed composite "
"weight (e.g., pair weight, tuple weight and derived classes) to "
"ensure proper I/O of nested composite weights; "
"must have size 0 (none) or 2 (open and close parenthesis)");
namespace fst {
namespace internal {
CompositeWeightIO::CompositeWeightIO(char separator,
std::pair<char, char> parentheses)
: separator_(separator),
open_paren_(parentheses.first),
close_paren_(parentheses.second),
error_(false) {
if ((open_paren_ == 0 || close_paren_ == 0) && open_paren_ != close_paren_) {
FSTERROR() << "Invalid configuration of weight parentheses: "
<< static_cast<int>(open_paren_) << " "
<< static_cast<int>(close_paren_);
error_ = true;
}
}
CompositeWeightIO::CompositeWeightIO()
: CompositeWeightIO(FLAGS_fst_weight_separator.empty()
? 0
: FLAGS_fst_weight_separator.front(),
{FLAGS_fst_weight_parentheses.empty()
? 0
: FLAGS_fst_weight_parentheses[0],
FLAGS_fst_weight_parentheses.size() < 2
? 0
: FLAGS_fst_weight_parentheses[1]}) {
if (FLAGS_fst_weight_separator.size() != 1) {
FSTERROR() << "CompositeWeight: "
<< "FLAGS_fst_weight_separator.size() is not equal to 1";
error_ = true;
}
if (!FLAGS_fst_weight_parentheses.empty() &&
FLAGS_fst_weight_parentheses.size() != 2) {
FSTERROR() << "CompositeWeight: "
<< "FLAGS_fst_weight_parentheses.size() is not equal to 2";
error_ = true;
}
}
} // namespace internal
CompositeWeightWriter::CompositeWeightWriter(std::ostream &ostrm)
: ostrm_(ostrm) {
if (error()) ostrm.clear(std::ios::badbit);
}
CompositeWeightWriter::CompositeWeightWriter(std::ostream &ostrm,
char separator,
std::pair<char, char> parentheses)
: internal::CompositeWeightIO(separator, parentheses), ostrm_(ostrm) {
if (error()) ostrm_.clear(std::ios::badbit);
}
void CompositeWeightWriter::WriteBegin() {
if (open_paren_ != 0) {
ostrm_ << open_paren_;
}
}
void CompositeWeightWriter::WriteEnd() {
if (close_paren_ != 0) {
ostrm_ << close_paren_;
}
}
CompositeWeightReader::CompositeWeightReader(std::istream &istrm)
: istrm_(istrm) {
if (error()) istrm_.clear(std::ios::badbit);
}
CompositeWeightReader::CompositeWeightReader(std::istream &istrm,
char separator,
std::pair<char, char> parentheses)
: internal::CompositeWeightIO(separator, parentheses), istrm_(istrm) {
if (error()) istrm_.clear(std::ios::badbit);
}
void CompositeWeightReader::ReadBegin() {
do { // Skips whitespace.
c_ = istrm_.get();
} while (std::isspace(c_));
if (open_paren_ != 0) {
if (c_ != open_paren_) {
FSTERROR() << "CompositeWeightReader: Open paren missing: "
<< "fst_weight_parentheses flag set correcty?";
istrm_.clear(std::ios::badbit);
return;
}
++depth_;
c_ = istrm_.get();
}
}
void CompositeWeightReader::ReadEnd() {
if (c_ != EOF && !std::isspace(c_)) {
FSTERROR() << "CompositeWeightReader: excess character: '"
<< static_cast<char>(c_)
<< "': fst_weight_parentheses flag set correcty?";
istrm_.clear(std::ios::badbit);
}
}
} // namespace fst