DeSR Dependency Parser

src/Corpus.h

/*
**  DeSR
**  src/Corpus.h
** ----------------------------------------------------------------------
**  Copyright (c) 2008  Giuseppe Attardi (attardi@di.unipi.it).
** ----------------------------------------------------------------------
**
**  This file is part of DeSR.
**
**  DeSR 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.
**
**  DeSR 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 DeSR_Corpus_H
#define DeSR_Corpus_H

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

// library
#include "include/error.h"

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
{
  std::string           name;
  TokenFields           tokenFields;
  AttributeIndex        index;  
};

class CorpusFormatError : public IXE::RuntimeError
{
public:
  CorpusFormatError(std::string const& msg) : IXE::RuntimeError(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) {
    return create(Language(language), 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;

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

};

struct ConllXCorpus : public Corpus
{

  ConllXCorpus(Language const& lang);

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

  void                  print(std::ostream& os, Sentence const& sent) const;
};

struct Conll08Corpus : public Corpus
{
  Conll08Corpus(Language const& lang, CorpusFormat& format) :
    Corpus(lang, format)
  { }

  void                  print(std::ostream& os, Sentence const& sent) const;
};

struct DgaCorpus : public Corpus
{

  DgaCorpus(Language const& lang);

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

  void                  print(std::ostream& os, Sentence const& sent) const;
};

struct CombCorpus : public Corpus
{
  CombCorpus(Language const& lang, char const* formatFile) :
    Corpus(lang, formatFile)
  { }

  void                  print(std::ostream& os, Sentence const& sent) const;
};

struct TextCorpus : public Corpus
{
  TextCorpus(Language const& lang) :
    Corpus(lang)
  {}

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

struct TokenizedTextCorpus : public Corpus
{
  TokenizedTextCorpus(Language const& lang) :
    Corpus(lang)
  {}

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


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

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 // DeSR_Corpus_H

 

Copyright © 2005-2007 G. Attardi. Generated on 13 Aug 2009 by doxygen 1.5.7.1.