---

nodeoutputstrategy.h

Go to the documentation of this file.

/***************************************************************************
*  @file    outputstrategy.h
*  @version 1.0
*
*  @author  Ingo Herwig, TU Darmstadt, FG Regelsystemtheorie und Robotik
*  @author  Eva Brucherseifer, TU Darmstadt, FG Regelsystemtheorie und Robotik
*  @date    2001
*
***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Library Public License as       *
 *   published by the Free Software Foundation; either version 2 of the    *
 *   License, or (at your option) any later version.                       *
 *                                                                         *
 ***************************************************************************/

#ifndef NODEOUTPUTSTRATEGY_H
#define NODEOUTPUTSTRATEGY_H

#include <iostream>
#include <string>
#include "node.h"
#include "nodeutil.h"

namespace treecomp
{



template<class _TContent>
class NormalNode;
template<class _TContent>
class RootNode;

// ======================
// === OutputStrategy ===
// ======================
/**
 * @interface OutputStrategy
 * @ingroup outputstrategy
 *
 * @brief OutputStrategies are used to define the output-format of the tree.
 * They are used together with an OutputVisitor which calls their methods
 * appropriately.
 */
template<class _TContent>
class OutputStrategy
{
public:
    virtual OutputStrategy<_TContent>* clone() const {return 0;}
    virtual ~OutputStrategy() {}

    virtual void writeHeader() = 0;
    virtual void writeFooter() = 0;
    virtual void writeString(std::string& str) = 0;
    virtual void writeNormalNode(const NormalNode<_TContent>* node) = 0;
    virtual void writeRootNode(const RootNode<_TContent>* node) = 0;

    virtual bool isNull() {return false;}
};



// ============================
// === StreamOutputStrategy ===
// ============================
/**
 * @class StreamOutputStrategy
 * @ingroup outputstrategy
 *
 * @brief This OutputStrategy is used as base-class for all OutputStrategies which write to a stream.
 */
template<class _TContent>
class StreamOutputStrategy
    : public OutputStrategy<_TContent>, public StreamOut
{
public:
    explicit StreamOutputStrategy(std::ostream* out=&cout) : StreamOut(out) {}
    virtual StreamOutputStrategy<_TContent>* clone() const { return 0;}
    virtual ~StreamOutputStrategy() {}

    virtual void writeHeader() = 0;
    virtual void writeFooter() = 0;
    virtual void writeString(std::string& str) { *m_out << str; }
    virtual void writeNormalNode(const NormalNode<_TContent>* node) = 0;
    virtual void writeRootNode(const RootNode<_TContent>* node) = 0;
};


// ======================
// === NullOutputStrategy ===
// ======================
/**
 * @class NullOutputStrategy
 * @ingroup outputstrategy
 *
 * @brief NullOutputStrategies are used to define the output-format of the tree
 * - this one is a placeholder, which doesn't produce any output.
 */
template<class _TContent>
class NullOutputStrategy : public StreamOutputStrategy<_TContent>
{
public:
    explicit NullOutputStrategy(std::ostream* out=&cout) : StreamOutputStrategy<_TContent>(out) {}
    virtual NullOutputStrategy<_TContent>* clone() const { return new NullOutputStrategy<_TContent>(*this);}
    virtual ~NullOutputStrategy() {}

    virtual void writeHeader() {}
    virtual void writeFooter() {}
    virtual void writeString(std::string&) {}
    virtual void writeNormalNode(const NormalNode<_TContent>*) {}
    virtual void writeRootNode(const RootNode<_TContent>*) {}

    virtual bool isNull() {return true;}
};


// ============================
// === DefaultOutputStrategy ===
// ============================
/**
 * @class DefaultOutputStrategy
 * @ingroup outputstrategy
 *
 * @brief This OutputStrategy writes the node-type and name to 'cout.'
 */
template<class _TContent>
class DefaultOutputStrategy : public StreamOutputStrategy<_TContent>
{
public:
    explicit DefaultOutputStrategy(std::ostream* out=&cout) : StreamOutputStrategy<_TContent>(out) {}
    virtual DefaultOutputStrategy<_TContent>* construct()
            { return new DefaultOutputStrategy<_TContent>(); }
    virtual DefaultOutputStrategy<_TContent>* clone() const
            { return new DefaultOutputStrategy<_TContent>(*this); }
    virtual ~DefaultOutputStrategy() {}

    virtual void writeHeader() {}
    virtual void writeFooter() {}
    virtual void writeNormalNode(const NormalNode<_TContent>* node);
    virtual void writeRootNode(const RootNode<_TContent>* node);
};


// =================== Template definition =================================

// =============================
// === DefaultOutputStrategy ===
// =============================
/**
 * Write the normalNode content
 */
template<class _TContent>
void DefaultOutputStrategy<_TContent>::writeNormalNode(const NormalNode<_TContent>* node)
{
    *m_out << "......NN: " << node->getName() << endl;
}

/**
 * Write the RootNode content
 */
template<class _TContent>
void DefaultOutputStrategy<_TContent>::writeRootNode(const RootNode<_TContent>* node)
{
    *m_out << "......SN: " << node->getName() << endl;
}


} //namespace treecomp

#endif //OUTPUTSTRATEGY_H

---