helloworld.cpp File Reference

The basics - A trivial Graph with a single Detector. More...

Go to the source code of this file.

Detailed Description

The basics - A trivial Graph with a single Detector.

Introduction

This examples cover the basics of using the DetectorGraph framework - a "Hello World" of sorts. For the purposes of this example imagine a temperature sensor that produces samples regularly and that we're tasked to signal other parts of the system whenever that temperature crosses a threshold.

We start by splitting the problem, within the scope of our task, in three parts:

• What's our input data? The input Topic
• What's our output data? The output Topic
• How do we get from one to the other? The Detector what will do the job

Topics

Topics are defined by the DetectorGraph::TopicState type they carry. A TopicState is any C++ struct/class that inherits from DetectorGraph::TopicState.

For the 'input' to our system we'll declare a TemperatureSample TopicState:

struct TemperatureSample : public DetectorGraph::TopicState
{
    TemperatureSample(int aTemp = 0) : temperature(aTemp) {}
    int temperature;
};

The important here is that this struct inherits TopicState and that it has data field(s).

Next we define the 'output'; another struct that also inherits DetectorGraph::TopicState and has data fields:

struct OverheatingState : public DetectorGraph::TopicState
{
    OverheatingState(bool aState = false) : isOverheating(aState) {}
    bool isOverheating;
};

Detector

Now we just need to fill in the gap; the Detector that creates OverheatingState from TemperatureSample: two.

class OverheatingDetector : public DetectorGraph::Detector
, public DetectorGraph::SubscriberInterface<TemperatureSample>
, public DetectorGraph::Publisher<OverheatingState>
{
public:
    OverheatingDetector(DetectorGraph::Graph* graph) : DetectorGraph::Detector(graph)
    {
        Subscribe<TemperatureSample>(this);
        SetupPublishing<OverheatingState>(this);
    }

    virtual void Evaluate(const TemperatureSample& sample)
    {
        if (sample.temperature > kThreshold)
        {
            Publish(OverheatingState(true));
        }
        else
        {
            Publish(OverheatingState(false));
        }
    }

    static const int kThreshold = 100;
};

Graph

The final plumbing is to add our newly created Detector to a DetectorGraph::Graph. Depending on the situation this can be done in different ways but here's the simplest:

    DetectorGraph::Graph graph;
    OverheatingDetector detector(&graph);

With that the Graph instance will internally create the following graph:

HelloWorldGraph

Topics are represented by rectangles, Detectors by the oval shapes and arrows follow the flow of data - this is the standard representation for DetectorGraph graphs. The numeric prefix to the names is each node's order in the Topological sort of the graph. Output topics are painted Lime Green and input ones Light Blue.

Usage

Finally, using the graph is done by Pushing data in, evaluating the graph and checking outputs:

    graph.PushData(TemperatureSample(110));
    graph.EvaluateGraph();

    const OverheatingState& output =
        graph.ResolveTopic<OverheatingState>()->GetNewValue();
    cout << "IsOverheating = " << ((output.isOverheating) ? "true" : "false") << endl;

Running the program then gives:

DetectorGraph: Graph Initialized
IsOverheating = true

An alternative way to do things is to subclass the DetectorGraph::ProcessorContainer utility that streamlines the DetectorGraph::Graph::PushData, DetectorGraph::Graph::EvaluateGraph and subsequent inspection steps. For the example above, the DetectorGraph::ProcessorContainer implementation would be:

class HelloWorldGraph : public DetectorGraph::ProcessorContainer
{
public:
    HelloWorldGraph()
    : mOverheatingDetector(&mGraph)
    {
    }

    OverheatingDetector mOverheatingDetector;

    virtual void ProcessOutput()
    {
        DetectorGraph::Topic<OverheatingState>* overheatingStateTopic = mGraph.ResolveTopic<OverheatingState>();
        if (overheatingStateTopic->HasNewValue())
        {
            const OverheatingState& overheatingState = overheatingStateTopic->GetNewValue();
            cout << "OverheatingState.isOverheating = " << ((overheatingState.isOverheating) ? "true" : "false") << endl;
        }
    }
};

And then usage would be like:

    HelloWorldGraph thermostat;
    thermostat.ProcessData(TemperatureSample(70));
    thermostat.ProcessData(TemperatureSample(90));
    thermostat.ProcessData(TemperatureSample(100));
    thermostat.ProcessData(TemperatureSample(110));
    thermostat.ProcessData(TemperatureSample(120));

DetectorGraph: Graph Initialized
OverheatingState.isOverheating = false
OverheatingState.isOverheating = false
OverheatingState.isOverheating = false
OverheatingState.isOverheating = true
OverheatingState.isOverheating = true

This example can be built with:

g++ -std=c++11 -I./include/ -I./platform_standalone/ src/graph.cpp src/detector.cpp platform_standalone/dglogging.cpp examples/helloworld.cpp -o helloworld.out

Definition in file helloworld.cpp.