portuguesetranslator.cpp File Reference

A dictionary-based translator that uses shared memory in TopicStates. More...

Go to the source code of this file.

Detailed Description

A dictionary-based translator that uses shared memory in TopicStates.

Introduction

This examples implements a very basic translator based only on word replacements.

Using Shared Memory in TopicStates

DetectorGraph uses C++ copies to propagate information across Topics & Detectors. This is fine & desirable for small amounts of data but can become prohibitive for large objects. In such cases the recommended pattern is to wrap the large resource using an appropriate smart pointer (e.g. std::shared_ptr).

The one caveat is that, as Detectors start accessing shared memory, the DetectorGraph framework alone cannot guarantee the hermetic nature of detectors - a detector's data (i.e. the data a member pointer points to) may change even though no Evaluate('new value') for that member was called.

In cases where the large data piece only has only read-only use, a const_shared_ptr can be used to partially address the concern mentioned above.

In this example, the TranslationDictionary TopicState carries a large, immutable object and does so using a shared_ptr<const T>:

struct TranslationDictionary : public TopicState
{
    TranslationDictionary()
    : map(std::make_shared<Text2TextMap>())
    {
    }

    TranslationDictionary(const std::shared_ptr<const Text2TextMap>& aMapPtr)
    : map(aMapPtr)
    {
    }

    bool Lookup(std::string inStr, std::string& outStr) const
    {
        Text2TextMap::const_iterator lookupIterator = map->find(inStr);
        if (lookupIterator != map->end())
        {
            outStr = lookupIterator->second;
            return true;
        }
        else
        {
            return false;
        }
    };

    std::shared_ptr<const Text2TextMap> map;
};

A different example that also uses this pattern is Fancy Vending Machine:

struct ChangeAvailable : public DetectorGraph::TopicState
{
    ChangeAvailable() : mCoins(), mpChangeLookupTable() {}

    ChangeAvailable(const ChangeAlgo::CoinStock& aCoins, const std::shared_ptr<const ChangeAlgo::ChangeLookupTable>& aLookupTable)
    : mCoins(aCoins)
    , mpChangeLookupTable(aLookupTable)
    {
    }

    bool CanGiveChange(unsigned change) const
    {
        return mpChangeLookupTable->CanGiveChange(mCoins, change);
    }

    ChangeAlgo::CoinStock mCoins;
    std::shared_ptr<const ChangeAlgo::ChangeLookupTable> mpChangeLookupTable;
};

Architecture

This sample implements the following graph:

TextTranslatorGraph

Definition in file portuguesetranslator.cpp.