pattern_serialize.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2016 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_SERIALIZE_LIB_HPP_INCLUDED
#define _STRUS_ANALYZER_PATTERN_SERIALIZE_LIB_HPP_INCLUDED
#include <string>
#include <iostream>

namespace strus {

class PatternTermFeederInterface;
class PatternTermFeederInstanceInterface;
class PatternLexerInterface;
class PatternLexerInstanceInterface;
class PatternMatcherInterface;
class PatternMatcherInstanceInterface;
class ErrorBufferInterface;
struct SerializerData;

class PatternSerializer
{
public:
        enum {MaxContentBufSize=1<<20};

public:
        PatternSerializer( SerializerData* serializerData_, PatternLexerInstanceInterface* lexer_, PatternMatcherInstanceInterface* matcher_, ErrorBufferInterface* errorhnd_)
                :m_errorhnd(errorhnd_),m_serializerData(serializerData_),m_lexer(lexer_),m_feeder(0),m_matcher(matcher_){}
        PatternSerializer( SerializerData* serializerData_, PatternTermFeederInstanceInterface* feeder_, PatternMatcherInstanceInterface* matcher_, ErrorBufferInterface* errorhnd_)
                :m_errorhnd(errorhnd_),m_serializerData(serializerData_),m_lexer(0),m_feeder(feeder_),m_matcher(matcher_){}
        ~PatternSerializer();

        PatternLexerInstanceInterface* lexer()          {return m_lexer;}
        PatternTermFeederInstanceInterface* feeder()    {return m_feeder;}
        PatternMatcherInstanceInterface* matcher()      {return m_matcher;}

        bool close();

private:
        PatternSerializer( const PatternSerializer&){}  //... non copyable
        void operator=( const PatternSerializer&){}     //... non copyable

private:
        ErrorBufferInterface* m_errorhnd;
        SerializerData* m_serializerData;
        PatternLexerInstanceInterface* m_lexer;
        PatternTermFeederInstanceInterface* m_feeder;
        PatternMatcherInstanceInterface* m_matcher;
};

enum PatternSerializerType
{
        PatternMatcherWithLexer,
        PatternMatcherWithFeeder
};

bool isPatternSerializerContent(
                const std::string& m_itrcontent,
                ErrorBufferInterface* errorhnd);


PatternSerializer*
        createPatternSerializer(
                const std::string& filename,
                const PatternSerializerType& serializerType,
                ErrorBufferInterface* errorhnd);

PatternSerializer*
        createPatternSerializerText(
                std::ostream& output,
                const PatternSerializerType& serializerType,
                ErrorBufferInterface* errorhnd);

bool loadPatternMatcherFromSerialization(
                const std::string& source,
                PatternLexerInstanceInterface* lexer,
                PatternMatcherInstanceInterface* matcher,
                ErrorBufferInterface* errorhnd);

bool loadPatternMatcherFromSerialization(
                const std::string& source,
                PatternTermFeederInstanceInterface* feeder,
                PatternMatcherInstanceInterface* matcher,
                ErrorBufferInterface* errorhnd);
}//namespace
#endif