Info.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 "Info.h"

#include "State.h"

#include <sstream>

using namespace std;
using namespace rsc;
using namespace rsc::runtime;

namespace cca {

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

ComponentInfo::~ComponentInfo() {
}

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

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

    if (!stateCache.empty()) {
        outstream << this->stateCache;
    }
    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 (!propertiesCache.empty()) {
        outstream << this->propertiesCache;
    } else {
        outstream << line("...", 1);
    }

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

std::string ComponentInfo::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 ComponentInfo::displayDataPorts(NamedInputPorts ip, NamedOutputPorts op) {
    ostringstream outstream(ostringstream::out);

    if (ip.empty()) {
        outstream << line("No data input ports.");
    } else {
        outstream << line("Data input ports:");
        for (NamedInputPorts::const_iterator it = ip.begin(); it != ip.end();
                ++it) {
            ostringstream port(ostringstream::out);
            port << "\"" << it->first << "\"" << it->second->print();
            outstream << line(port.str(), 1);
        }
    }
    if (op.empty()) {
        outstream << line("No data output ports.");
    } else {
        outstream << line("Data output ports:");
        for (NamedOutputPorts::const_iterator it = op.begin(); it != op.end();
                ++it) {
            ostringstream port(ostringstream::out);
            port << "\"" << it->first << "\"" << it->second->print();
            outstream << line(port.str(), 1);
        }
    }

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

void ComponentInfo::displayStatePorts(InputPort<ComponentState>::Ptr ip,
        OutputPort<ComponentState>::Ptr op) {
    ostringstream outstream(ostringstream::out);

    outstream << line("Component State Ports:");
    outstream << line("in:  " + ip->print(), 1);
    outstream << line("out: " + op->print(), 1);

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

void ComponentInfo::displayBeatPort(InputPort<cca::timing::Tick>::Ptr ip) {
    ostringstream outstream(ostringstream::out);

    outstream << line("Beat Port:");
    outstream << line(ip->print(), 1);

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

void ComponentInfo::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();
}

void ComponentInfo::displayComponentState(ComponentStatePtr state) {
    ostringstream outstream(ostringstream::out);

    if (state) {
        outstream << line("Component State:");
        outstream << line(state->print(), 1);
    }

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

void ComponentInfo::displayProperties(const rsc::runtime::Properties& d,
        const rsc::runtime::Properties& p) {
    ostringstream outstream(ostringstream::out);
    ostringstream properties(ostringstream::out);

    outstream << line("Properties:", 1);

    for (Properties::const_iterator it = p.begin(); it != p.end(); ++it) {
        ostringstream property(ostringstream::out);

        property << it->second.type() << " '" << it->first << "': ";
        if (it->second.type() == typeid(std::string)) {
            property << "\"" << boost::any_cast<std::string>(it->second)
                    << "\"";
        } else if (it->second.type() == typeid(bool)) {
            property << boost::any_cast<bool>(it->second);
        } else if (it->second.type() == typeid(int)) {
            property << boost::any_cast<int>(it->second);
        } else if (it->second.type() == typeid(unsigned int)) {
            property << boost::any_cast<unsigned int>(it->second);
        } else if (it->second.type() == typeid(double)) {
            property << boost::any_cast<double>(it->second);
        }

        if (d.count(it->first)) {
            property << "  (default: ";
            if (d.at(it->first).type() == typeid(std::string)) {
                property << "\""
                        << boost::any_cast<std::string>(d.at(it->first))
                        << "\"";
            } else if (d.at(it->first).type() == typeid(bool)) {
                property << boost::any_cast<bool>(d.at(it->first));
            } else if (d.at(it->first).type() == typeid(int)) {
                property << boost::any_cast<int>(d.at(it->first));
            } else if (d.at(it->first).type() == typeid(unsigned int)) {
                property << boost::any_cast<unsigned int>(d.at(it->first));
            } else if (d.at(it->first).type() == typeid(double)) {
                property << boost::any_cast<double>(d.at(it->first));
            }
            property << ")";
        }

        outstream << line(property.str(), 2);
    }

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

}