task.readfst.hpp

Go to the documentation of this file.

// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use these files 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 2012 - Gonzalo Iglesias, Adrià de Gispert, William Byrne

#ifndef TASK_READFST_HPP
#define TASK_READFST_HPP

namespace ucam {
namespace fsttools {

template <class Data, class Arc = fst::StdArc >
class ReadFstTask: public ucam::util::TaskInterface<Data> {

 private:
  ucam::util::IntegerPatternAddress fstfile_;

  std::string previousfile_;
  std::string fstkey_;
  boost::scoped_ptr< fst::VectorFst<Arc> > fst_;

 public:
  ReadFstTask ( const ucam::util::RegistryPO& rg ,
                const std::string& fstkey
              ) :
    fstkey_ ( fstkey ),
    fstfile_ ( rg.get<std::string> ( fstkey ) ) {
  };

  static ReadFstTask * init ( const ucam::util::RegistryPO& rg ,
                              const std::string& fstkey
                            ) {
    if ( rg.exists ( fstkey ) ) return new ReadFstTask ( rg, fstkey );
    return NULL;
  }

  bool run ( Data& d ) {
    fst_.reset();
    if ( fstfile_ ( d.sidx ) != "" && fstfile_ ( d.sidx ) != previousfile_ ) {
      LINFO ( "Loading ... " << fstfile_ ( d.sidx ) << " with key=" << fstkey_ );
      fst_.reset ( fst::VectorFstRead<Arc> ( fstfile_ ( d.sidx ) ) );
      d.fsts[fstkey_] = fst_.get();
      previousfile_ = fstfile_ ( d.sidx );
    }
    return false;
  };

  ~ReadFstTask ( ) {
    //fst_->DeleteStates();
    fst_.reset();
    LINFO ("Shutdown!");
  }

 private:

  ZDISALLOW_COPY_AND_ASSIGN ( ReadFstTask );

};

template <class Data>
static ucam::util::TaskInterface<Data> * ReadFstInit ( const
    ucam::util::RegistryPO& rg ,
    const std::string& fstkey ,
    const std::string& arctype = HifstConstants::kHifstSemiringStdArc
                                                     ) {
  if ( rg.exists ( fstkey ) )
    if (arctype == HifstConstants::kHifstSemiringStdArc) return new
          ReadFstTask<Data, fst::StdArc> ( rg, fstkey );
    else if (arctype == HifstConstants::kHifstSemiringLexStdArc ) return
        static_cast< ucam::util::TaskInterface<Data> * > (new
            ReadFstTask<Data, fst::LexStdArc> ( rg, fstkey ) );
    else {
      LERROR ("Unknown arc type:" << arctype);
      exit (EXIT_FAILURE);
    }
  return NULL;
}

}
}  // End namespaces

#endif