textProcessorInterface.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014 Patrick P. Frey
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
#ifndef _STRUS_ANALYZER_TEXT_PROCESSOR_INTERFACE_HPP_INCLUDED
#define _STRUS_ANALYZER_TEXT_PROCESSOR_INTERFACE_HPP_INCLUDED
#include "strus/analyzer/documentClass.hpp"
#include "strus/analyzer/segmenterOptions.hpp"
#include <string>
#include <vector>

namespace strus
{
class DocumentClassDetectorInterface;
class SegmenterInterface;
class NormalizerFunctionInterface;
class TokenizerFunctionInterface;
class TokenizerFunctionInstanceInterface;
class AggregatorFunctionInterface;
class PatternLexerInterface;
class PatternMatcherInterface;
class PatternMatcherProgramInterface;
class PatternTermFeederInterface;
class PosTaggerDataInterface;
class PosTaggerInterface;
class TokenMarkupInstanceInterface;

class TextProcessorInterface
{
public:
        virtual ~TextProcessorInterface(){}

        virtual std::string getResourceFilePath( const std::string& filename) const=0;

        virtual const SegmenterInterface* getSegmenterByName( const std::string& segmenterName) const=0;

        virtual const SegmenterInterface* getSegmenterByMimeType( const std::string& mimetype) const=0;

        virtual analyzer::SegmenterOptions getSegmenterOptions( const std::string& scheme) const=0;

        virtual const TokenizerFunctionInterface* getTokenizer( const std::string& name) const=0;

        virtual const NormalizerFunctionInterface* getNormalizer( const std::string& name) const=0;

        virtual const AggregatorFunctionInterface* getAggregator( const std::string& name) const=0;

        virtual const PatternLexerInterface* getPatternLexer( const std::string& name) const=0;

        virtual const PatternMatcherInterface* getPatternMatcher( const std::string& name) const=0;

        virtual const PatternTermFeederInterface* getPatternTermFeeder() const=0;

        virtual PosTaggerDataInterface* createPosTaggerData( TokenizerFunctionInstanceInterface* tokenizer) const=0;

        virtual const PosTaggerInterface* getPosTagger() const=0;

        virtual TokenMarkupInstanceInterface* createTokenMarkupInstance() const=0;

        virtual bool detectDocumentClass( analyzer::DocumentClass& dclass, const char* contentBegin, std::size_t contentBeginSize, bool isComplete) const=0;

        virtual void defineDocumentClassDetector( DocumentClassDetectorInterface* detector)=0;

        virtual void defineSegmenter( const std::string& name, SegmenterInterface* segmenter)=0;

        virtual void defineSegmenterOptions( const std::string& scheme, const analyzer::SegmenterOptions& options)=0;

        virtual void defineTokenizer( const std::string& name, TokenizerFunctionInterface* tokenizer)=0;

        virtual void defineNormalizer( const std::string& name, NormalizerFunctionInterface* normalizer)=0;

        virtual void defineAggregator( const std::string& name, AggregatorFunctionInterface* aggregator)=0;

        virtual void definePatternLexer( const std::string& name, PatternLexerInterface* lexer)=0;

        virtual void definePatternMatcher( const std::string& name, PatternMatcherInterface* matcher)=0;

        enum FunctionType
        {
                Segmenter,                      
                TokenizerFunction,              
                NormalizerFunction,             
                AggregatorFunction,             
                PatternLexer,                   
                PatternMatcher                  
        };
        static const char* functionTypeName( FunctionType t)
        {
                const char* ar[] = {"Segmenter","Tokenizer","Normalizer","Aggregator","PatternLexer","PatternMatcher",0};
                return ar[t];
        }

        virtual std::vector<std::string> getFunctionList( const FunctionType& type) const=0;
};

}//namespace
#endif