Configuration.cpp

Go to the documentation of this file.

/* ============================================================
 *
 * This file is a part of CCA project
 *
 * Copyright (C) 2011 by Arne Nordmann <anordman at cor-lab dot uni-bielefeld dot de>
 *
 * This file may be licensed under the terms of the
 * GNU Lesser General Public License Version 3 (the ``LGPL''),
 * or (at your option) any later version.
 *
 * Software distributed under the License is distributed
 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
 * express or implied. See the LGPL for the specific language
 * governing rights and limitations.
 *
 * You should have received a copy of the LGPL along with this
 * program. If not, go to http://www.gnu.org/licenses/lgpl.html
 * or write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The development of this software was supported by:
 *   CoR-Lab, Research Institute for Cognition and Robotics
 *     Bielefeld University
 *
 * ============================================================ */

#include "Configuration.h"

#include <sstream>

using namespace std;

namespace cca {

Configuration::Configuration(const std::string &n) :
        DataTransferObject(), name(n), strategyCache(), dataPortsCache(),
                statePortsCache(), beatPortsCache() {
}

Configuration::~Configuration() {
}

std::string Configuration::print() const {
    ostringstream outstream(ostringstream::out);

    outstream << line(name, 0, true);

    if (!strategyCache.empty()) {
        outstream << this->strategyCache;
    }
    if (!beatPortsCache.empty()) {
        outstream << this->beatPortsCache;
    }
    if (!statePortsCache.empty()) {
        outstream << this->statePortsCache;
    }
    if (!dataPortsCache.empty()) {
        outstream << this->dataPortsCache;
    }

    outstream << line("", 0, true);

    if (true) {
        outstream << line("...", 1);
    }

    outstream << line("", 0, true);
    return outstream.str();
}

std::string Configuration::line(std::string str, unsigned int place,
        bool horizontal) const {
    unsigned int linelen = 80;
    unsigned int cursor = 0;

    ostringstream outstream(ostringstream::out);

    // Start the line
    outstream << " ";
    if (horizontal) {
        outstream << " +----";
        cursor += 6;
    } else {
        outstream << " |  ";
        cursor += 4;
    }

    // Insert tabs
    for (unsigned int tabs = 0; tabs < place; ++tabs) {
        if (!horizontal) {
            outstream << "    ";
            cursor += 4;
        }
    }

    // Insert string
    if (!str.empty()) {
        outstream << " " << str << " ";
        cursor += str.length() + 2;
    }

    // Fill up the line
    for (; cursor < linelen; ++cursor) {
        if (horizontal) {
            outstream << "-";
        } else {
            outstream << " ";
        }
    }

    // Finish the line
    if (horizontal) {
        outstream << "+";
    } else {
        outstream << "|";
    }

    outstream << std::endl;
    return outstream.str();
}

void Configuration::displayDataPorts(std::vector<InputPortPtr> ip,
        std::vector<OutputPortPtr> op, std::vector<Buffer<rsb::VoidPtr>*> bf) {
    ostringstream outstream(ostringstream::out);

    if (ip.empty()) {
        outstream << line("No data input ports.");
    } else {
        outstream << line("Data input ports:");
        for (unsigned int port = 0; port < ip.size(); ++port) {
            outstream << line(ip[port]->print(), 1);
            if (ip[port]->getConfig()) {
                outstream
                        << line(
                                "Scope:  "
                                        + ip[port]->getConfig()->getScopePtr()->toString(),
                                2);
                outstream << line("Buffer: " + bf[port]->print(), 2);
            }
        }
    }
    if (op.empty()) {
        outstream << line("No data output ports.");
    } else {
        outstream << line("Data output ports:");
        for (unsigned int port = 0; port < op.size(); ++port) {
            outstream << line(op[port]->print(), 1);
            if (op[port]->getConfig()) {
                outstream
                        << line(
                                "Scope:  "
                                        + op[port]->getConfig()->getScopePtr()->toString(),
                                2);
            }
        }
    }

    this->dataPortsCache = outstream.str();
}

void Configuration::displayStatePorts(InputPortPtr ip, OutputPortPtr op) {
    ostringstream outstream(ostringstream::out);

    outstream << line("Component State Ports:");
    outstream << line(ip->print(), 1);
    outstream
            << line("Scope: " + ip->getConfig()->getScopePtr()->toString(), 2);
    outstream << line(op->print(), 1);
    outstream
            << line("Scope: " + op->getConfig()->getScopePtr()->toString(), 2);

    this->statePortsCache = outstream.str();
}

void Configuration::displayBeatPort(InputPortPtr ip) {
    ostringstream outstream(ostringstream::out);

    outstream << line("Beat Port:");
    outstream << line(ip->print(), 1);
    outstream
            << line("Scope: " + ip->getConfig()->getScopePtr()->toString(), 2);

    this->beatPortsCache = outstream.str();
}

void Configuration::displayStrategy(StrategyPtr strat) {
    ostringstream outstream(ostringstream::out);

    if (strat) {
        outstream << line("Processing strategy:");
        outstream << line(strat->print(), 1);
    } else {
        outstream << line("Processing strategy:");
        outstream << line("<unconfigured>", 1);
    }

    this->strategyCache = outstream.str();
}

}