FST  openfst-1.8.2
OpenFst Library
arciterator-class.h
Go to the documentation of this file.
1 // Copyright 2005-2020 Google LLC
2 //
3 // Licensed under the Apache License, Version 2.0 (the 'License');
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an 'AS IS' BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 //
15 // See www.openfst.org for extensive documentation on this weighted
16 // finite-state transducer library.
17 
18 #ifndef FST_SCRIPT_ARCITERATOR_CLASS_H_
19 #define FST_SCRIPT_ARCITERATOR_CLASS_H_
20 
21 #include <cstdint>
22 #include <memory>
23 #include <utility>
24 
25 #include <fst/fstlib.h>
26 #include <fst/script/fst-class.h>
27 
28 // Scripting API support for ArcIterator.
29 //
30 // A call to Value() causes the underlying arc to be used to construct the
31 // associated ArcClass.
32 
33 namespace fst {
34 namespace script {
35 
36 // Non-mutable arc iterators.
37 
38 // Virtual interface implemented by each concrete ArcIteratorImpl<F>.
40  public:
41  virtual bool Done() const = 0;
42  virtual uint8_t Flags() const = 0;
43  virtual void Next() = 0;
44  virtual size_t Position() const = 0;
45  virtual void Reset() = 0;
46  virtual void Seek(size_t a) = 0;
47  virtual void SetFlags(uint8_t flags, uint8_t mask) = 0;
48  virtual ArcClass Value() const = 0;
49  virtual ~ArcIteratorImplBase() {}
50 };
51 
52 // Templated implementation.
53 template <class Arc>
55  public:
56  explicit ArcIteratorClassImpl(const Fst<Arc> &fst, int64_t s)
57  : aiter_(fst, s) {}
58 
59  bool Done() const final { return aiter_.Done(); }
60 
61  uint8_t Flags() const final { return aiter_.Flags(); }
62 
63  void Next() final { aiter_.Next(); }
64 
65  size_t Position() const final { return aiter_.Position(); }
66 
67  void Reset() final { aiter_.Reset(); }
68 
69  void Seek(size_t a) final { aiter_.Seek(a); }
70 
71  void SetFlags(uint8_t flags, uint8_t mask) final {
72  aiter_.SetFlags(flags, mask);
73  }
74 
75  // This is returned by value because it has not yet been constructed, and
76  // is likely to participate in return-value optimization.
77  ArcClass Value() const final { return ArcClass(aiter_.Value()); }
78 
79  ~ArcIteratorClassImpl() override {}
80 
81  private:
82  ArcIterator<Fst<Arc>> aiter_;
83 };
84 
85 class ArcIteratorClass;
86 
88  std::tuple<const FstClass &, int64_t, ArcIteratorClass *>;
89 
90 // Untemplated user-facing class holding a templated pimpl.
92  public:
93  ArcIteratorClass(const FstClass &fst, int64_t s);
94 
95  template <class Arc>
96  ArcIteratorClass(const Fst<Arc> &fst, int64_t s)
97  : impl_(std::make_unique<ArcIteratorClassImpl<Arc>>(fst, s)) {}
98 
99  bool Done() const { return impl_->Done(); }
100 
101  uint8_t Flags() const { return impl_->Flags(); }
102 
103  void Next() { impl_->Next(); }
104 
105  size_t Position() const { return impl_->Position(); }
106 
107  void Reset() { impl_->Reset(); }
108 
109  void Seek(size_t a) { impl_->Seek(a); }
110 
111  void SetFlags(uint8_t flags, uint8_t mask) { impl_->SetFlags(flags, mask); }
112 
113  ArcClass Value() const { return impl_->Value(); }
114 
115  template <class Arc>
117 
118  private:
119  std::unique_ptr<ArcIteratorImplBase> impl_;
120 };
121 
122 template <class Arc>
124  const Fst<Arc> &fst = *std::get<0>(*args).GetFst<Arc>();
125  std::get<2>(*args)->impl_ =
126  std::make_unique<ArcIteratorClassImpl<Arc>>(fst, std::get<1>(*args));
127 }
128 
129 // Mutable arc iterators.
130 
131 // Virtual interface implemented by each concrete MutableArcIteratorImpl<F>.
133  public:
134  virtual void SetValue(const ArcClass &) = 0;
135 
137 };
138 
139 // Templated implementation.
140 template <class Arc>
142  public:
144  : aiter_(fst, s) {}
145 
146  bool Done() const final { return aiter_.Done(); }
147 
148  uint8_t Flags() const final { return aiter_.Flags(); }
149 
150  void Next() final { aiter_.Next(); }
151 
152  size_t Position() const final { return aiter_.Position(); }
153 
154  void Reset() final { aiter_.Reset(); }
155 
156  void Seek(size_t a) final { aiter_.Seek(a); }
157 
158  void SetFlags(uint8_t flags, uint8_t mask) final {
159  aiter_.SetFlags(flags, mask);
160  }
161 
162  void SetValue(const ArcClass &ac) final { SetValue(ac.GetArc<Arc>()); }
163 
164  // This is returned by value because it has not yet been constructed, and
165  // is likely to participate in return-value optimization.
166  ArcClass Value() const final { return ArcClass(aiter_.Value()); }
167 
169 
170  private:
171  void SetValue(const Arc &arc) { aiter_.SetValue(arc); }
172 
174 };
175 
177 
179  std::tuple<MutableFstClass *, int64_t, MutableArcIteratorClass *>;
180 
181 // Untemplated user-facing class holding a templated pimpl.
183  public:
185 
186  template <class Arc>
188  : impl_(std::make_unique<MutableArcIteratorClassImpl<Arc>>(fst, s)) {}
189 
190  bool Done() const { return impl_->Done(); }
191 
192  uint8_t Flags() const { return impl_->Flags(); }
193 
194  void Next() { impl_->Next(); }
195 
196  size_t Position() const { return impl_->Position(); }
197 
198  void Reset() { impl_->Reset(); }
199 
200  void Seek(size_t a) { impl_->Seek(a); }
201 
202  void SetFlags(uint8_t flags, uint8_t mask) { impl_->SetFlags(flags, mask); }
203 
204  void SetValue(const ArcClass &ac) { impl_->SetValue(ac); }
205 
206  ArcClass Value() const { return impl_->Value(); }
207 
208  template <class Arc>
209  friend void InitMutableArcIteratorClass(
211 
212  private:
213  std::unique_ptr<MutableArcIteratorImplBase> impl_;
214 };
215 
216 template <class Arc>
218  MutableFst<Arc> *fst = std::get<0>(*args)->GetMutableFst<Arc>();
219  std::get<2>(*args)->impl_ =
220  std::make_unique<MutableArcIteratorClassImpl<Arc>>(fst,
221  std::get<1>(*args));
222 }
223 
224 } // namespace script
225 } // namespace fst
226 
227 #endif // FST_SCRIPT_ARCITERATOR_CLASS_H_
void SetFlags(uint8_t flags, uint8_t mask) final
virtual uint8_t Flags() const =0
void SetFlags(uint8_t flags, uint8_t mask)
MutableArcIteratorClass(MutableFst< Arc > *fst, int64_t s)
std::tuple< const FstClass &, int64_t, ArcIteratorClass * > InitArcIteratorClassArgs
std::tuple< MutableFstClass *, int64_t, MutableArcIteratorClass * > InitMutableArcIteratorClassArgs
virtual bool Done() const =0
ArcIteratorClass(const Fst< Arc > &fst, int64_t s)
void SetFlags(uint8_t flags, uint8_t mask)
void SetValue(const ArcClass &ac) final
virtual size_t Position() const =0
virtual ArcClass Value() const =0
void InitArcIteratorClass(InitArcIteratorClassArgs *args)
virtual void SetFlags(uint8_t flags, uint8_t mask)=0
void SetFlags(uint8_t flags, uint8_t mask) final
MutableArcIteratorClassImpl(MutableFst< Arc > *fst, int64_t s)
virtual void Seek(size_t a)=0
ArcIteratorClassImpl(const Fst< Arc > &fst, int64_t s)
void InitMutableArcIteratorClass(InitMutableArcIteratorClassArgs *args)