Translator.h

#pragma once


#include <libutl/AutoPtr.h>
#include <libutl/Encoder.h>
#include <libutl/Hashtable.h>
#include <libutl/Mapping.h>
#include <libutl/MemStream.h>
#include <libutl/Pair.h>


UTL_NS_BEGIN;

// Translator //////////////////////////////////////////////////////////////////////////////////////


class Translator : public Encoder
{
    UTL_CLASS_DECL(Translator, Encoder);

public:
    Translator(Stream* stream,
               bool owner = true,
               Mapping* mapping = nullptr,
               bool mappingOwner = true,
               bool rememberMappings = false,
               char prefix = '$')
    {
        set(stream, owner, mapping, mappingOwner, rememberMappings, prefix);
    }

    void
    add(const String& lhs, const String& rhs)
    {
        _xlats += new Pair(lhs.clone(), rhs.clone());
    }

    void clear();

    virtual void
    dump(Stream& os, uint_t level = uint_t_max) const
    {
        _xlats.dump(os, level);
    }

    virtual size_t encode(const byte_t* block, size_t num);

    virtual size_t
    decode(byte_t* block, size_t num)
    {
        ABORT();
        return 0;
    }

    const Mapping*
    getMapping() const
    {
        return _mapping;
    }

    bool
    getRememberMappings() const
    {
        return getFlag(flg_rememberMappings);
    }

    bool
    isMappingOwner() const
    {
        return getFlag(flg_mappingOwner);
    }

    void set(Stream* stream,
             bool owner = true,
             Mapping* mapping = nullptr,
             bool mappingOwner = true,
             bool rememberMappings = false,
             char prefix = '$');

    void
    setMapping(Mapping* mapping, bool mappingOwner = true, bool rememberMappings = false)
    {
        if (isMappingOwner()) delete _mapping;
        _mapping = mapping;
        setFlag(flg_mappingOwner, mappingOwner);
        setFlag(flg_rememberMappings, rememberMappings);
    }

private:
    void
    init()
    {
        _mapping = nullptr;
    }

    void
    deInit()
    {
        setMapping(nullptr);
    }

    const String* translate(const String& token);

private:
    enum flg_t
    {
        flg_mappingOwner = 12,
        flg_rememberMappings
    };

private:
    String _prefix;
    Hashtable _xlats;
    Mapping* _mapping;
    AutoPtr<> _mappedObject;
};

// StringTranslator ////////////////////////////////////////////////////////////////////////////////


class StringTranslator : public Object
{
    UTL_CLASS_DECL(StringTranslator, Object);

public:
    StringTranslator(Mapping* mapping,
                     bool mappingOwner = true,
                     bool rememberMappings = true,
                     char prefix = '$')
    {
        set(mapping, mappingOwner, rememberMappings, prefix);
    }

    void set(Mapping* mapping,
             bool mappingOwner = true,
             bool rememberMappings = true,
             char prefix = '$');

    void
    add(const String& lhs, const String& rhs)
    {
        _translator.add(lhs, rhs);
    }

    virtual void
    dump(Stream& os, uint_t level = uint_t_max) const
    {
        _translator.dump(os, level);
    }

    String translate(const String& str);

private:
    void
    init()
    {
        set(nullptr);
    }

    void
    deInit()
    {
        _translator.set(nullptr);
    }

private:
    Translator _translator;
    MemStream _ms;
};


UTL_NS_END;