pattern_resultformat.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2018 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_PATTERN_RESULTFORMAT_LIB_HPP_INCLUDED
#define _STRUS_ANALYZER_PATTERN_RESULTFORMAT_LIB_HPP_INCLUDED
#include "strus/analyzer/patternMatcherResult.hpp"
#include <utility>

namespace strus {

class ErrorBufferInterface;
class DebugTraceContextInterface;

typedef struct PatternResultFormat PatternResultFormat;

class PatternResultFormatContext
{
public:
        explicit PatternResultFormatContext( ErrorBufferInterface* errorhnd_);
        ~PatternResultFormatContext();

        const char* map( const PatternResultFormat* fmt, const analyzer::PatternMatcherResultItem* items, std::size_t nofItems);

private:
        ErrorBufferInterface* m_errorhnd;                       
        DebugTraceContextInterface* m_debugtrace;               
        struct Impl;                                            
        Impl* m_impl;                                           
};

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

        virtual const char* getVariable( const std::string& name) const=0;
};

class PatternResultFormatTable
{
public:
        PatternResultFormatTable( const PatternResultFormatVariableMap* variableMap_, ErrorBufferInterface* errorhnd_);
        ~PatternResultFormatTable();

        const PatternResultFormat* createResultFormat( const char* src);

private:
        ErrorBufferInterface* m_errorhnd;                       
        const PatternResultFormatVariableMap* m_variableMap;    
        struct Impl;                                            
        Impl* m_impl;                                           
};


struct PatternResultFormatChunk
{
        const char* value;              
        std::size_t valuesize;          
        int start_seg;                  
        int start_pos;                  
        int end_seg;                    
        int end_pos;                    

        static bool parseNext( PatternResultFormatChunk& result, char const*& src, ErrorBufferInterface* errorhnd);
};

class PatternResultFormatMap
{
public:
        PatternResultFormatMap( const char* src_, ErrorBufferInterface* errorhnd_);
        ~PatternResultFormatMap();

        std::string map( const analyzer::PatternMatcherResult& res) const;

private:
        std::string mapItem( const analyzer::PatternMatcherResultItem& res) const;

private:
        ErrorBufferInterface* m_errorhnd;                       
        struct Impl;                                            
        Impl* m_impl;                                           
};

}//namespace
#endif