Tanl Linguistic Pipeline

Corpus/Corpus.h

/*
**  Tanl
**  Corpus/Corpus.h
** ----------------------------------------------------------------------
**  Copyright (c) 2008  Giuseppe Attardi (attardi@di.unipi.it).
** ----------------------------------------------------------------------
**
**  This file is part of Tanl.
**
**  Tanl is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  Tanl is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/

#ifndef Tanl_Corpus_Corpus_H
#define Tanl_Corpus_Corpus_H

// local
#include "Language.h"
#include "SentenceReader.h"

// standard
#include <map>
#include <stdexcept>

namespace Tanl {

struct TokenField
{
  enum Use {
    input,                      // default
    output,
    echo,
    ignore
  };

  enum Value {
    string,                     // default
    integer
  };

  enum Role {
    none,                       // default
    form,
    head,
    deprel,
    predicate
  };

  TokenField() :
    use(input),
    value(string),
    role(none),
    default_("_")
  { }

  std::string   name;
  Use           use;
  Value         value;
  Role          role;
  std::string   default_;       
  std::string   link;           
  std::string   label;          
};

typedef std::vector<TokenField> TokenFields;

struct CorpusFormat
{
  CorpusFormat()
  { }

  ~CorpusFormat() { }

  void clear() { index.clear(); }

  std::string           name;
  TokenFields           tokenFields;
  AttributeIndex        index;  
};

class CorpusFormatError : public std::runtime_error
{
public:
  CorpusFormatError(std::string const& msg) : std::runtime_error(msg) {}
};

class Corpus
{
 public:
  Language const&       language;
  AttributeIndex        index;
  TokenFields           tokenFields;

  Corpus(Language const& lang) :
    language(lang)
  { }

  Corpus(Language const& lang, CorpusFormat& format) :
    language(lang),
    tokenFields(format.tokenFields),
    index(format.index)
  { }

  Corpus(Language const& lang, char const* formatFile);

  static Corpus* create(Language const& language, char const* inputFormat);

  static Corpus* create(char const* language, char const* inputFormat);

  virtual ~Corpus() {}

  static CorpusFormat*          parseFormat(char const* formatFile);

  AttributeId           attributeId(const char* name) {
    return index.insert(name);
  }

  virtual SentenceReader* sentenceReader(std::istream* is);

  virtual void          print(std::ostream& os, Sentence const& sent) const;
  virtual std::string   toString(Sentence const& sent) const;

protected:
  static CorpusFormat*  parseFormat(std::istream& is);

};


typedef Corpus* CorpusFactory(Language const& lang, CorpusFormat* format);

struct CorpusMap
{
public:
  CorpusMap(char const* type, CorpusFactory* rf)
  {
    get()[type] = rf;
  }

  static CorpusFactory*         get(char const* type);

private:
  static std::map<char const*, CorpusFactory*>& get();
};

#define REGISTER_CORPUS(type, factory) static CorpusMap __dummy ## type(#type, factory)

} // namespace Tanl

#endif // Tanl_Corpus_Corpus_H

 

Copyright © 2005-2011 G. Attardi. Generated on 4 Mar 2011 by doxygen 1.6.1.