From 9b02d5a62ea41136b46b744f7b2c1cf50f30a888 Mon Sep 17 00:00:00 2001 From: Henrik Rentz-Reichert Date: Wed, 4 Jan 2017 21:07:12 +0100 Subject: Bug 509875 - [runtime.cpp] replace STL containers with own containers that are more light weight * replaced streaming code with (s)printf constructs * added String, Vector, Set, Pair and Map with tests * using new String class in * Address * Message * MSCFilter * MSCLogger * RTObject * and affected classes * using new Vector class in * RTObject * MSCLogger * MessageServiceController * ReplicatedActorClassBase * ReplicatedInterfaceItemBase * and affected classes * using new Set class in * MessageDispatcher * using new Map class in * SubSystemClassBase * DebuggingService * adjusted cpp generator Change-Id: I9c91289057185e6e36b9453ecf03f6f6d3834ec6 --- .../jgen_modellib_java.launch | 2 + .../common/modelbase/RTSystemServicesProtocol.cpp | 40 ++- .../common/modelbase/RTSystemServicesProtocol.h | 20 +- .../src/common/containers/Map.cpp | 20 ++ .../src/common/containers/Map.h | 232 ++++++++++++++ .../src/common/containers/Pair.h | 84 ++++++ .../src/common/containers/Set.cpp | 20 ++ .../src/common/containers/Set.h | 222 ++++++++++++++ .../src/common/containers/String.cpp | 169 +++++++++++ .../src/common/containers/String.h | 318 ++++++++++++++++++++ .../src/common/containers/Vector.cpp | 22 ++ .../src/common/containers/Vector.h | 334 +++++++++++++++++++++ .../src/common/debugging/DebuggingService.cpp | 61 ++-- .../src/common/debugging/DebuggingService.h | 21 +- .../src/common/debugging/MSCFilter.cpp | 10 +- .../src/common/debugging/MSCFilter.h | 26 +- .../src/common/debugging/MSCFunctionObject.cpp | 12 +- .../src/common/debugging/MSCFunctionObject.h | 8 +- .../src/common/debugging/MSCLogger.cpp | 42 +-- .../src/common/debugging/MSCLogger.h | 43 ++- .../src/common/messaging/AbstractMessageReceiver.h | 7 +- .../src/common/messaging/Address.cpp | 5 +- .../src/common/messaging/Address.h | 6 +- .../src/common/messaging/IRTObject.cpp | 3 +- .../src/common/messaging/IRTObject.h | 22 +- .../src/common/messaging/Message.cpp | 19 +- .../src/common/messaging/Message.h | 6 +- .../src/common/messaging/MessageDispatcher.cpp | 20 +- .../src/common/messaging/MessageDispatcher.h | 17 +- .../src/common/messaging/MessageSeQueue.cpp | 2 +- .../src/common/messaging/MessageSeQueue.h | 3 +- .../src/common/messaging/MessageService.cpp | 10 +- .../src/common/messaging/MessageService.h | 7 +- .../common/messaging/MessageServiceController.cpp | 26 +- .../common/messaging/MessageServiceController.h | 10 +- .../src/common/messaging/RTObject.cpp | 60 ++-- .../src/common/messaging/RTObject.h | 56 ++-- .../src/common/messaging/StaticMessageMemory.cpp | 7 +- .../src/common/messaging/StaticMessageMemory.h | 2 +- .../src/common/modelbase/ActorClassBase.cpp | 13 +- .../src/common/modelbase/ActorClassBase.h | 11 +- .../src/common/modelbase/DataPort.cpp | 3 +- .../src/common/modelbase/DataPort.h | 9 +- .../src/common/modelbase/EventReceiver.cpp | 3 +- .../src/common/modelbase/EventReceiver.h | 3 +- .../src/common/modelbase/InterfaceItemBase.cpp | 26 +- .../src/common/modelbase/InterfaceItemBase.h | 7 +- .../src/common/modelbase/PortBase.h | 5 +- .../src/common/modelbase/RTSystem.h | 4 +- .../src/common/modelbase/RTSystemProtocol.cpp | 13 +- .../src/common/modelbase/RTSystemProtocol.h | 7 +- .../common/modelbase/ReplicatedActorClassBase.cpp | 16 +- .../common/modelbase/ReplicatedActorClassBase.h | 10 +- .../modelbase/ReplicatedInterfaceItemBase.cpp | 26 +- .../common/modelbase/ReplicatedInterfaceItemBase.h | 17 +- .../src/common/modelbase/ReplicatedPortBase.h | 3 +- .../src/common/modelbase/SubSystemClassBase.cpp | 44 ++- .../src/common/modelbase/SubSystemClassBase.h | 13 +- .../src/common/modelbase/SubSystemRunnerBase.cpp | 18 +- .../src/common/modelbase/SubSystemRunnerBase.h | 6 +- .../src/common/modelbase/SystemPortOwner.h | 3 +- 61 files changed, 1851 insertions(+), 403 deletions(-) create mode 100644 runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Map.cpp create mode 100644 runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Map.h create mode 100644 runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Pair.h create mode 100644 runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Set.cpp create mode 100644 runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Set.h create mode 100644 runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/String.cpp create mode 100644 runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/String.h create mode 100644 runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Vector.cpp create mode 100644 runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Vector.h (limited to 'runtime') diff --git a/runtime/org.eclipse.etrice.modellib.java/jgen_modellib_java.launch b/runtime/org.eclipse.etrice.modellib.java/jgen_modellib_java.launch index fac0a9524..02583c781 100644 --- a/runtime/org.eclipse.etrice.modellib.java/jgen_modellib_java.launch +++ b/runtime/org.eclipse.etrice.modellib.java/jgen_modellib_java.launch @@ -6,8 +6,10 @@ + + diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src-gen/common/modelbase/RTSystemServicesProtocol.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src-gen/common/modelbase/RTSystemServicesProtocol.cpp index 83fa9cd55..77e266e0d 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src-gen/common/modelbase/RTSystemServicesProtocol.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src-gen/common/modelbase/RTSystemServicesProtocol.cpp @@ -13,22 +13,20 @@ #include "common/messaging/Address.h" #include "common/messaging/Message.h" #include "common/modelbase/IEventReceiver.h" -#include -#include using namespace etRuntime; /* message names as strings for debugging (generate MSC) */ -const std::string RTSystemServicesProtocol::s_messageStrings[] = {"MIN", "executeInitialTransition","startDebugging","stopDebugging","MAX"}; +const String RTSystemServicesProtocol::s_messageStrings[] = {"MIN", "executeInitialTransition","startDebugging","stopDebugging","MAX"}; -const std::string& RTSystemServicesProtocol::getMessageString(int msg_id) { +const String& RTSystemServicesProtocol::getMessageString(int msg_id) { if ((MSG_MIN < msg_id ) && ( msg_id < MSG_MAX )) { return s_messageStrings[msg_id]; } else { // id out of range - static const std::string errorMsg = "Message ID out of range"; + static const String errorMsg = "Message ID out of range"; return errorMsg; } } @@ -37,12 +35,12 @@ const std::string& RTSystemServicesProtocol::getMessageString(int msg_id) { // port class //------------------------------------------------------------------------------------------------------------ -RTSystemServicesProtocolPort::RTSystemServicesProtocolPort(IInterfaceItemOwner* actor, const std::string& name, int localId) +RTSystemServicesProtocolPort::RTSystemServicesProtocolPort(IInterfaceItemOwner* actor, const String& name, int localId) : PortBase(actor, name, localId, 0) { } -RTSystemServicesProtocolPort::RTSystemServicesProtocolPort(IInterfaceItemOwner* actor, const std::string& name, int localId, int idx) +RTSystemServicesProtocolPort::RTSystemServicesProtocolPort(IInterfaceItemOwner* actor, const String& name, int localId, int idx) : PortBase(actor, name, localId, idx) { } @@ -55,10 +53,10 @@ void RTSystemServicesProtocolPort::destroy() { void RTSystemServicesProtocolPort::receive(const Message* msg) { // TODO JH further if (! RTSystemServicesProtocol::isValidIncomingEvtID(msg->getEvtId())) { - std::cout << "unknown" << std::endl; + //std::cout << "unknown" << std::endl; } - DebuggingService::getInstance().addMessageAsyncIn(getPeerAddress(), getAddress(), RTSystemServicesProtocol::getMessageString(msg->getEvtId())); + DebuggingService::getInstance().addMessageAsyncIn(getPeerAddress(), getAddress(), RTSystemServicesProtocol::getMessageString(msg->getEvtId()).c_str()); getActor()->receiveEvent(this, msg->getEvtId(), msg->getData()); } @@ -69,7 +67,7 @@ void RTSystemServicesProtocolPort::receive(const Message* msg) { //------------------------------------------------------------------------------------------------------------ // replicated port class //------------------------------------------------------------------------------------------------------------ -RTSystemServicesProtocolReplPort::RTSystemServicesProtocolReplPort(IInterfaceItemOwner* actor, const std::string& name, int localId) : +RTSystemServicesProtocolReplPort::RTSystemServicesProtocolReplPort(IInterfaceItemOwner* actor, const String& name, int localId) : ReplicatedPortBase(actor, name, localId) { } @@ -79,12 +77,12 @@ RTSystemServicesProtocolReplPort::RTSystemServicesProtocolReplPort(IInterfaceIte // conjugated port class //------------------------------------------------------------------------------------------------------------ -RTSystemServicesProtocolConjPort::RTSystemServicesProtocolConjPort(IInterfaceItemOwner* actor, const std::string& name, int localId) +RTSystemServicesProtocolConjPort::RTSystemServicesProtocolConjPort(IInterfaceItemOwner* actor, const String& name, int localId) : PortBase(actor, name, localId, 0) { } -RTSystemServicesProtocolConjPort::RTSystemServicesProtocolConjPort(IInterfaceItemOwner* actor, const std::string& name, int localId, int idx) +RTSystemServicesProtocolConjPort::RTSystemServicesProtocolConjPort(IInterfaceItemOwner* actor, const String& name, int localId, int idx) : PortBase(actor, name, localId, idx) { } @@ -97,10 +95,10 @@ void RTSystemServicesProtocolConjPort::destroy() { void RTSystemServicesProtocolConjPort::receive(const Message* msg) { // TODO JH further if (! RTSystemServicesProtocol::isValidOutgoingEvtID(msg->getEvtId())) { - std::cout << "unknown" << std::endl; + //std::cout << "unknown" << std::endl; } - DebuggingService::getInstance().addMessageAsyncIn(getPeerAddress(), getAddress(), RTSystemServicesProtocol::getMessageString(msg->getEvtId())); + DebuggingService::getInstance().addMessageAsyncIn(getPeerAddress(), getAddress(), RTSystemServicesProtocol::getMessageString(msg->getEvtId()).c_str()); getActor()->receiveEvent(this, msg->getEvtId(), msg->getData()); } @@ -113,7 +111,7 @@ void RTSystemServicesProtocolConjPort::executeInitialTransition() { void RTSystemServicesProtocolConjPort::executeInitialTransition_impl() { DebuggingService::getInstance().addMessageAsyncOut(getAddress(), getPeerAddress(), - RTSystemServicesProtocol::getMessageString(RTSystemServicesProtocol::IN_executeInitialTransition)); + RTSystemServicesProtocol::getMessageString(RTSystemServicesProtocol::IN_executeInitialTransition).c_str()); if (getPeerAddress().isValid()) { Message* buffer = dynamic_cast(getPeerMsgReceiver())->getMessageBuffer(sizeof(Message)); if (buffer) { @@ -127,7 +125,7 @@ void RTSystemServicesProtocolConjPort::startDebugging() { void RTSystemServicesProtocolConjPort::startDebugging_impl() { DebuggingService::getInstance().addMessageAsyncOut(getAddress(), getPeerAddress(), - RTSystemServicesProtocol::getMessageString(RTSystemServicesProtocol::IN_startDebugging)); + RTSystemServicesProtocol::getMessageString(RTSystemServicesProtocol::IN_startDebugging).c_str()); if (getPeerAddress().isValid()) { Message* buffer = dynamic_cast(getPeerMsgReceiver())->getMessageBuffer(sizeof(Message)); if (buffer) { @@ -141,7 +139,7 @@ void RTSystemServicesProtocolConjPort::stopDebugging() { void RTSystemServicesProtocolConjPort::stopDebugging_impl() { DebuggingService::getInstance().addMessageAsyncOut(getAddress(), getPeerAddress(), - RTSystemServicesProtocol::getMessageString(RTSystemServicesProtocol::IN_stopDebugging)); + RTSystemServicesProtocol::getMessageString(RTSystemServicesProtocol::IN_stopDebugging).c_str()); if (getPeerAddress().isValid()) { Message* buffer = dynamic_cast(getPeerMsgReceiver())->getMessageBuffer(sizeof(Message)); if (buffer) { @@ -153,24 +151,24 @@ void RTSystemServicesProtocolConjPort::stopDebugging_impl() { //------------------------------------------------------------------------------------------------------------ // conjugated replicated port class //------------------------------------------------------------------------------------------------------------ -RTSystemServicesProtocolConjReplPort::RTSystemServicesProtocolConjReplPort(IInterfaceItemOwner* actor, const std::string& name, int localId) : +RTSystemServicesProtocolConjReplPort::RTSystemServicesProtocolConjReplPort(IInterfaceItemOwner* actor, const String& name, int localId) : ReplicatedPortBase(actor, name, localId) { } // incoming messages void RTSystemServicesProtocolConjReplPort::executeInitialTransition(){ - for (std::vector::iterator it = getItems().begin(); it != getItems().end(); ++it) { + for (Vector::iterator it = getItems().begin(); it != getItems().end(); ++it) { (dynamic_cast(*it))->executeInitialTransition(); } } void RTSystemServicesProtocolConjReplPort::startDebugging(){ - for (std::vector::iterator it = getItems().begin(); it != getItems().end(); ++it) { + for (Vector::iterator it = getItems().begin(); it != getItems().end(); ++it) { (dynamic_cast(*it))->startDebugging(); } } void RTSystemServicesProtocolConjReplPort::stopDebugging(){ - for (std::vector::iterator it = getItems().begin(); it != getItems().end(); ++it) { + for (Vector::iterator it = getItems().begin(); it != getItems().end(); ++it) { (dynamic_cast(*it))->stopDebugging(); } } diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src-gen/common/modelbase/RTSystemServicesProtocol.h b/runtime/org.eclipse.etrice.runtime.cpp/src-gen/common/modelbase/RTSystemServicesProtocol.h index 49f575623..83301edb3 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src-gen/common/modelbase/RTSystemServicesProtocol.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src-gen/common/modelbase/RTSystemServicesProtocol.h @@ -38,10 +38,10 @@ class RTSystemServicesProtocol { static bool isValidIncomingEvtID(int evtId) { return ((IN_executeInitialTransition <= evtId) && (evtId < MSG_MAX)); } - static const std::string& getMessageString(int msg_id); + static const etRuntime::String& getMessageString(int msg_id); private: - static const std::string s_messageStrings[]; + static const etRuntime::String s_messageStrings[]; }; @@ -50,8 +50,8 @@ class RTSystemServicesProtocol { //------------------------------------------------------------------------------------------------------------ class RTSystemServicesProtocolPort : public etRuntime::PortBase { public: - RTSystemServicesProtocolPort(etRuntime::IInterfaceItemOwner* actor, const std::string& name, int localId); - RTSystemServicesProtocolPort(etRuntime::IInterfaceItemOwner* actor, const std::string& name, int localId, int idx); + RTSystemServicesProtocolPort(etRuntime::IInterfaceItemOwner* actor, const etRuntime::String& name, int localId); + RTSystemServicesProtocolPort(etRuntime::IInterfaceItemOwner* actor, const etRuntime::String& name, int localId, int idx); virtual void destroy(); @@ -67,7 +67,7 @@ class RTSystemServicesProtocolPort : public etRuntime::PortBase { class RTSystemServicesProtocolReplPort : public etRuntime::ReplicatedPortBase { public: - RTSystemServicesProtocolReplPort(etRuntime::IInterfaceItemOwner* actor, const std::string& name, int localId); + RTSystemServicesProtocolReplPort(etRuntime::IInterfaceItemOwner* actor, const etRuntime::String& name, int localId); int getReplication() const { return getNInterfaceItems(); } int getIndexOf(const etRuntime::InterfaceItemBase& ifitem) const { return ifitem.getIdx(); } @@ -76,7 +76,7 @@ class RTSystemServicesProtocolReplPort : public etRuntime::ReplicatedPortBase { // outgoing messages protected: - virtual etRuntime::InterfaceItemBase* createInterfaceItem(etRuntime::IInterfaceItemOwner* rcv, const std::string& name, int lid, int idx) { + virtual etRuntime::InterfaceItemBase* createInterfaceItem(etRuntime::IInterfaceItemOwner* rcv, const etRuntime::String& name, int lid, int idx) { return new RTSystemServicesProtocolPort(rcv, name, lid, idx); } @@ -86,8 +86,8 @@ class RTSystemServicesProtocolReplPort : public etRuntime::ReplicatedPortBase { //------------------------------------------------------------------------------------------------------------ class RTSystemServicesProtocolConjPort : public etRuntime::PortBase { public: - RTSystemServicesProtocolConjPort(etRuntime::IInterfaceItemOwner* actor, const std::string& name, int localId); - RTSystemServicesProtocolConjPort(etRuntime::IInterfaceItemOwner* actor, const std::string& name, int localId, int idx); + RTSystemServicesProtocolConjPort(etRuntime::IInterfaceItemOwner* actor, const etRuntime::String& name, int localId); + RTSystemServicesProtocolConjPort(etRuntime::IInterfaceItemOwner* actor, const etRuntime::String& name, int localId, int idx); virtual void destroy(); @@ -109,7 +109,7 @@ class RTSystemServicesProtocolConjPort : public etRuntime::PortBase { class RTSystemServicesProtocolConjReplPort : public etRuntime::ReplicatedPortBase { public: - RTSystemServicesProtocolConjReplPort(etRuntime::IInterfaceItemOwner* actor, const std::string& name, int localId); + RTSystemServicesProtocolConjReplPort(etRuntime::IInterfaceItemOwner* actor, const etRuntime::String& name, int localId); int getReplication() const { return getNInterfaceItems(); } int getIndexOf(const etRuntime::InterfaceItemBase& ifitem) const { return ifitem.getIdx(); } @@ -121,7 +121,7 @@ class RTSystemServicesProtocolConjReplPort : public etRuntime::ReplicatedPortBas public: void stopDebugging(); protected: - virtual etRuntime::InterfaceItemBase* createInterfaceItem(etRuntime::IInterfaceItemOwner* rcv, const std::string& name, int lid, int idx) { + virtual etRuntime::InterfaceItemBase* createInterfaceItem(etRuntime::IInterfaceItemOwner* rcv, const etRuntime::String& name, int lid, int idx) { return new RTSystemServicesProtocolConjPort(rcv, name, lid, idx); } diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Map.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Map.cpp new file mode 100644 index 000000000..35bd4188a --- /dev/null +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Map.cpp @@ -0,0 +1,20 @@ +/******************************************************************************* + * Copyright (c) 2017 protos software gmbh (http://www.protos.de). + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * CONTRIBUTORS: + * Henrik Rentz-Reichert (initial contribution) + * + *******************************************************************************/ + +#include "common/containers/Map.h" + +namespace etRuntime { + +size_t MapStats::ncreated = 0; +size_t MapStats::ndestroyed = 0; + +} /* namespace etRuntime */ diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Map.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Map.h new file mode 100644 index 000000000..d77c53f5e --- /dev/null +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Map.h @@ -0,0 +1,232 @@ +/******************************************************************************* + * Copyright (c) 2017 protos software gmbh (http://www.protos.de). + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * CONTRIBUTORS: + * Henrik Rentz-Reichert (initial contribution) + * + *******************************************************************************/ + +#ifndef MAP_H_ +#define MAP_H_ + +#include "etDatatypes.h" +#include "Pair.h" +#include "Vector.h" + +namespace etRuntime { + +/** + * common map base class with counters for creations and destructions + */ +class MapStats { +public: + static size_t getNCreated() { return ncreated; } + static size_t getNDestroyed() { return ndestroyed; } + +private: + template friend class Map; + static size_t ncreated; + static size_t ndestroyed; +}; + +template +class Map { +public: + + typedef Pair Entry; + typedef typename Vector::iterator iterator; + typedef typename Vector::const_iterator const_iterator; + typedef typename Vector::reverse_iterator reverse_iterator; + + /** + * default constructor + */ + Map() + : _container() + { + ++MapStats::ncreated; + } + + /** + * copy constructor + */ + Map(const Map &rhs) + : _container(rhs._container) + { + ++MapStats::ncreated; + } + + /** + * virtual destructor + */ + virtual ~Map(void) { + ++MapStats::ndestroyed; + } + + /** + * Requests that the set capacity be at least enough to contain n elements. + * + * If n is greater than the current set capacity, the function causes the container + * to reallocate its storage increasing its capacity to n (or greater). + * In all other cases, the function call does not cause a reallocation and the set + * capacity is not affected. + * + * This function has no effect on the set size and cannot alter its elements. + */ + void reserve(size_t n) { + _container.reserve(n); + } + + /** + * returns the _size of this set + */ + int size(void) const { + return _container.size(); + } + + /** + * Returns whether the set is empty (i.e. whether its size is 0). + * This function does not modify the container in any way. + * To clear the content of a set, see Map::clear. + */ + bool empty(void) const { + return _container.empty(); + } + + void clear() { + _container.clear(); + } + + Value& operator[](const Key& key) { + for (iterator it=begin(); it!=end(); ++it) { + if (key==it->first) { + return it->second; + } + } + + _container.push_back(Entry(key, Value())); + return _container.back().second; + } + + iterator find(const Key& key) { + for (iterator it=begin(); it!=end(); ++it) { + if (key==(*it).first) { + return it; + } + } + return end(); + } + + const_iterator find(const Key& key) const { + for (const_iterator it=begin(); it!=end(); ++it) { + if (key==(*it).first) { + return it; + } + } + return end(); + } + + iterator erase(iterator position) { + return _container.erase(position); + } + + size_t erase(const Key& key) { + iterator it = find(key); + if (it==end()) { + return 0; + } + else { + _container.erase(it); + return 1; + } + } + + /** + * returns a pointer to the _data of this set (as a C array) + */ + Entry* getData(void) { + return _container.getData(); + } + + /** + * returns a const pointer to the _data of this set (as a C array) + */ + const Entry* getData(void) const { + return _container.getData(); + } + + /** + * copy assignment makes a deep copy + */ + Map& operator=(const Map &rhs) { + _container = rhs._container; + return *this; + } + + const_iterator begin() const { + return _container.begin(); + } + + const_iterator end() const { + return _container.end(); + } + + iterator begin() { + return _container.begin(); + } + + iterator end() { + return _container.end(); + } + + reverse_iterator rbegin() { + return _container.rbegin(); + } + + reverse_iterator rend() { + return _container.rend(); + } + +protected: + Vector _container; +}; + +/** + * comparison operator (expensive because not ordered - O(n^2)) + */ +template +inline bool operator==(const Map lhs, const Map rhs) { + if (rhs.size()!=lhs.size()) { + return false; + } + + // are all elements contained in rhs? + for (typename Map::const_iterator it=lhs.begin(); it!=lhs.end(); ++it) { + // find key + typename Map::const_iterator rit = rhs.find(it->first); + if (rit==rhs.end()) { + return false; + } + else { + // compare value + if (rit->second!=it->second) { + return false; + } + } + } + + return true; +} + +template +inline bool operator!=(const Map &lhs, const Map &rhs) { + return !(lhs==rhs); +} + +} /* namespace etRuntime */ +#endif /* MAP_H_ */ + diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Pair.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Pair.h new file mode 100644 index 000000000..ae61816e7 --- /dev/null +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Pair.h @@ -0,0 +1,84 @@ +/******************************************************************************* + * Copyright (c) 2017 protos software gmbh (http://www.protos.de). + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * CONTRIBUTORS: + * Henrik Rentz-Reichert (initial contribution) + * + *******************************************************************************/ + +#ifndef PAIR_H_ +#define PAIR_H_ + +#include "etDatatypes.h" + +namespace etRuntime { + + +template +struct Pair { + Pair() + : first(), second() + { } + Pair(const T1& f, const T2& s) + : first(f), second(s) + { } + + // copy constructor + // works if T1==U1 and T1==U2 or implicit conversions T1(U1) and T2(U2) exist + template + Pair(const Pair& p) + : first(p.first) + , second(p.second) + { + } + + T1 first; + T2 second; +}; + +/** + * two pairs of the same pair of types are equal iff their members are equal. + */ +template +inline bool operator==(const Pair& lhs, const Pair& rhs) { + return lhs.first == rhs.first && lhs.second == rhs.second; +} + +// uses operator== +template +inline bool operator!=(const Pair& lhs, const Pair& rhs) { + return !(lhs==rhs); +} + +// see http://www.cplusplus.com/reference/utility/pair/operators/ +template +inline bool operator<(const Pair& lhs, const Pair& rhs) { + return lhs.first < rhs.first + || (!(rhs.first < lhs.first) && lhs.second < rhs.second); +} + +// uses operator< +template +inline bool operator>(const Pair& lhs, const Pair& rhs) { + return rhs < lhs; +} + +// uses operator< +template +inline bool operator<=(const Pair& lhs, const Pair& rhs) { + return !(rhs < lhs); +} + +// uses operator< +template +inline bool operator>=(const Pair& lhs, const Pair& rhs) { + return !(lhs < rhs); +} + +} /* namespace etRuntime */ +#endif /* PAIR_H_ */ + diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Set.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Set.cpp new file mode 100644 index 000000000..e00d75d92 --- /dev/null +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Set.cpp @@ -0,0 +1,20 @@ +/******************************************************************************* + * Copyright (c) 2017 protos software gmbh (http://www.protos.de). + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * CONTRIBUTORS: + * Henrik Rentz-Reichert (initial contribution) + * + *******************************************************************************/ + +#include "common/containers/Set.h" + +namespace etRuntime { + +size_t SetStats::ncreated = 0; +size_t SetStats::ndestroyed = 0; + +} /* namespace etRuntime */ diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Set.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Set.h new file mode 100644 index 000000000..8fac8cada --- /dev/null +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Set.h @@ -0,0 +1,222 @@ +/******************************************************************************* + * Copyright (c) 2017 protos software gmbh (http://www.protos.de). + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * CONTRIBUTORS: + * Henrik Rentz-Reichert (initial contribution) + * + *******************************************************************************/ + +#ifndef SET_H_ +#define SET_H_ + +#include "etDatatypes.h" +#include "Vector.h" + +namespace etRuntime { + +/** + * common set base class with counters for allocations and deallocations + */ +class SetStats { +public: + static size_t getNCreated() { return ncreated; } + static size_t getNDestroyed() { return ndestroyed; } + +private: + template friend class Set; + static size_t ncreated; + static size_t ndestroyed; +}; + +template +class Set { +public: + + typedef typename Vector::iterator iterator; + typedef typename Vector::const_iterator const_iterator; + typedef typename Vector::reverse_iterator reverse_iterator; + + /** + * default constructor + */ + Set() + : _container() + { + ++SetStats::ncreated; + } + + /** + * copy constructor + */ + Set(const Set &rhs) + : _container(rhs._container) + { + ++SetStats::ncreated; + } + + /** + * virtual destructor + */ + virtual ~Set(void) { + ++SetStats::ndestroyed; + } + + /** + * Requests that the set capacity be at least enough to contain n elements. + * + * If n is greater than the current set capacity, the function causes the container + * to reallocate its storage increasing its capacity to n (or greater). + * In all other cases, the function call does not cause a reallocation and the set + * capacity is not affected. + * + * This function has no effect on the set size and cannot alter its elements. + */ + void reserve(size_t n) { + _container.reserve(n); + } + + /** + * returns the _size of this set + */ + int size(void) const { + return _container.size(); + } + + /** + * Returns whether the set is empty (i.e. whether its size is 0). + * This function does not modify the container in any way. + * To clear the content of a set, see Set::clear. + */ + bool empty(void) const { + return _container.empty(); + } + + void clear() { + _container.clear(); + } + + bool insert(const Type& t) { + iterator it = find(t); + if (it==end()) { + _container.push_back(t); + return true; + } + else { + return false; + } + } + + iterator find(const Type& t) { + for (iterator it=begin(); it!=end(); ++it) { + if (t==*it) { + return it; + } + } + return end(); + } + + const_iterator find(const Type& t) const { + for (const_iterator it=begin(); it!=end(); ++it) { + if (t==*it) { + return it; + } + } + return end(); + } + + iterator erase(iterator position) { + return _container.erase(position); + } + + size_t erase(const Type& t) { + iterator it = find(t); + if (it==end()) { + return 0; + } + else { + _container.erase(it); + return 1; + } + } + + /** + * returns a pointer to the _data of this set (as a C array) + */ + Type* getData(void) { + return _container.getData(); + } + + /** + * returns a const pointer to the _data of this set (as a C array) + */ + const Type* getData(void) const { + return _container.getData(); + } + + /** + * copy assignment makes a deep copy + */ + Set& operator=(const Set &rhs) { + _container = rhs._container; + return *this; + } + + const_iterator begin() const { + return _container.begin(); + } + + const_iterator end() const { + return _container.end(); + } + + iterator begin() { + return _container.begin(); + } + + iterator end() { + return _container.end(); + } + + reverse_iterator rbegin() { + return _container.rbegin(); + } + + reverse_iterator rend() { + return _container.rend(); + } + +protected: + Vector _container; +}; + +/** + * comparison operator (expensive because not ordered - O(n^2)) + */ +template +inline bool operator==(const Set lhs, const Set rhs) { + if (rhs.size()!=lhs.size()) { + return false; + } + + // are all elements contained in rhs? + for (typename Set::const_iterator it=lhs.begin(); it!=lhs.end(); ++it) { + if (rhs.find(*it)==rhs.end()) { + return false; + } + } + + return true; +} + +template +inline bool operator!=(const Set &lhs, const Set &rhs) { + return !(lhs==rhs); +} + +} /* namespace etRuntime */ +#endif /* SET_H_ */ + diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/String.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/String.cpp new file mode 100644 index 000000000..a82c11dd8 --- /dev/null +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/String.cpp @@ -0,0 +1,169 @@ +/******************************************************************************* + * Copyright (c) 2017 protos software gmbh (http://www.protos.de). + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * CONTRIBUTORS: + * Henrik Rentz-Reichert (initial contribution) + * + *******************************************************************************/ + +#include "common/containers/String.h" + +namespace etRuntime { + +size_t String::nallocs = 0; +size_t String::ndeallocs = 0; +size_t String::ncreated = 0; +size_t String::ndestroyed = 0; + +String::String() +: _size(0) +, _data(new char[1]) +{ + ++nallocs; + ++ncreated; + _data[0] = '\0'; +} + +String::~String(void) { + ++ndestroyed; + if (_data) { + delete[] _data; + ++ndeallocs; + } +} + +/* + * added this according to + * http://stackoverflow.com/questions/1634359/is-there-a-reverse-function-for-strstr + */ +static const char *rstrstr(const char * s1, const char * s2) { + size_t s1len = strlen(s1); + size_t s2len = strlen(s2); + const char *s; + + if (s2len > s1len) { + return NULL; + } + for (s = s1 + s1len - s2len; s >= s1; --s) { + if (strncmp(s, s2, s2len) == 0) { + return s; + } + } + return NULL; +} + +String& String::operator=(const char *rhs) { + if (rhs && rhs!=this->_data) { + size_t new_size = std::strlen(rhs) + 1; + if (new_size > _size) { + _size = new_size; + if (_data) { + delete[] _data; + ++ndeallocs; + } + _data = new char[new_size]; + ++nallocs; + } + std::strcpy(this->_data, rhs); + } + return *this; +} + +const String String::operator+=(const char* rhs) { + if (rhs) { + size_t new_size = this->length() + std::strlen(rhs) + 1; + if (new_size > _size) { + _size = new_size; + char* new_data = new char[new_size]; + ++nallocs; + if (_data) { + std::strcpy(new_data, _data); + delete[] _data; + ++ndeallocs; + } + else { + new_data[0] = '\0'; + } + _data = new_data; + } + std::strcat(this->_data, rhs); + } + + // Note: this function returns a const, not a const&! + // this prohibits things like (a + b) = c + return *this; +} + +const String String::operator+=(char c) { + size_t new_size = this->length() + 2; + if (new_size > _size) { + _size = new_size; + char* new_data = new char[new_size]; + ++nallocs; + if (_data) { + std::strcpy(new_data, _data); + delete[] _data; + ++ndeallocs; + } + _data = new_data; + } + _data[new_size-2] = c; + _data[new_size-1] = '\0'; + + // Note: this function returns a const, not a const&! + // this prohibits things like (a + b) = c + return *this; +} + +size_t String::find(const String& str, size_t pos) const { + if (pos>length()) { + return npos; + } + return std::strstr(_data + pos, str._data) - _data; +} + +size_t String::find(const char* str, size_t pos) const { + if (pos>length()) { + return npos; + } + return std::strstr(_data + pos, str) - _data; +} + +size_t String::find(char c, size_t pos) const { + if (pos>length()) { + return npos; + } + return std::strchr(_data + pos, c) - _data; +} + +size_t String::rfind(const String& str) const { + return rstrstr(_data, str._data) - _data; +} + +size_t String::rfind(const char* str) const { + return rstrstr(_data, str) - _data; +} + +size_t String::rfind(char c) const { + return std::strrchr(_data, c) - _data; +} + + +String String::substr(size_t pos, size_t len) const { + if (pos > length()) { + return String(""); + } + + String result(_data+pos); + if (len < result.length()) { + result._data[len] = '\0'; + } + + return result; +} + +} /* namespace etRuntime */ diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/String.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/String.h new file mode 100644 index 000000000..70ac624b8 --- /dev/null +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/String.h @@ -0,0 +1,318 @@ +/******************************************************************************* + * Copyright (c) 2017 protos software gmbh (http://www.protos.de). + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * CONTRIBUTORS: + * Henrik Rentz-Reichert (initial contribution) + * + *******************************************************************************/ + +#ifndef STRING_H_ +#define STRING_H_ + +#include +#include + +namespace etRuntime { + +/** + * a static size string class that basically encapsulates a C string + */ +class String { +public: + /** + * default constructor is empty string + */ + String(); + + /** + * copy constructor calls operator=(const char *rhs) + */ + String(const String &rhs) + : _size(0) + , _data(0) + { + ++ncreated; + operator=(rhs._data); + } + + /** + * constructor calls operator=(const char *rhs) + */ + String(const char *rhs) + : _size(0) + , _data(0) + { + ++ncreated; + operator=(rhs); + } + + /** + * virtual destructor + */ + virtual ~String(void); + + + /** + * returns the length of the C string stored + */ + size_t length(void) const + { + return std::strlen(this->_data); + } + + /** + * returns a const char * pointer to the data of this array + */ + const char* c_str(void) const + { + return this->_data; + } + + /** + * returns the character at the given position. If index is out of range 0 is returned + */ + char operator[](int index) const { + return (index < 0 || index >= (int)_size) ? 0 : _data[index]; + } + + /** + * forwards to operator=(const char *rhs) + */ + String& operator=(const String &rhs) + { + return operator=(rhs._data); + } + + /** + * creates a copy of the rhs + */ + String& operator=(const char *rhs); + + // + // string concatenation + // + + /* + * concatenates the rhs to the end of the string. + */ + const String operator+=(const String& rhs) { + return operator+=(rhs._data); + } + + /* + * concatenates the rhs to the end of the string. + */ + const String operator+=(const char* rhs); + + /* + * concatenates the c to the end of the string. + */ + const String operator+=(char c); + + // + // comparison + // + + /** + * compares two strings + */ + int compare(const String& rhs) const { + return std::strcmp(this->_data, rhs._data); + } + int compareXX(const String& rhs) const { + return std::strcmp(this->_data, rhs._data); + } +// +// /** +// * compares a string with a C-String +// */ +// int compare(const char *rhs) const { +// return strcmp(this->_data, rhs); +// } + + // + // find + // + static const size_t npos = -1; + + size_t find(const String& str, size_t pos = 0) const; + size_t find(const char* str, size_t pos = 0) const; + size_t find(char c, size_t pos = 0) const; + + size_t rfind(const String& str) const; + size_t rfind(const char* str) const; + size_t rfind(char c) const; + + // + // sub strings + // + String substr(size_t pos = 0, size_t len = npos) const; + + static size_t getNAllocations() { return nallocs; } + static size_t getNDeallocations() { return ndeallocs; } + static size_t getNCreated() { return ncreated; } + static size_t getNDestroyed() { return ndestroyed; } + +private: + static size_t nallocs; + static size_t ndeallocs; + static size_t ncreated; + static size_t ndestroyed; + + size_t _size; + char* _data; +}; + +// +// string concatenation +// + +/** + * concatenates lhs and rhs. + */ +inline const String operator+(const String &lhs, const String &rhs) { + // make a copy and add + return String(lhs) += rhs; +} + +/** + * concatenates lhs and rhs. + */ +inline const String operator+(const String &lhs, const char* rhs) { + // make a copy and add + return String(lhs) += rhs; +} + +/** + * concatenates lhs and c + */ +inline const String operator+(const String &lhs, char c) { + // make a copy and add + String result(lhs); + result += c; + return result; +} + +/** + * concatenates lhs and rhs. + */ +inline const String operator+(const char* lhs, const String& rhs) { + // create a string and add + String result(lhs); + result += rhs; + return result; +} + +/** + * concatenates c and rhs. + */ +inline const String operator+(char c, const String& rhs) { + // create a string and add + String result(""); + result += c; + result += rhs; + return result; +} + +// +// string comparison +// + +/** + * compares two strings + */ +inline bool operator==(const String& lhs, const String &rhs) { + return lhs.compare(rhs)==0; +} + +/** + * compares a string with a C-string + */ +inline bool operator==(const String& lhs, const char *rhs) { + return lhs.compare(rhs)==0; +} + +/** + * compares a C-string with a string + */ +inline bool operator==(const char* lhs, const String& rhs) { + return rhs.compare(lhs)==0; +} + +/** + * compares two strings + */ +inline bool operator!=(const String &lhs, const String &rhs) { + return !(lhs == rhs); +} + +/** + * compares a string and a C-string + */ +inline bool operator!=(const String &lhs, const char *rhs) { + return !(lhs == rhs); +} + +/** + * compares a C-string and a string + */ +inline bool operator!=(const char* lhs, const String& rhs) { + return !(lhs == rhs); +} + +inline bool operator<(const String &lhs, const String& rhs) { + return lhs.compare(rhs) < 0; +} + +inline bool operator<(const String &lhs, const char* rhs) { + return lhs.compare(rhs) < 0; +} + +inline bool operator<(const char* lhs, const String& rhs) { + return rhs.compare(lhs) > 0; +} + +inline bool operator<=(const String &lhs, const String& rhs) { + return lhs.compare(rhs) <= 0; +} + +inline bool operator<=(const String &lhs, const char* rhs) { + return lhs.compare(rhs) <= 0; +} + +inline bool operator<=(const char* lhs, const String& rhs) { + return rhs.compare(lhs) >= 0; +} + +inline bool operator>(const String &lhs, const String& rhs) { + return lhs.compare(rhs) > 0; +} + +inline bool operator>(const String &lhs, const char* rhs) { + return lhs.compare(rhs) > 0; +} + +inline bool operator>(const char* lhs, const String& rhs) { + return rhs.compare(lhs) < 0; +} + +inline bool operator>=(const String &lhs, const String& rhs) { + return lhs.compare(rhs) >= 0; +} + +inline bool operator>=(const String &lhs, const char* rhs) { + return lhs.compare(rhs) >= 0; +} + +inline bool operator>=(const char* lhs, const String& rhs) { + return rhs.compare(lhs) <= 0; +} + +} /* namespace etRuntime */ + +#endif /* STRING_H_ */ + diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Vector.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Vector.cpp new file mode 100644 index 000000000..e688803eb --- /dev/null +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Vector.cpp @@ -0,0 +1,22 @@ +/******************************************************************************* + * Copyright (c) 2017 protos software gmbh (http://www.protos.de). + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * CONTRIBUTORS: + * Henrik Rentz-Reichert (initial contribution) + * + *******************************************************************************/ + +#include "common/containers/Vector.h" + +namespace etRuntime { + +size_t VectorStats::nallocs = 0; +size_t VectorStats::ndeallocs = 0; +size_t VectorStats::ncreated = 0; +size_t VectorStats::ndestroyed = 0; + +} /* namespace etRuntime */ diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Vector.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Vector.h new file mode 100644 index 000000000..065a58f9d --- /dev/null +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/Vector.h @@ -0,0 +1,334 @@ +/******************************************************************************* + * Copyright (c) 2017 protos software gmbh (http://www.protos.de). + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * CONTRIBUTORS: + * Henrik Rentz-Reichert (initial contribution) + * + *******************************************************************************/ + +#ifndef VECTOR_H_ +#define VECTOR_H_ + +#include "etDatatypes.h" +#include + +namespace etRuntime { + +/** + * common vector base class with counters for allocations and deallocations + */ +class VectorStats { +public: + static size_t getNAllocations() { return nallocs; } + static size_t getNDeallocations() { return ndeallocs; } + static size_t getNCreated() { return ncreated; } + static size_t getNDestroyed() { return ndestroyed; } + +private: + template friend class Vector; + static size_t nallocs; + static size_t ndeallocs; + static size_t ncreated; + static size_t ndestroyed; +}; + +template +class Vector { +public: + + typedef Type* iterator; + typedef const Type* const_iterator; + + class reverse_iterator { + public: + reverse_iterator(Type* d) : _current(d) {} + reverse_iterator(const reverse_iterator& rhs) : _current(rhs._current) {} + + reverse_iterator& operator=(const reverse_iterator& rhs) { + _current = rhs._current; + return *this; + } + + Type operator*() const { + Type* tmp = _current; + return *(--tmp); + } + Type* operator->() const { + return &(operator*()); + } + + reverse_iterator& operator++() { + --_current; + return *this; + } + reverse_iterator operator++(int) { + reverse_iterator tmp = *this; + --_current; + return tmp; + } + reverse_iterator& operator--() { + ++_current; + return *this; + } + reverse_iterator operator--(int) { + reverse_iterator tmp = *this; + ++_current; + return tmp; + } + + bool operator==(const reverse_iterator& rhs) const { + return _current == rhs._current; + } + bool operator!=(const reverse_iterator& rhs) const { + return !(operator==(rhs)); + } + private: + Type* _current; + }; + + /** + * default constructor + */ + Vector() + : _size(0) + , _capacity(0) + , _data(0) + { + ++VectorStats::ncreated; + } + + /** + * copy constructor + */ + Vector(const Vector &rhs) + : _size(rhs._size) + , _capacity(rhs._size) + , _data(new Type[rhs._size]) + { + ++VectorStats::ncreated; + ++VectorStats::nallocs; + for (int i = 0; i < _size; i++) { + _data[i] = rhs[i]; + } + } + + /** + * initializes each vector element to t + */ + Vector(size_t size, const Type& t=Type()) + : _size(size) + , _capacity(size) + , _data(new Type[size]) + { + ++VectorStats::ncreated; + ++VectorStats::nallocs; + for (int i = 0; i < _size; i++) { + _data[i] = t; + } + } + + /** + * virtual destructor + */ + virtual ~Vector(void) { + ++VectorStats::ndestroyed; + if (_data) { + delete[] _data; + ++VectorStats::ndeallocs; + } + } + + /** + * Requests that the vector capacity be at least enough to contain n elements. + * + * If n is greater than the current vector capacity, the function causes the container + * to reallocate its storage increasing its capacity to n (or greater). + * In all other cases, the function call does not cause a reallocation and the vector + * capacity is not affected. + * + * This function has no effect on the vector size and cannot alter its elements. + */ + void reserve(size_t n) { + if (n > _capacity) { + _capacity = n; + Type* new_data = new Type[_capacity]; + ++VectorStats::nallocs; + if (_data) { + for (int i = 0; i < _size; i++) { + new_data[i] = _data[i]; + } + delete[] _data; + ++VectorStats::ndeallocs; + } + _data = new_data; + } + } + + /** + * returns the _size of this vector + */ + int size(void) const { + return _size; + } + + /** + * Returns whether the vector is empty (i.e. whether its size is 0). + * This function does not modify the container in any way. + * To clear the content of a vector, see Vector::clear. + */ + bool empty(void) const { + return _size==0; + } + + void clear() { + _size = 0; + _capacity = 0; + if (_data) { + delete[] _data; + ++VectorStats::ndeallocs; + } + _data = 0; + } + + void push_back(const Type& t) { + if (_size>=_capacity) { + reserve(_size + const_grow_by); + } + + _data[_size++] = t; + } + + void pop_back() { + if (_size>0) { + --_size; + } + } + + iterator erase (iterator position) { + if (_size>0 && (position >= _data) && (position < _data+_size)) { + // copy following elements one position down each + iterator curr = position; + iterator next = position + 1; + for (; next!=end(); ++curr, ++next) { + *curr = *next; + } + --_size; + } + return position; + } + + /** + * returns a pointer to the _data of this vector (as a C array) + */ + Type* getData(void) { + return this->_data; + } + + /** + * returns a const pointer to the _data of this vector (as a C array) + */ + const Type* getData(void) const { + return this->_data; + } + + /** + * indexed access without range check + */ + Type& operator[](int index) { + return _data[index]; + } + + /** + * indexed access without range check + */ + const Type& operator[](int index) const { + return _data[index]; + } + + Type& front() { + return _data[0]; + } + + const Type& front() const { + return _data[0]; + } + + Type& back() { + return _data[_size-1]; + } + + const Type& back() const { + return _data[_size-1]; + } + + /** + * copy assignment makes a deep copy + */ + Vector& operator=(const Vector &rhs) { + if (&rhs!=this) { + _size = rhs._size; + if (_size > _capacity) { + _capacity = _size; + if (_data) { + delete[] _data; + ++VectorStats::ndeallocs; + } + _data = new Type[_capacity]; + ++VectorStats::nallocs; + } + for (int i = 0; i < _size; i++) { + _data[i] = rhs[i]; + } + } + return *this; + } + + /** + * comparison operator based on memcmp() + */ + bool operator==(const Vector &rhs) const { + return _size!=rhs._size ? false : std::memcmp(this->_data, rhs._data, _size*sizeof(*_data)) == 0; + } + bool operator!=(const Vector &rhs) const { + return !(operator==(rhs)); + } + + const_iterator begin() const { + return _data; + } + + const_iterator end() const { + return _data + _size; + } + + iterator begin() { + return _data; + } + + iterator end() { + return _data + _size; + } + + reverse_iterator rbegin() { + return reverse_iterator(_data + _size); + } + + reverse_iterator rend() { + return reverse_iterator(_data); + } + +protected: + size_t _size; + size_t _capacity; + Type* _data; ///< the C array holding the _data + + static const size_t const_grow_by = 4; +}; + +} /* namespace etRuntime */ +#endif /* VECTOR_H_ */ + diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/DebuggingService.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/DebuggingService.cpp index b2dedc349..7216a1640 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/DebuggingService.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/DebuggingService.cpp @@ -15,7 +15,6 @@ #include "common/modelbase/ActorClassBase.h" #include "common/modelbase/SubSystemClassBase.h" #include "common/modelbase/InterfaceItemBase.h" -#include namespace etRuntime { @@ -32,66 +31,76 @@ DebuggingService::DebuggingService() : } const InterfaceItemBase* DebuggingService::getPort(const Address& address) const { - std::map::const_iterator it = m_portInstances.find(address); + Map::const_iterator it = m_portInstances.find(address); if (it != m_portInstances.end()) return it->second; return 0; } -void DebuggingService::addMessageAsyncOut(const Address& source, const Address& target, const std::string& msg) { +void DebuggingService::addMessageAsyncOut(const Address& source, const Address& target, const String& msg) { const InterfaceItemBase* srcPort = getPort(source); const InterfaceItemBase* tgtPort = getPort(target); - if (srcPort != 0 && tgtPort != 0) - m_asyncLogger.addMessageAsyncOut(srcPort->getActor()->getInstancePath(), tgtPort->getActor()->getInstancePath(), - msg); + if (srcPort != 0 && tgtPort != 0) { + etRuntime::String srcPath = srcPort->getActor()->getInstancePath(); + etRuntime::String tgtPath = tgtPort->getActor()->getInstancePath(); + m_asyncLogger.addMessageAsyncOut(srcPath, tgtPath, msg); + } } -void DebuggingService::addMessageAsyncIn(const Address& source, const Address& target, const std::string& msg) { +void DebuggingService::addMessageAsyncIn(const Address& source, const Address& target, const String& msg) { const InterfaceItemBase* srcPort = getPort(source); const InterfaceItemBase* tgtPort = getPort(target); - if (srcPort != 0 && tgtPort != 0) - m_asyncLogger.addMessageAsyncIn(srcPort->getActor()->getInstancePath(), tgtPort->getActor()->getInstancePath(), - msg); + if (srcPort != 0 && tgtPort != 0) { + etRuntime::String srcPath = srcPort->getActor()->getInstancePath(); + etRuntime::String tgtPath = tgtPort->getActor()->getInstancePath(); + m_asyncLogger.addMessageAsyncIn(srcPath, tgtPath, msg); + } } -void DebuggingService::addMessageSyncCall(const Address& source, const Address& target, const std::string& msg) { +void DebuggingService::addMessageSyncCall(const Address& source, const Address& target, const String& msg) { const InterfaceItemBase* srcPort = getPort(source); const InterfaceItemBase* tgtPort = getPort(target); - if (srcPort != 0 && tgtPort != 0) - m_asyncLogger.addMessageSyncCall(srcPort->getActor()->getInstancePath(), tgtPort->getActor()->getInstancePath(), - msg); + if (srcPort != 0 && tgtPort != 0) { + etRuntime::String srcPath = srcPort->getActor()->getInstancePath(); + etRuntime::String tgtPath = tgtPort->getActor()->getInstancePath(); + m_asyncLogger.addMessageSyncCall(srcPath, tgtPath, msg); + } } -void DebuggingService::addMessageSyncReturn(const Address& source, const Address& target, const std::string& msg) { +void DebuggingService::addMessageSyncReturn(const Address& source, const Address& target, const String& msg) { const InterfaceItemBase* srcPort = getPort(source); const InterfaceItemBase* tgtPort = getPort(target); - if (srcPort != 0 && tgtPort != 0) + if (srcPort != 0 && tgtPort != 0) { m_asyncLogger.addMessageSyncReturn(srcPort->getActor()->getInstancePath(), tgtPort->getActor()->getInstancePath(), msg); + } } -void DebuggingService::addActorState(const ActorClassBase& actor, const std::string& state) { - m_asyncLogger.addActorState(actor.getInstancePath(), state); +void DebuggingService::addActorState(const ActorClassBase& actor, const String& state) { + etRuntime::String instancePath = actor.getInstancePath(); + m_asyncLogger.addActorState(instancePath, state); } -void DebuggingService::addMessageActorCreate(const SubSystemClassBase& parent, const std::string& refName) { - m_asyncLogger.addMessageActorCreate(parent.getInstancePath(), - parent.getInstancePath() + IRTObject::PATH_DELIM + refName); +void DebuggingService::addMessageActorCreate(const SubSystemClassBase& parent, const String& refName) { + etRuntime::String parentPath = parent.getInstancePath(); + m_asyncLogger.addMessageActorCreate(parentPath, String(parentPath) + IRTObject::PATH_DELIM + refName); } -void DebuggingService::addMessageActorCreate(const ActorClassBase& parent, const std::string& refName) { - m_asyncLogger.addMessageActorCreate(parent.getInstancePath(), - parent.getInstancePath() + IRTObject::PATH_DELIM + refName); +void DebuggingService::addMessageActorCreate(const ActorClassBase& parent, const String& refName) { + etRuntime::String parentPath = parent.getInstancePath(); + m_asyncLogger.addMessageActorCreate(parentPath, String(parentPath) + IRTObject::PATH_DELIM + refName); } void DebuggingService::addMessageActorDestroy(const ActorClassBase& inst) { + etRuntime::String parentPath = inst.getParent()->getInstancePath(); + etRuntime::String instancePath = inst.getInstancePath(); //if (!(inst.getParent() instanceof OptionalActorInterfaceBase)) - m_asyncLogger.addMessageActorDestroy(inst.getParent()->getInstancePath(), inst.getInstancePath()); + m_asyncLogger.addMessageActorDestroy(parentPath, instancePath); } -void DebuggingService::addVisibleComment(const std::string& comment) { +void DebuggingService::addVisibleComment(const String& comment) { m_asyncLogger.addVisibleComment(comment); } diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/DebuggingService.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/DebuggingService.h index 0ac9e6354..ff070c243 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/DebuggingService.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/DebuggingService.h @@ -14,11 +14,10 @@ #define DEBUGGINGSERVICE_H_ #include "common/debugging/MSCLogger.h" +#include "common/containers/Map.h" #include "common/messaging/Address.h" #include "etDatatypes.h" #include "common/modelbase/InterfaceItemBase.h" -#include -#include namespace etRuntime { @@ -33,15 +32,15 @@ public: static DebuggingService& getInstance(); - void addMessageAsyncOut(const Address& source, const Address& target, const std::string& msg); - void addMessageAsyncIn(const Address& source, const Address& target, const std::string& msg); - void addMessageSyncCall(const Address& source, const Address& target, const std::string& msg); - void addMessageSyncReturn(const Address& source, const Address& target, const std::string& msg); - void addActorState(const ActorClassBase& actor, const std::string& state); - void addMessageActorCreate(const SubSystemClassBase& parent, const std::string& refName); - void addMessageActorCreate(const ActorClassBase& parent, const std::string& refName); + void addMessageAsyncOut(const Address& source, const Address& target, const String& msg); + void addMessageAsyncIn(const Address& source, const Address& target, const String& msg); + void addMessageSyncCall(const Address& source, const Address& target, const String& msg); + void addMessageSyncReturn(const Address& source, const Address& target, const String& msg); + void addActorState(const ActorClassBase& actor, const String& state); + void addMessageActorCreate(const SubSystemClassBase& parent, const String& refName); + void addMessageActorCreate(const ActorClassBase& parent, const String& refName); void addMessageActorDestroy(const ActorClassBase& inst); - void addVisibleComment(const std::string& comment); + void addVisibleComment(const String& comment); void addPortInstance(const InterfaceItemBase& port); void removePortInstance(const InterfaceItemBase& port); @@ -52,7 +51,7 @@ private: MSCLogger m_asyncLogger; MSCLogger m_syncLogger; - std::map m_portInstances; + Map m_portInstances; const InterfaceItemBase* getPort(const Address& address) const; diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCFilter.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCFilter.cpp index 09d9c153b..db011e4cb 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCFilter.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCFilter.cpp @@ -12,8 +12,6 @@ #include "common/debugging/MSCFilter.h" #include "etStdDatatypes.h" -#include -#include namespace etRuntime { @@ -25,10 +23,10 @@ void MSCFilter::addFilter(FilterItem filter) { filterList.push_back(filter); } -etBool MSCFilter::applyTo(const std::string& text) { +etBool MSCFilter::applyTo(const String& text) { if (filterList.empty()) return true; // no filters -> all messages will be logged - std::list::iterator it = filterList.begin(); + Vector::iterator it = filterList.begin(); for (; it != filterList.end(); ++it) { if (text.compare((*it).filter) == 0) return !(*it).exclude; @@ -36,13 +34,13 @@ etBool MSCFilter::applyTo(const std::string& text) { return false; } -std::string MSCFilter::reduceString(const std::string& string) { +String MSCFilter::reduceString(const String& text) { // if (filterList.size() == 1) // //TODO: filtering with regular expression // // return string.replaceFirst(filterList.front().filter, ""); // return string; // else - return string; + return text; } } /* namespace etRuntime */ diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCFilter.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCFilter.h index a3c5d98d6..6ec0f1a84 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCFilter.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCFilter.h @@ -14,8 +14,8 @@ #define MSCFILTER_H_ #include "etDatatypes.h" -#include -#include +#include "common/containers/String.h" +#include "common/containers/Vector.h" namespace etRuntime { @@ -23,14 +23,18 @@ class MSCFilter { public: class FilterItem { public: - FilterItem(const std::string& filter_, etBool exclude_) : - exclude(exclude_), - filter(filter_) { + FilterItem(const String& filter_, etBool exclude_) + : exclude(exclude_) + , filter(filter_) + { + } + FilterItem() + : exclude() + , filter() + { } etBool exclude; - std::string filter; - private: - FilterItem(); + String filter; }; MSCFilter(); @@ -38,11 +42,11 @@ public: } void addFilter(FilterItem filter); - etBool applyTo(const std::string& text); - std::string reduceString(const std::string& string); + etBool applyTo(const String& text); + String reduceString(const String& text); private: - std::list filterList; + Vector filterList; }; diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCFunctionObject.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCFunctionObject.cpp index 6b7d6ca94..b75e84e95 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCFunctionObject.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCFunctionObject.cpp @@ -15,17 +15,17 @@ using namespace etRuntime; -MSCFunctionObject::MSCFunctionObject(const std::string& objectName, const std::string& message) : +MSCFunctionObject::MSCFunctionObject(const String& objectName, const String& message) : m_syncLogger(DebuggingService::getInstance().getSyncLogger()), m_targetName(objectName), - m_sourceName(m_syncLogger.getObjectName()) + m_sourceName(m_syncLogger.getObjectName().c_str()) { - m_syncLogger.setObjectName(m_targetName); - m_syncLogger.addMessageSyncCall(m_sourceName, m_targetName, message); + m_syncLogger.setObjectName(m_targetName.c_str()); + m_syncLogger.addMessageSyncCall(m_sourceName.c_str(), m_targetName.c_str(), message.c_str()); } MSCFunctionObject::~MSCFunctionObject() { - m_syncLogger.setObjectName(m_sourceName); - m_syncLogger.addMessageSyncReturn(m_sourceName, m_targetName, "return"); + m_syncLogger.setObjectName(m_sourceName.c_str()); + m_syncLogger.addMessageSyncReturn(m_sourceName.c_str(), m_targetName.c_str(), "return"); } diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCFunctionObject.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCFunctionObject.h index e521ce532..898b9783b 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCFunctionObject.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCFunctionObject.h @@ -13,20 +13,20 @@ #ifndef SRC_COMMON_DEBUGGING_MSCFUNCTIONOBJECT_H_ #define SRC_COMMON_DEBUGGING_MSCFUNCTIONOBJECT_H_ -#include #include "common/debugging/MSCLogger.h" +#include "common/containers/String.h" namespace etRuntime { class MSCFunctionObject { public: - MSCFunctionObject(const std::string& objectName, const std::string& message); + MSCFunctionObject(const String& objectName, const String& message); ~MSCFunctionObject(); private: MSCLogger& m_syncLogger; - const std::string m_targetName; - const std::string m_sourceName; + const String m_targetName; + const String m_sourceName; }; } // namespace etRuntime diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCLogger.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCLogger.cpp index 528ea0087..7651e09e4 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCLogger.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCLogger.cpp @@ -14,8 +14,6 @@ #include "common/debugging/MSCLogger.h" #include "debugging/etLogger.h" #include "etDatatypes.h" -#include -#include namespace etRuntime { @@ -36,7 +34,7 @@ MSCLogger::~MSCLogger() { etMutex_destruct(&m_mutex); } -void MSCLogger::setMSC(const std::string& msc_name, const std::string& path) { +void MSCLogger::setMSC(const String& msc_name, const String& path) { m_msc_name = msc_name; m_path = path; if(m_filter != NULL) @@ -50,78 +48,82 @@ void MSCLogger::open() { etMutex_leave(&m_mutex); } -void MSCLogger::addMessageAsyncOut(const std::string& source, const std::string& target, const std::string& message) { +void MSCLogger::addMessageAsyncOut(const String& source, const String& target, const String& message) { etMutex_enter(&m_mutex); createLine(source, " >-- ", target, message); etMutex_leave(&m_mutex); } -void MSCLogger::addMessageAsyncIn(const std::string& source, const std::string& target, const std::string& message) { +void MSCLogger::addMessageAsyncIn(const String& source, const String& target, const String& message) { etMutex_enter(&m_mutex); createLine(source, " --> ", target, message); etMutex_leave(&m_mutex); } -void MSCLogger::addMessageSyncCall(const std::string& source, const std::string& target, const std::string& message) { +void MSCLogger::addMessageSyncCall(const String& source, const String& target, const String& message) { etMutex_enter(&m_mutex); createLine(source, " ==> ", target, message); etMutex_leave(&m_mutex); } -void MSCLogger::addMessageSyncReturn(const std::string& source, const std::string& target, const std::string& message) { +void MSCLogger::addMessageSyncReturn(const String& source, const String& target, const String& message) { etMutex_enter(&m_mutex); createLine(source, " <== ", target, message); etMutex_leave(&m_mutex); } -void MSCLogger::addMessageActorCreate(const std::string& source, const std::string& target) { +void MSCLogger::addMessageActorCreate(const String& source, const String& target) { etMutex_enter(&m_mutex); createLine(source, " (!) ", target, ""); etMutex_leave(&m_mutex); } -void MSCLogger::addMessageActorDestroy(const std::string& source, const std::string& target) { +void MSCLogger::addMessageActorDestroy(const String& source, const String& target) { etMutex_enter(&m_mutex); createLine(source, " (X) ", target, ""); etMutex_leave(&m_mutex); } -void MSCLogger::addNote(const std::string& actor, const std::string& note) { +void MSCLogger::addNote(const String& actor, const String& note) { etMutex_enter(&m_mutex); //if (filter.applyTo(actor)) - getCommandList().push_back("\t" + m_filter->reduceString(actor) + " note: " + note); + String reduced = m_filter->reduceString(actor.c_str()); + getCommandList().push_back("\t" + reduced + " note: " + note); etMutex_leave(&m_mutex); } -void MSCLogger::addMessageCreate(const std::string& source, const std::string& target) { +void MSCLogger::addMessageCreate(const String& source, const String& target) { etMutex_enter(&m_mutex); createLine(source, " (!) ", target, ""); etMutex_leave(&m_mutex); } -void MSCLogger::addActorState(const std::string& actor, const std::string& state) { +void MSCLogger::addActorState(const String& actor, const String& state) { etMutex_enter(&m_mutex); //if (filter->applyTo(actor)) - getCommandList().push_back("\t" + m_filter->reduceString(actor) + " >>> " + state); + String reduced = m_filter->reduceString(actor.c_str()); + getCommandList().push_back("\t" + reduced + " >>> " + state); etMutex_leave(&m_mutex); } -void MSCLogger::addVisibleComment(const std::string& comment) { +void MSCLogger::addVisibleComment(const String& comment) { etMutex_enter(&m_mutex); getCommandList().push_back("# " + comment); etMutex_leave(&m_mutex); } -void MSCLogger::createLine(const std::string& source, const std::string& mid, const std::string& target, - const std::string& message) { +void MSCLogger::createLine(const String& source, const String& mid, const String& target, + const String& message) { //if (filter->applyTo(source) && filter->applyTo(target)) { + String reduced_src = m_filter->reduceString(source.c_str()); + String reduced_tgt = m_filter->reduceString(target.c_str()); getCommandList().push_back( - "\t" + m_filter->reduceString(source) + mid + m_filter->reduceString(target) + " " + message); + "\t" + reduced_src + mid + reduced_tgt + " " + message); } void MSCLogger::close() { if (m_is_open) { - std::string path = m_path + m_msc_name + ".seq"; + String path = m_path + m_msc_name + ".seq"; etFileHandle handle = etLogger_fopen(path.c_str(), "w+"); etMutex_enter(&m_mutex); if (handle != 0) { @@ -136,7 +138,7 @@ void MSCLogger::close() { void MSCLogger::saveMSCforTrace2UML(etFileHandle handle) { etLogger_fprintf(handle, "; generated MSC for Trace2UML\n"); - std::list::iterator it = getCommandList().begin(); + Vector::iterator it = getCommandList().begin(); for (; it != getCommandList().end(); ++it){ etLogger_fprintf(handle, (*it).c_str()); etLogger_fprintf(handle, "\n"); diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCLogger.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCLogger.h index 440f20ef7..e42f32929 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCLogger.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/debugging/MSCLogger.h @@ -14,9 +14,8 @@ #define MSCLOGGER_H_ #include "osal/etMutex.h" -#include -#include -#include +#include "common/containers/String.h" +#include "common/containers/Vector.h" namespace etRuntime { @@ -27,44 +26,44 @@ public: MSCLogger(); virtual ~MSCLogger(); - void setMSC(const std::string& msc_name, const std::string& path); + void setMSC(const String& msc_name, const String& path); /* synchronized */ void open(); - void addMessageAsyncOut(const std::string& source, const std::string& target, const std::string& message); - void addMessageAsyncIn(const std::string& source, const std::string& target, const std::string& message); - void addMessageSyncCall(const std::string& source, const std::string& target, const std::string& message); - void addMessageSyncReturn(const std::string& source, const std::string& target, const std::string& message); - void addMessageActorCreate(const std::string& source, const std::string& target); - void addMessageActorDestroy(const std::string& source, const std::string& target); - void addNote(const std::string& actor, const std::string& note); - void addMessageCreate(const std::string& source, const std::string& target); - void addActorState(const std::string& actor, const std::string& state); - void addVisibleComment(const std::string& comment); + void addMessageAsyncOut(const String& source, const String& target, const String& message); + void addMessageAsyncIn(const String& source, const String& target, const String& message); + void addMessageSyncCall(const String& source, const String& target, const String& message); + void addMessageSyncReturn(const String& source, const String& target, const String& message); + void addMessageActorCreate(const String& source, const String& target); + void addMessageActorDestroy(const String& source, const String& target); + void addNote(const String& actor, const String& note); + void addMessageCreate(const String& source, const String& target); + void addActorState(const String& actor, const String& state); + void addVisibleComment(const String& comment); void close(); /* --- */ - const std::string& getObjectName(void) { return m_objectName; } - void setObjectName(const std::string& name) { m_objectName = name; } + const String& getObjectName(void) { return m_objectName; } + void setObjectName(const String& name) { m_objectName = name; } - std::list& getCommandList() { return m_commandList; }; + Vector& getCommandList() { return m_commandList; }; MSCFilter* getMSCFilter(){ return m_filter; }; private: - void createLine(const std::string& source, const std::string& mid, const std::string& target, const std::string& message); + void createLine(const String& source, const String& mid, const String& target, const String& message); void saveMSCforTrace2UML(etFileHandle handle); - std::list m_commandList; + Vector m_commandList; MSCFilter* m_filter; - std::string m_path; - std::string m_msc_name ; + String m_path; + String m_msc_name ; etBool m_is_open; etMutex m_mutex; - std::string m_objectName; + String m_objectName; MSCLogger(const MSCLogger& right); MSCLogger& operator=(const MSCLogger& right); diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/AbstractMessageReceiver.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/AbstractMessageReceiver.h index d4a8f7897..eafe6f337 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/AbstractMessageReceiver.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/AbstractMessageReceiver.h @@ -16,7 +16,6 @@ #include "common/messaging/Address.h" #include "common/messaging/IMessageReceiver.h" #include "common/messaging/RTObject.h" -#include namespace etRuntime { @@ -31,12 +30,12 @@ public: } protected: - AbstractMessageReceiver(IRTObject* parent, const std::string& name) : + AbstractMessageReceiver(IRTObject* parent, const String& name) : RTObject(parent, name), m_address(Address::EMPTY) { } - AbstractMessageReceiver(IRTObject* parent, const Address& address, const std::string& name) : + AbstractMessageReceiver(IRTObject* parent, const Address& address, const String& name) : RTObject(parent, name), m_address(address) { } @@ -45,7 +44,7 @@ protected: m_address = address; } - virtual std::string toString() const { + virtual String toString() const { return getName() + " " + m_address.toID(); } diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/Address.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/Address.cpp index 1095d71e5..cc0a66bb1 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/Address.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/Address.cpp @@ -11,7 +11,6 @@ *******************************************************************************/ #include "common/messaging/Address.h" -#include namespace etRuntime { @@ -71,11 +70,11 @@ bool Address::operator<(const Address& right) const { } } -std::string Address::toID() const { +String Address::toID() const { char buffer[50]; sprintf(buffer, "%i_%i_%i", m_nodeID, m_threadID, m_objectID); - return std::string(buffer); + return String(buffer); } Address Address::createInc() const { diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/Address.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/Address.h index e59228d46..0766ccc77 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/Address.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/Address.h @@ -14,7 +14,7 @@ #define ADDRESS_H_ #include "etDatatypes.h" -#include +#include "common/containers/String.h" namespace etRuntime { @@ -33,8 +33,8 @@ public: bool operator!=(const Address& other) const; bool operator< (const Address& right) const; - std::string toString() const; - std::string toID() const; + String toString() const; + String toID() const; Address createInc() const; diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/IRTObject.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/IRTObject.cpp index af6adef7b..00c427bde 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/IRTObject.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/IRTObject.cpp @@ -11,10 +11,9 @@ *******************************************************************************/ #include "common/messaging/IRTObject.h" -#include namespace etRuntime { -const std::string IRTObject::NO_NAME = ""; +const String IRTObject::NO_NAME = ""; } diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/IRTObject.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/IRTObject.h index 4fd02181c..30225ba85 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/IRTObject.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/IRTObject.h @@ -13,8 +13,8 @@ #ifndef IRTOBJECT_H_ #define IRTOBJECT_H_ -#include -#include +#include "common/containers/String.h" +#include "common/containers/Vector.h" namespace etRuntime { @@ -26,23 +26,25 @@ public: static const char PATH_DELIM = '/'; static const char PATHNAME_DELIM = '_'; - static const std::string NO_NAME; + static const String NO_NAME; - virtual const std::string& getName() const = 0; - virtual const std::string& getInstancePath() const = 0; - virtual const std::string& getInstancePathName() const = 0; + typedef Vector ChildList; - virtual std::vector& getChildren() = 0; + virtual const String& getName() const = 0; + virtual String getInstancePath() const = 0; + virtual String getInstancePathName() const = 0; + + virtual ChildList& getChildren() = 0; virtual IRTObject* getParent() const = 0; virtual IRTObject* getRoot() const = 0; - virtual IRTObject* getChild(const std::string& name) const = 0; + virtual IRTObject* getChild(const String& name) const = 0; - virtual IRTObject* getObject(const std::string& path) const = 0; + virtual IRTObject* getObject(const String& path) const = 0; - virtual int getThreadForPath(const std::string& path) const = 0; + virtual int getThreadForPath(const String& path) const = 0; }; } diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/Message.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/Message.cpp index 69705f972..76cb4dbd2 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/Message.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/Message.cpp @@ -11,8 +11,6 @@ *******************************************************************************/ #include "common/messaging/Message.h" -#include -#include #include #include @@ -39,13 +37,20 @@ Message::~Message() { m_dataSize = 0; } -std::string Message::toString() const { - std::stringstream strm; - strm << "Message(" << m_address.toID() << ", evt=" << m_evtId << ")"; +String Message::toString() const { + char buffer[50]; + + String result("Message("); + result += m_address.toID(); + result += ", evt="; + sprintf(buffer, "%d", m_evtId); + result += buffer; + result += ")"; if (m_data) { - strm << std::showbase << std::hex << m_data; + sprintf(buffer, "%p", m_data); + result += buffer; } - return strm.str(); + return result; } } /* namespace etRuntime */ diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/Message.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/Message.h index e4564c41a..95c9350b5 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/Message.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/Message.h @@ -15,9 +15,7 @@ #include "common/messaging/Address.h" #include "stddef.h" -#include -#include -#include +#include "common/containers/String.h" namespace etRuntime { @@ -43,7 +41,7 @@ public: return m_data; } - std::string toString() const; + String toString() const; protected: friend class MessageSeQueue; diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageDispatcher.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageDispatcher.cpp index f5250be98..4374c5079 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageDispatcher.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageDispatcher.cpp @@ -16,7 +16,7 @@ namespace etRuntime { -MessageDispatcher::MessageDispatcher(IRTObject* parent, const Address& addr, const std::string& name) : +MessageDispatcher::MessageDispatcher(IRTObject* parent, const Address& addr, const String& name) : RTObject(parent, name), m_local_map(), m_freeAdresses(), @@ -29,15 +29,16 @@ MessageDispatcher::MessageDispatcher(IRTObject* parent, const Address& addr, con Address MessageDispatcher::getFreeAddress() { if (m_freeAdresses.empty()) { return Address(getAddress().m_nodeID, getAddress().m_threadID, m_nextFreeObjId++); - } else { - Address address = m_freeAdresses.front(); - m_freeAdresses.pop(); + } + else { + Address address = m_freeAdresses.back(); + m_freeAdresses.pop_back(); return address; } } void MessageDispatcher::freeAddress(const Address& addr) { - m_freeAdresses.push(addr); + m_freeAdresses.push_back(addr); } void MessageDispatcher::addMessageReceiver(IMessageReceiver& receiver) { if (!receiver.getAddress().isValid()) @@ -69,14 +70,13 @@ void MessageDispatcher::receive(const Message* msg) { IMessageReceiver* receiver = 0; if (msg->getAddress().m_nodeID == m_address.m_nodeID && msg->getAddress().m_threadID == m_address.m_threadID) { - std::map::iterator it; - it = m_local_map.find(msg->getAddress().m_objectID); + Map::iterator it = m_local_map.find(msg->getAddress().m_objectID); if (it != m_local_map.end()) { receiver = it->second; } } if (receiver == this) { - for (std::set::iterator it = m_pollingMessageReceiver.begin(); + for (Set::iterator it = m_pollingMessageReceiver.begin(); it != m_pollingMessageReceiver.end(); ++it) { (*it)->receive(msg); } @@ -89,8 +89,8 @@ void MessageDispatcher::receive(const Message* msg) { dynamic_cast(getParent())->returnMessageBuffer(msg); } -std::string MessageDispatcher::toString() const { - return getName() + " " + getAddress().toID(); +String MessageDispatcher::toString() const { + return getName() + " " + getAddress().toID().c_str(); } } /* namespace etRuntime */ diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageDispatcher.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageDispatcher.h index 359acff43..0e2d6a9f8 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageDispatcher.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageDispatcher.h @@ -13,13 +13,12 @@ #ifndef MESSAGEDISPATCHER_H_ #define MESSAGEDISPATCHER_H_ +#include "common/containers/Vector.h" +#include "common/containers/Set.h" +#include "common/containers/Map.h" #include "common/messaging/Address.h" #include "common/messaging/IMessageReceiver.h" #include "common/messaging/RTObject.h" -#include -#include -#include -#include @@ -27,7 +26,7 @@ namespace etRuntime { class MessageDispatcher : public RTObject, public virtual IMessageReceiver { public: - MessageDispatcher(IRTObject* parent, const Address& addr, const std::string& name); + MessageDispatcher(IRTObject* parent, const Address& addr, const String& name); virtual ~MessageDispatcher() {} Address getFreeAddress(); @@ -41,12 +40,12 @@ class MessageDispatcher : public RTObject, public virtual IMessageReceiver { const Address& getAddress() const { return m_address; }; protected: - std::string toString() const; + String toString() const; private: - std::map m_local_map; - std::queue
m_freeAdresses; - std::set m_pollingMessageReceiver; + Map m_local_map; + Vector
m_freeAdresses; + Set m_pollingMessageReceiver; Address m_address; int m_nextFreeObjId; diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageSeQueue.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageSeQueue.cpp index 05acc694d..70bb49da5 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageSeQueue.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageSeQueue.cpp @@ -14,7 +14,7 @@ namespace etRuntime { -MessageSeQueue::MessageSeQueue(IRTObject* parent, const std::string& name) +MessageSeQueue::MessageSeQueue(IRTObject* parent, const String& name) : RTObject(parent, name), m_first(0), m_last(0), diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageSeQueue.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageSeQueue.h index e2b42e67f..f19023308 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageSeQueue.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageSeQueue.h @@ -16,13 +16,12 @@ #include "common/messaging/RTObject.h" #include "common/messaging/Message.h" #include "etDatatypes.h" -#include namespace etRuntime { class MessageSeQueue: public RTObject { public: - MessageSeQueue(IRTObject* parent, const std::string& name); + MessageSeQueue(IRTObject* parent, const String& name); virtual ~MessageSeQueue(); void push(Message* msg); diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageService.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageService.cpp index 62d62d66f..4b4e13fba 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageService.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageService.cpp @@ -15,12 +15,12 @@ #include "common/messaging/MessageServiceController.h" #include "common/messaging/RTServices.h" #include "osal/etTime.h" -#include +#include namespace etRuntime { -MessageService::MessageService(IRTObject* parent, IMessageService::ExecMode mode, int node, int thread, const std::string& name, +MessageService::MessageService(IRTObject* parent, IMessageService::ExecMode mode, int node, int thread, const String& name, IMessageMemory* memory, int priority) : RTObject(parent, name), m_running(false), @@ -38,7 +38,7 @@ MessageService::MessageService(IRTObject* parent, IMessageService::ExecMode mode } MessageService::MessageService(IRTObject* parent, IMessageService::ExecMode mode, etTime interval, int node, int thread, - const std::string& name, IMessageMemory* memory, int priority) : + const String& name, IMessageMemory* memory, int priority) : RTObject(parent, name), m_running(false), m_execMode(mode), @@ -173,8 +173,8 @@ void MessageService::returnMessageBuffer(const Message* buffer) { etMutex_leave(&m_mutex); } -std::string MessageService::toString() const { - return getName() + " " + getAddress().toID(); +String MessageService::toString() const { + return getName() + " " + getAddress().toID().c_str(); } void MessageService::terminate() { diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageService.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageService.h index 388226079..6afd3524c 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageService.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageService.h @@ -23,7 +23,6 @@ #include "osal/etSema.h" #include "osal/etThread.h" #include "osal/etTimer.h" -#include namespace etRuntime { @@ -35,8 +34,8 @@ public: POLLED, BLOCKED, MIXED }; - MessageService(IRTObject* parent, IMessageService::ExecMode mode, int node, int thread, const std::string& name, IMessageMemory* memory, int priority = 0); - MessageService(IRTObject* parent, IMessageService::ExecMode mode, etTime interval, int node, int thread, const std::string& name, IMessageMemory* memory, int priority = 0); + MessageService(IRTObject* parent, IMessageService::ExecMode mode, int node, int thread, const String& name, IMessageMemory* memory, int priority = 0); + MessageService(IRTObject* parent, IMessageService::ExecMode mode, etTime interval, int node, int thread, const String& name, IMessageMemory* memory, int priority = 0); virtual ~MessageService(); void run(); @@ -59,7 +58,7 @@ public: void returnMessageBuffer(const Message* buffer); const Address& getAddress(void) const { return m_address; } - std::string toString() const; + String toString() const; protected: diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageServiceController.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageServiceController.cpp index 7ac21eb4e..a5697e2ae 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageServiceController.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageServiceController.cpp @@ -10,12 +10,22 @@ * *******************************************************************************/ -#include - #include "MessageServiceController.h" +#include "common/containers/String.h" namespace etRuntime { +typedef Vector::iterator iterator; +static iterator find(iterator begin, iterator end, const IMessageService* value) { + iterator current = begin; + for (; current!=end; ++current) { + if (*current==value) { + return current; + } + } + return current; +} + MessageServiceController::MessageServiceController() : m_messageServices(), m_freeIDs(), @@ -33,7 +43,7 @@ int MessageServiceController::getNewID() { newID = m_nextFreeID++; else { newID = m_freeIDs.back(); - m_freeIDs.pop(); + m_freeIDs.pop_back(); } etMutex_leave(&m_mutex); @@ -42,7 +52,7 @@ int MessageServiceController::getNewID() { void MessageServiceController::freeID(int id) { etMutex_enter(&m_mutex); - m_freeIDs.push(id); + m_freeIDs.push_back(id); etMutex_leave(&m_mutex); } @@ -58,7 +68,7 @@ void MessageServiceController::addMsgSvc(IMessageService& msgSvc) { void MessageServiceController::removeMsgSvc(IMessageService& msgSvc) { etMutex_enter(&m_mutex); - MsgSvcList::iterator it = std::find(m_messageServices.begin(), m_messageServices.end(), &msgSvc); + MsgSvcList::iterator it = find(m_messageServices.begin(), m_messageServices.end(), &msgSvc); if (it!=m_messageServices.end()) { m_messageServices.erase(it); } @@ -98,7 +108,7 @@ void MessageServiceController::stop() { m_running = false; } -void MessageServiceController::dumpThreads(std::string msg) { +void MessageServiceController::dumpThreads(String msg) { // std::cout << "<<< begin dump threads <<<" << std::endl; // std::cout << "=== " << msg << std::endl; //TODO dump stack traces @@ -146,7 +156,7 @@ void MessageServiceController::resetAll() { etMutex_enter(&m_mutex); m_messageServices.clear(); while (!m_freeIDs.empty()) { - m_freeIDs.pop(); + m_freeIDs.pop_back(); } m_nextFreeID = 0; etMutex_leave(&m_mutex); @@ -154,7 +164,7 @@ void MessageServiceController::resetAll() { void MessageServiceController::setMsgSvcTerminated(const IMessageService& msgSvc){ etMutex_enter(&m_mutex); - MsgSvcList::iterator it = std::find(m_terminateServices.begin(), m_terminateServices.end(), &msgSvc); + MsgSvcList::iterator it = find(m_terminateServices.begin(), m_terminateServices.end(), &msgSvc); if (it!=m_terminateServices.end()) { m_terminateServices.erase(it); } diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageServiceController.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageServiceController.h index c9bc85aed..bd15af6f5 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageServiceController.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/MessageServiceController.h @@ -14,11 +14,9 @@ #define MESSAGESERVICECONTROLLER_H_ #include "common/messaging/IMessageService.h" +#include "common/containers/Vector.h" #include "osal/etMutex.h" #include "osal/etSema.h" -#include -#include -#include namespace etRuntime { @@ -45,15 +43,15 @@ public: void setMsgSvcTerminated(const IMessageService& msgSvc); protected: - void dumpThreads(std::string msg); + void dumpThreads(String msg); private: void terminate(); - typedef std::vector MsgSvcList; + typedef Vector MsgSvcList; MsgSvcList m_messageServices; - std::queue m_freeIDs; + Vector m_freeIDs; etBool m_running; int m_nextFreeID; diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/RTObject.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/RTObject.cpp index 6c3182ecc..4a4692c67 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/RTObject.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/RTObject.cpp @@ -12,29 +12,31 @@ #include "common/messaging/RTObject.h" #include "etDatatypes.h" -#include -#include -#include namespace etRuntime { -RTObject::RTObject(IRTObject* parent, const std::string& name) : +RTObject::RTObject(IRTObject* parent, const String& name) : m_name(name), m_parent(parent), m_children() { if (m_parent != 0) { m_parent->getChildren().push_back(this); +#ifdef RTOBJECT_STORES_PATHS m_instancePath = m_parent->getInstancePath() + PATH_DELIM + m_name; m_instancePathName = m_parent->getInstancePathName() + PATHNAME_DELIM + m_name; - } else { +#endif + } +#ifdef RTOBJECT_STORES_PATHS + else { m_instancePath = PATH_DELIM + m_name; m_instancePathName = PATHNAME_DELIM + m_name; } +#endif } void RTObject::destroy() { - for (std::vector::iterator it = m_children.begin(); it != m_children.end(); ++it) { + for (ChildList::iterator it = m_children.begin(); it != m_children.end(); ++it) { RTObject* child = dynamic_cast(*it); if (child != 0) { child->destroy(); @@ -53,8 +55,8 @@ IRTObject* RTObject::getRoot() const { return root; } -IRTObject* RTObject::getChild(const std::string& name) const { - for (std::vector::const_iterator it = m_children.begin(); it != m_children.end(); ++it) { +IRTObject* RTObject::getChild(const String& name) const { + for (ChildList::const_iterator it = m_children.begin(); it != m_children.end(); ++it) { if (name == ((*it)->getName())) { return *it; } @@ -63,17 +65,17 @@ IRTObject* RTObject::getChild(const std::string& name) const { return 0; } -IRTObject* RTObject::getObject(const std::string& path) const { +IRTObject* RTObject::getObject(const String& path) const { etBool isAbsolute = (path[0] == PATH_DELIM); if (isAbsolute && getParent() != 0) return getParent()->getObject(path); - std::string segment; + String segment; std::size_t last = 0; if (isAbsolute) { last = 1; size_t first = path.find(PATH_DELIM, last); - segment = path.substr(last, (first == std::string::npos) ? std::string::npos : first - 1); + segment = path.substr(last, (first == String::npos) ? String::npos : first - 1); if (segment != m_name) return 0; @@ -82,7 +84,7 @@ IRTObject* RTObject::getObject(const std::string& path) const { IRTObject* current = const_cast(this); std::size_t next; - while ((next = path.find(PATH_DELIM, last)) != std::string::npos) { + while ((next = path.find(PATH_DELIM, last)) != String::npos) { if (next > last + 1) { segment = path.substr(last, next - last); current = current->getChild(segment); @@ -99,18 +101,18 @@ IRTObject* RTObject::getObject(const std::string& path) const { return current; } -int RTObject::getThreadForPath(const std::string& path) const { +int RTObject::getThreadForPath(const String& path) const { if (m_parent != 0) return m_parent->getThreadForPath(path); return -1; } -std::string RTObject::toStringRecursive(const std::string& indent) const { - std::string result(indent + toString() + "\n"); +String RTObject::toStringRecursive(const String& indent) const { + String result(indent + toString() + "\n"); - std::string indentInc(" " + indent); - std::vector::const_iterator it = m_children.begin(); + String indentInc(" " + indent); + ChildList::const_iterator it = m_children.begin(); for (; it != m_children.end(); ++it) { RTObject* child = dynamic_cast(*it); if (child != 0) @@ -120,11 +122,31 @@ std::string RTObject::toStringRecursive(const std::string& indent) const { return result; } -std::string RTObject::toStringRecursive() const { +#ifndef RTOBJECT_STORES_PATHS +String RTObject::getInstancePath() const { + if (m_parent != 0) { + return m_parent->getInstancePath() + PATH_DELIM + m_name; + } + else { + return PATH_DELIM + m_name; + } +} + +String RTObject::getInstancePathName() const { + if (m_parent != 0) { + return m_parent->getInstancePathName() + PATHNAME_DELIM + m_name; + } + else { + return PATHNAME_DELIM + m_name; + } +} +#endif + +String RTObject::toStringRecursive() const { return toStringRecursive(""); } -std::string RTObject::toString() const { +String RTObject::toString() const { return getName(); } diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/RTObject.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/RTObject.h index ceb2b6c93..5de8f1344 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/RTObject.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/RTObject.h @@ -14,28 +14,22 @@ #define RTOBJECT_H_ #include "common/messaging/IRTObject.h" -#include -#include namespace etRuntime { class RTObject: public virtual IRTObject { public: - RTObject(IRTObject* parent, const std::string& name); + RTObject(IRTObject* parent, const String& name); virtual ~RTObject() {} - virtual const std::string& getName() const { + virtual const String& getName() const { return m_name; } - virtual const std::string& getInstancePath() const { - return m_instancePath; - } - virtual const std::string& getInstancePathName() const { - return m_instancePathName; - } + virtual String getInstancePath() const; + virtual String getInstancePathName() const; - virtual std::vector& getChildren() { + virtual ChildList& getChildren() { return m_children; } @@ -45,33 +39,47 @@ public: virtual IRTObject* getRoot() const; - virtual IRTObject* getChild(const std::string& name) const; + virtual IRTObject* getChild(const String& name) const; - virtual IRTObject* getObject(const std::string& path) const; + virtual IRTObject* getObject(const String& path) const; - virtual int getThreadForPath(const std::string& path) const; + virtual int getThreadForPath(const String& path) const; protected: virtual void destroy(); - std::string toStringRecursive(const std::string& indent) const; - std::string toStringRecursive() const; - virtual std::string toString() const; + String toStringRecursive(const String& indent) const; + String toStringRecursive() const; + virtual String toString() const; private: - std::string m_name; - // for speed optimization the instance paths are created at instantiation - // and used as const ref parameters in the logging methods to avoid copying - std::string m_instancePath; - std::string m_instancePathName; + String m_name; IRTObject* m_parent; - std::vector m_children; - + ChildList m_children; +#ifdef RTOBJECT_STORES_PATHS + // for speed optimization the instance paths are created at instantiation + // TODO: if not RTOBJECT_STORES_PATHS we need to return a copy + // in the other case it would be more efficient to return const refs. + // Can this be resolved in some way? + String m_instancePath; + String m_instancePathName; +#endif + + // unimplemented RTObject(); RTObject(RTObject const&); RTObject& operator=(RTObject const&); }; +#ifdef RTOBJECT_STORES_PATHS +inline const String& RTObject::getInstancePath() const { + return m_instancePath; +} +inline const String& RTObject::getInstancePathName() const { + return m_instancePathName; +} +#endif + } /* namespace etRuntime */ #endif /* RTOBJECT_H_ */ diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/StaticMessageMemory.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/StaticMessageMemory.cpp index d88f10b86..c92b01d90 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/StaticMessageMemory.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/StaticMessageMemory.cpp @@ -11,10 +11,11 @@ *******************************************************************************/ #include "common/messaging/StaticMessageMemory.h" +#include namespace etRuntime { -StaticMessageMemory::StaticMessageMemory(IRTObject* parent, const std::string& name, size_t size, int number) : +StaticMessageMemory::StaticMessageMemory(IRTObject* parent, const String& name, size_t size, int number) : RTObject(parent, name), m_size(size), m_msgPool(NULL, "memory"), m_buffer(0) { m_buffer = new uint8_t[m_size * number]; uint8_t* ptr = m_buffer; @@ -31,10 +32,10 @@ StaticMessageMemory::~StaticMessageMemory() { Message* StaticMessageMemory::getMessageBuffer(size_t size) { if(size > m_size) { - std::cout << "Could not provide message buffer (message too big)!" << std::endl; + printf("Could not provide message buffer (message too big)!\n"); } else if(m_msgPool.getSize() <= 0) { - std::cout << "Could not provide message buffer (message pool is empty)!" << std::endl; + printf("Could not provide message buffer (message pool is empty)!\n"); } else { return const_cast(m_msgPool.pop()); diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/StaticMessageMemory.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/StaticMessageMemory.h index 56b5eabb1..b2df0adcc 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/StaticMessageMemory.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/messaging/StaticMessageMemory.h @@ -21,7 +21,7 @@ namespace etRuntime { class StaticMessageMemory : public IMessageMemory, public RTObject { public: - StaticMessageMemory(IRTObject* parent, const std::string& name, size_t size, int number); + StaticMessageMemory(IRTObject* parent, const String& name, size_t size, int number); virtual ~StaticMessageMemory(); // returns a buffer of the specified size in bytes diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ActorClassBase.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ActorClassBase.cpp index 5f67b8ac5..4884bac09 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ActorClassBase.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ActorClassBase.cpp @@ -15,14 +15,11 @@ #include "common/modelbase/RTSystemServicesProtocol.h" #include "common/modelbase/SystemPortOwner.h" #include "etDatatypes.h" -#include -#include -#include namespace etRuntime { -ActorClassBase::ActorClassBase(IRTObject* parent, const std::string& name) : +ActorClassBase::ActorClassBase(IRTObject* parent, const String& name) : SystemPortOwner(parent, name), m_state(0), m_RTSystemPort(this, IFITEM_RTSystemPort), @@ -51,7 +48,7 @@ void ActorClassBase::initialize() { //--------------------- life cycle functions void ActorClassBase::init() { ActorClassBase* child = 0; - for (std::vector::iterator it = getChildren().begin(); it != getChildren().end(); ++it) { + for (ChildList::iterator it = getChildren().begin(); it != getChildren().end(); ++it) { if ((child = dynamic_cast(*it)) != 0) child->init(); } @@ -61,7 +58,7 @@ void ActorClassBase::init() { void ActorClassBase::start() { ActorClassBase* child = 0; - for (std::vector::iterator it = getChildren().begin(); it != getChildren().end(); ++it) { + for (ChildList::iterator it = getChildren().begin(); it != getChildren().end(); ++it) { if ((child = dynamic_cast(*it)) != 0) child->start(); } @@ -73,7 +70,7 @@ void ActorClassBase::stop() { stopUser(); ActorClassBase* child = 0; - for (std::vector::iterator it = getChildren().begin(); it != getChildren().end(); ++it) { + for (ChildList::iterator it = getChildren().begin(); it != getChildren().end(); ++it) { if ((child = dynamic_cast(*it)) != 0) child->stop(); } @@ -102,7 +99,7 @@ etBool ActorClassBase::handleSystemEvent(InterfaceItemBase* ifitem, int evt, voi return true; } -std::string ActorClassBase::toString() const { +String ActorClassBase::toString() const { ActorClassBase* thisPtr = const_cast(this); char buffer[10]; sprintf(buffer, "%i", thisPtr->getThread()); diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ActorClassBase.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ActorClassBase.h index 52d876b17..9c4ca8485 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ActorClassBase.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ActorClassBase.h @@ -18,7 +18,6 @@ #include "common/modelbase/RTSystemProtocol.h" #include "common/modelbase/SystemPortOwner.h" #include "etDatatypes.h" -#include namespace etRuntime { @@ -28,11 +27,11 @@ public: virtual ~ActorClassBase(); - const std::string& getClassName() const { + const String& getClassName() const { return m_className; } - void setClassName(const std::string& className) { + void setClassName(const String& className) { m_className = className; } @@ -72,7 +71,7 @@ public: protected: - ActorClassBase(IRTObject* parent, const std::string&); + ActorClassBase(IRTObject* parent, const String& name); static const int EVT_SHIFT = 1000; // TODOHRR: use 256 or shift operation later static const int NO_STATE = 0; @@ -88,9 +87,9 @@ protected: RTSystemPort m_RTSystemPort; virtual etBool handleSystemEvent(InterfaceItemBase* ifitem, int evt, void* generic_data); - std::string toString() const; + String toString() const; private: - std::string m_className; + String m_className; ActorClassBase(); ActorClassBase(ActorClassBase const&); diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/DataPort.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/DataPort.cpp index 5726012ac..42d6f3dec 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/DataPort.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/DataPort.cpp @@ -11,11 +11,10 @@ *******************************************************************************/ #include "common/modelbase/DataPort.h" -#include namespace etRuntime { -void DataPortBase::connect(IRTObject* obj, const std::string& path1, const std::string& path2) { +void DataPortBase::connect(IRTObject* obj, const String& path1, const String& path2) { IRTObject* obj1 = obj->getObject(path1); IRTObject* obj2 = obj->getObject(path2); diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/DataPort.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/DataPort.h index eac2b6b21..1cb3de715 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/DataPort.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/DataPort.h @@ -13,15 +13,14 @@ #define SRC_COMMON_MODELBASE_DATAPORT_H_ #include "common/messaging/RTObject.h" -#include namespace etRuntime { class DataPortBase: public RTObject { public: - static void connect(IRTObject* obj, const std::string& path1, const std::string& path2); + static void connect(IRTObject* obj, const String& path1, const String& path2); - DataPortBase(IRTObject* parent, const std::string& name, int localId) : + DataPortBase(IRTObject* parent, const String& name, int localId) : RTObject(parent, name), m_localId(localId) { } @@ -40,7 +39,7 @@ private: class DataSendPort: public DataPortBase { public: - DataSendPort(IRTObject* parent, const std::string& name, int localId) : + DataSendPort(IRTObject* parent, const String& name, int localId) : DataPortBase(parent, name, localId) { } @@ -53,7 +52,7 @@ private: class DataReceivePort: public DataPortBase { friend class DataPortBase; public: - DataReceivePort(IRTObject* parent, const std::string& name, int localId) : + DataReceivePort(IRTObject* parent, const String& name, int localId) : DataPortBase(parent, name, localId) { } diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/EventReceiver.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/EventReceiver.cpp index 9ca651026..4c6829b44 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/EventReceiver.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/EventReceiver.cpp @@ -11,11 +11,10 @@ *******************************************************************************/ #include "common/modelbase/EventReceiver.h" -#include namespace etRuntime { -EventReceiver::EventReceiver(IRTObject* parent, const std::string& name) : +EventReceiver::EventReceiver(IRTObject* parent, const String& name) : RTObject(parent, name), m_thread(-1) { } diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/EventReceiver.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/EventReceiver.h index e67df44b9..cfdb7c230 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/EventReceiver.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/EventReceiver.h @@ -15,7 +15,6 @@ #include "common/messaging/RTObject.h" #include "common/modelbase/IEventReceiver.h" -#include namespace etRuntime { @@ -27,7 +26,7 @@ public: virtual int getThread(); protected: - EventReceiver(IRTObject* parent, const std::string& name); + EventReceiver(IRTObject* parent, const String& name); private: diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/InterfaceItemBase.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/InterfaceItemBase.cpp index 498137c69..0e45bc4de 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/InterfaceItemBase.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/InterfaceItemBase.cpp @@ -17,11 +17,10 @@ #include "common/modelbase/IInterfaceItemOwner.h" #include "common/modelbase/InterfaceItemBase.h" #include "common/modelbase/IReplicatedInterfaceItem.h" -#include namespace etRuntime { -void InterfaceItemBase::connect(IRTObject* obj, const std::string& path1, const std::string& path2) { +void InterfaceItemBase::connect(IRTObject* obj, const String& path1, const String& path2) { IRTObject* obj1 = obj->getObject(path1); IRTObject* obj2 = obj->getObject(path2); @@ -33,7 +32,7 @@ void InterfaceItemBase::connect(IRTObject* obj, const std::string& path1, const } } -InterfaceItemBase::InterfaceItemBase(IInterfaceItemOwner* owner, const std::string& name, int localId, int idx) : +InterfaceItemBase::InterfaceItemBase(IInterfaceItemOwner* owner, const String& name, int localId, int idx) : AbstractMessageReceiver(owner->getEventReceiver(), name), m_localId(localId), m_idx(idx), @@ -135,20 +134,19 @@ void InterfaceItemBase::destroy() { AbstractMessageReceiver::destroy(); } -std::string InterfaceItemBase::toString() const { - std::stringstream result; - - result << ((m_replicator != 0) ? "sub " : ""); - result << "port " + getName() << " " << getAddress().toID() << " "; - if(m_peerMsgReceiver == 0) - result << "UNCONNECTED"; +String InterfaceItemBase::toString() const { + char buffer [256]; + const char* sub = (m_replicator != 0) ? "sub " : ""; + int pos = sprintf(buffer, "%sport %s %s ", sub, getName().c_str(), getAddress().toID().c_str()); + if (m_peerMsgReceiver == 0) { + sprintf(buffer+pos, "UNCONNECTED"); + } else { - result << " -> "; - result << ((m_peer != 0) ? m_peer->getName() : "?"); - result << " " << m_peerAddress.toID(); + const char* peerName = (m_peer != 0) ? m_peer->getName().c_str() : "?"; + sprintf(buffer + pos, " -> %s %s", peerName, m_peerAddress.toID().c_str()); } - return result.str(); + return buffer; } } /* namespace etRuntime */ diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/InterfaceItemBase.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/InterfaceItemBase.h index cdb12d99d..004cb129d 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/InterfaceItemBase.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/InterfaceItemBase.h @@ -17,7 +17,6 @@ #include "common/messaging/Address.h" #include "common/messaging/IMessageService.h" #include "common/modelbase/IInterfaceItem.h" -#include namespace etRuntime { @@ -28,7 +27,7 @@ class IMessageService; class InterfaceItemBase: public AbstractMessageReceiver, public virtual IInterfaceItem { public: - static void connect(IRTObject* obj, const std::string& path1, const std::string& path2); + static void connect(IRTObject* obj, const String& path1, const String& path2); virtual ~InterfaceItemBase(); @@ -45,9 +44,9 @@ public: IEventReceiver* getActor() const; - virtual std::string toString() const; + virtual String toString() const; protected: - InterfaceItemBase(IInterfaceItemOwner* owner, const std::string& name, int localId, int idx); + InterfaceItemBase(IInterfaceItemOwner* owner, const String& name, int localId, int idx); IMessageReceiver* getMsgReceiver() const { return m_ownMsgReceiver; diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/PortBase.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/PortBase.h index 9fbb2c1be..8be912354 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/PortBase.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/PortBase.h @@ -15,7 +15,6 @@ #include "common/modelbase/IInterfaceItemOwner.h" #include "common/modelbase/InterfaceItemBase.h" -#include namespace etRuntime { @@ -25,11 +24,11 @@ public: virtual ~PortBase() {} protected: - PortBase(IInterfaceItemOwner* owner, const std::string& name, int localId) : + PortBase(IInterfaceItemOwner* owner, const String& name, int localId) : InterfaceItemBase(owner, name, localId, 0) { } - PortBase(IInterfaceItemOwner* owner, const std::string& name, int localId, int idx) : + PortBase(IInterfaceItemOwner* owner, const String& name, int localId, int idx) : InterfaceItemBase(owner, name, localId, idx) { } diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/RTSystem.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/RTSystem.h index 4dbae420c..afee89e71 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/RTSystem.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/RTSystem.h @@ -13,14 +13,14 @@ #define SRC_COMMON_MODELBASE_RTSYSTEM_H_ #include "common/messaging/RTObject.h" -#include +#include "common/containers/String.h" namespace etRuntime { class RTSystem: public RTObject { public: - explicit RTSystem(std::string name) : + explicit RTSystem(String name) : RTObject(0, name) { } virtual ~RTSystem() {} diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/RTSystemProtocol.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/RTSystemProtocol.cpp index 9a9f930b0..eaf8ec682 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/RTSystemProtocol.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/RTSystemProtocol.cpp @@ -12,26 +12,25 @@ #include "common/modelbase/IEventReceiver.h" #include "common/modelbase/RTSystemProtocol.h" -#include namespace etRuntime { -const std::string RTSystemProtocol::RT_SYSTEM_PORT_NAME = "RTSystemPort"; +const String RTSystemProtocol::RT_SYSTEM_PORT_NAME = "RTSystemPort"; RTSystemPort::RTSystemPort(IInterfaceItemOwner* actor, int localId) : - RTSystemServicesProtocolPort(actor, RTSystemProtocol::RT_SYSTEM_PORT_NAME, localId) { + RTSystemServicesProtocolPort(actor, RTSystemProtocol::RT_SYSTEM_PORT_NAME.c_str(), localId) { } RTSystemConjPort::RTSystemConjPort(IInterfaceItemOwner* actor, int localId) : - RTSystemServicesProtocolConjReplPort(actor, RTSystemProtocol::RT_SYSTEM_PORT_NAME, localId) { + RTSystemServicesProtocolConjReplPort(actor, RTSystemProtocol::RT_SYSTEM_PORT_NAME.c_str(), localId) { } -InterfaceItemBase* RTSystemConjPort::createInterfaceItem(IInterfaceItemOwner* rcv, const std::string& name, int lid, int idx) { +InterfaceItemBase* RTSystemConjPort::createInterfaceItem(IInterfaceItemOwner* rcv, const String& name, int lid, int idx) { return new RTSystemConjSubPort(rcv, name, lid, idx); } -RTSystemConjSubPort::RTSystemConjSubPort(IInterfaceItemOwner* actor, const std::string& name, int localId, int idx) : - RTSystemServicesProtocolConjPort(actor, name, localId, idx) { +RTSystemConjSubPort::RTSystemConjSubPort(IInterfaceItemOwner* actor, const String& name, int localId, int idx) : + RTSystemServicesProtocolConjPort(actor, name.c_str(), localId, idx) { } } // namespace etRuntime diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/RTSystemProtocol.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/RTSystemProtocol.h index 61f0b8665..0536d2102 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/RTSystemProtocol.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/RTSystemProtocol.h @@ -9,13 +9,12 @@ #define SRC_COMMON_MESSAGING_RTSYSTEMPROTOCOL_H_ #include "common/modelbase/RTSystemServicesProtocol.h" -#include namespace etRuntime { class RTSystemProtocol { public: - static const std::string RT_SYSTEM_PORT_NAME; + static const String RT_SYSTEM_PORT_NAME; }; @@ -37,7 +36,7 @@ public: virtual ~RTSystemConjPort() {} protected: - virtual InterfaceItemBase* createInterfaceItem(IInterfaceItemOwner* rcv, const std::string& name, int lid, int idx); + virtual InterfaceItemBase* createInterfaceItem(IInterfaceItemOwner* rcv, const String& name, int lid, int idx); private: RTSystemConjPort(); @@ -47,7 +46,7 @@ private: class RTSystemConjSubPort: public RTSystemServicesProtocolConjPort { public: - RTSystemConjSubPort(IInterfaceItemOwner* actor, const std::string& name, int localId, int idx); + RTSystemConjSubPort(IInterfaceItemOwner* actor, const String& name, int localId, int idx); virtual ~RTSystemConjSubPort() {} private: diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ReplicatedActorClassBase.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ReplicatedActorClassBase.cpp index fc9747cc0..923a327eb 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ReplicatedActorClassBase.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ReplicatedActorClassBase.cpp @@ -14,33 +14,35 @@ namespace etRuntime { -ReplicatedActorClassBase::ReplicatedActorClassBase(IRTObject* parent, const std::string& name) : +ReplicatedActorClassBase::ReplicatedActorClassBase(IRTObject* parent, const String& name) : RTObject(parent, name), m_items() { } ReplicatedActorClassBase::~ReplicatedActorClassBase() { - for(std::vector::iterator it = m_items.begin(); it != m_items.end(); ++it) { + for(Vector::iterator it = m_items.begin(); it != m_items.end(); ++it) { delete *it; } } void ReplicatedActorClassBase::createSubActors(int number) { + m_items.reserve(m_items.size() + number); + for (int i = 0; i < number; i++) { - std::stringstream itemName; - itemName << getName() << SEP << i; - ActorClassBase* item = createActor(getParent(), itemName.str()); + char buffer[64]; + sprintf(buffer, "%s%c%d", getName().c_str(), SEP, i); + ActorClassBase* item = createActor(getParent(), buffer); m_items.push_back(item); } } void ReplicatedActorClassBase::initialize() { - for(std::vector::iterator it = m_items.begin(); it != m_items.end(); ++it) { + for(Vector::iterator it = m_items.begin(); it != m_items.end(); ++it) { (*it)->initialize(); } } void ReplicatedActorClassBase::setProbesActive(bool recursive, bool active) { - for(std::vector::iterator it = m_items.begin(); it != m_items.end(); ++it) + for(Vector::iterator it = m_items.begin(); it != m_items.end(); ++it) (*it)->setProbesActive(recursive, active); } diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ReplicatedActorClassBase.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ReplicatedActorClassBase.h index 6a1eba38d..b4eb3b0bf 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ReplicatedActorClassBase.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ReplicatedActorClassBase.h @@ -15,6 +15,8 @@ #include "common/messaging/RTObject.h" #include "common/modelbase/ActorClassBase.h" +#include "common/containers/String.h" +#include "common/containers/Vector.h" namespace etRuntime { @@ -23,19 +25,19 @@ class ReplicatedActorClassBase : public RTObject { public: static const char SEP = ':'; - ReplicatedActorClassBase(IRTObject* parent, const std::string& name); + ReplicatedActorClassBase(IRTObject* parent, const String& name); virtual ~ReplicatedActorClassBase(void); void createSubActors(int number); void initialize(void); void setProbesActive(bool recursive, bool active); int getNSubActors(void) { return m_items.size(); } - ActorClassBase* getSubActor(int index) { return m_items.at(index); } + ActorClassBase* getSubActor(int index) { return m_items[index]; } protected: - virtual ActorClassBase* createActor(IRTObject* parent, const std::string& name) = 0; + virtual ActorClassBase* createActor(IRTObject* parent, const String& name) = 0; private: - std::vector m_items; + Vector m_items; }; } // namespace et Runtime diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ReplicatedInterfaceItemBase.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ReplicatedInterfaceItemBase.cpp index 6e5b536d2..c89d87137 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ReplicatedInterfaceItemBase.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ReplicatedInterfaceItemBase.cpp @@ -13,14 +13,10 @@ #include "common/messaging/RTObject.h" #include "common/modelbase/IEventReceiver.h" #include "common/modelbase/ReplicatedInterfaceItemBase.h" -#include -#include -#include -#include namespace etRuntime { -ReplicatedInterfaceItemBase::ReplicatedInterfaceItemBase(IInterfaceItemOwner* owner, const std::string& name, int localId) : +ReplicatedInterfaceItemBase::ReplicatedInterfaceItemBase(IInterfaceItemOwner* owner, const String& name, int localId) : RTObject(owner, name), m_localId(localId), m_items(), @@ -28,29 +24,29 @@ ReplicatedInterfaceItemBase::ReplicatedInterfaceItemBase(IInterfaceItemOwner* ow } ReplicatedInterfaceItemBase::~ReplicatedInterfaceItemBase() { - for(std::vector::iterator it = m_items.begin(); it != m_items.end(); ++it) { + for(Vector::iterator it = m_items.begin(); it != m_items.end(); ++it) { delete *it; } } InterfaceItemBase* ReplicatedInterfaceItemBase::createSubInterfaceItem() { int newIndex = getFreeIndex(); - std::stringstream itemName; - itemName << getName() << SEP << newIndex; + char buffer[64]; + sprintf(buffer, "%s%c%d", getName().c_str(), SEP, newIndex); - InterfaceItemBase* item = createInterfaceItem(this, itemName.str(), m_localId, newIndex); + InterfaceItemBase* item = createInterfaceItem(this, buffer, m_localId, newIndex); m_items.push_back(item); return item; } void ReplicatedInterfaceItemBase::removeItem(InterfaceItemBase& item) { - std::vector::iterator it = m_items.begin(); + Vector::iterator it = m_items.begin(); while (it != m_items.end() && *it != &item) { ++it; } if (it != m_items.end()) { m_items.erase(it); - m_releasedIndices.push(item.getIdx()); + m_releasedIndices.push_back(item.getIdx()); } } @@ -59,14 +55,14 @@ int ReplicatedInterfaceItemBase::getFreeIndex() { return m_items.size(); else { int idx = m_releasedIndices.front(); - m_releasedIndices.pop(); + m_releasedIndices.pop_back(); return idx; } } InterfaceItemBase* ReplicatedInterfaceItemBase::getInterfaceItem(int idx) const { - for (std::vector::const_iterator it = m_items.begin(); it != m_items.end(); ++it) { + for (Vector::const_iterator it = m_items.begin(); it != m_items.end(); ++it) { if ((*it)->getIdx() == idx) return *it; } @@ -82,8 +78,8 @@ IReplicatedInterfaceItem* ReplicatedInterfaceItemBase::getSystemPort() const { return dynamic_cast(getParent())->getSystemPort(); } -std::string ReplicatedInterfaceItemBase::toString() const { - return "replicated port " + getName(); +String ReplicatedInterfaceItemBase::toString() const { + return String("replicated port ") + getName(); } IInterfaceItem* ReplicatedInterfaceItemBase::connectWith(IInterfaceItem* peer) { diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ReplicatedInterfaceItemBase.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ReplicatedInterfaceItemBase.h index 4738382da..bf1447154 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ReplicatedInterfaceItemBase.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ReplicatedInterfaceItemBase.h @@ -15,9 +15,8 @@ #include "common/modelbase/IInterfaceItemOwner.h" #include "common/modelbase/InterfaceItemBase.h" #include "common/modelbase/IReplicatedInterfaceItem.h" -#include -#include -#include +#include "common/containers/String.h" +#include "common/containers/Vector.h" namespace etRuntime { @@ -45,23 +44,23 @@ public: virtual IEventReceiver* getEventReceiver() const; virtual IReplicatedInterfaceItem* getSystemPort() const; - std::string toString() const; + String toString() const; virtual IInterfaceItem* connectWith(IInterfaceItem* peer); protected: - ReplicatedInterfaceItemBase(IInterfaceItemOwner* owner, const std::string& name, int localId); + ReplicatedInterfaceItemBase(IInterfaceItemOwner* owner, const String& name, int localId); - std::vector& getItems() { + Vector& getItems() { return m_items; } - virtual InterfaceItemBase* createInterfaceItem(IInterfaceItemOwner* rcv, const std::string& name, int lid, int idx) = 0; + virtual InterfaceItemBase* createInterfaceItem(IInterfaceItemOwner* rcv, const String& name, int lid, int idx) = 0; private: int m_localId; - std::vector m_items; - std::queue m_releasedIndices; + Vector m_items; + Vector m_releasedIndices; int getFreeIndex(); diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ReplicatedPortBase.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ReplicatedPortBase.h index a3975093a..b4afdd76e 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ReplicatedPortBase.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/ReplicatedPortBase.h @@ -13,7 +13,6 @@ #define SRC_COMMON_MODELBASE_REPLICATEDPORTBASE_H_ #include "common/modelbase/ReplicatedInterfaceItemBase.h" -#include namespace etRuntime { @@ -22,7 +21,7 @@ public: virtual ~ReplicatedPortBase() {} protected: - ReplicatedPortBase(IInterfaceItemOwner* owner, const std::string& name, int localId) : + ReplicatedPortBase(IInterfaceItemOwner* owner, const String& name, int localId) : ReplicatedInterfaceItemBase(owner, name, localId) { } diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/SubSystemClassBase.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/SubSystemClassBase.cpp index d7e33a04a..762ca2910 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/SubSystemClassBase.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/SubSystemClassBase.cpp @@ -16,22 +16,20 @@ #include "common/messaging/MessageServiceController.h" #include "common/messaging/RTServices.h" #include "common/modelbase/ActorClassBase.h" -#include -#include -#include -#include -#include - namespace etRuntime { -SubSystemClassBase::SubSystemClassBase(IRTObject* parent, std::string name) : +SubSystemClassBase::SubSystemClassBase(IRTObject* parent, String name) : RTObject(parent, name), m_RTSystemPort(this, IFITEM_RTSystemPort) { - DebuggingService::getInstance().getAsyncLogger().setMSC(name + "_Async", "log/"); + String asyncMSCname(name); + asyncMSCname += "_Async"; + String syncMSCname(name); + syncMSCname += "_Sync"; + DebuggingService::getInstance().getAsyncLogger().setMSC(asyncMSCname.c_str(), "log/"); DebuggingService::getInstance().getAsyncLogger().open(); - DebuggingService::getInstance().getSyncLogger().setMSC(name + "_Sync", "log/"); + DebuggingService::getInstance().getSyncLogger().setMSC(syncMSCname.c_str(), "log/"); DebuggingService::getInstance().getSyncLogger().open(); DebuggingService::getInstance().getSyncLogger().setObjectName("main"); @@ -40,7 +38,7 @@ SubSystemClassBase::SubSystemClassBase(IRTObject* parent, std::string name) : void SubSystemClassBase::init() { - std::cout << "*** MainComponent " << getInstancePath() << "::init ***" << std::endl; + printf("*** MainComponent %s::init ***\n", getInstancePath().c_str()); // MessageService instantiateMessageServices(); @@ -55,7 +53,7 @@ void SubSystemClassBase::init() { // std::cout << toStringRecursive() << std::endl; // initialize all actor instances - for (std::vector::iterator it = getChildren().begin(); it != getChildren().end(); ++it) { + for (ChildList::iterator it = getChildren().begin(); it != getChildren().end(); ++it) { ActorClassBase* child = dynamic_cast(*it); if (child != 0) child->init(); @@ -72,50 +70,50 @@ void SubSystemClassBase::start() { } void SubSystemClassBase::stop() { - std::cout << "*** MainComponent " << getInstancePath() << "::stop ***" << std::endl; + printf("*** MainComponent %s::stop ***\n", getInstancePath().c_str()); RTServices::getInstance().getMsgSvcCtrl().stop(); - std::cout << "=== done stop MsgSvcCtrl" << std::endl; + printf("=== done stop MsgSvcCtrl\n"); // stop all actor instances - for (std::vector::iterator it = getChildren().begin(); it != getChildren().end(); ++it) { + for (ChildList::iterator it = getChildren().begin(); it != getChildren().end(); ++it) { ActorClassBase* child = dynamic_cast(*it); if (child != 0) child->stop(); } - std::cout << "=== done stop actor instances" << std::endl; + printf("=== done stop actor instances\n"); } void SubSystemClassBase::destroy() { - std::cout << "*** MainComponent " << this->getInstancePath() << "::destroy ***" << std::endl; + printf("*** MainComponent %s::destroy ***\n", this->getInstancePath().c_str()); RTObject::destroy(); // std::cout << toStringRecursive() << std::endl; - std::cout << "=== done destroy actor instances" << std::endl; + printf("=== done destroy actor instances\n"); DebuggingService::getInstance().getAsyncLogger().close(); DebuggingService::getInstance().getSyncLogger().close(); - std::cout << "=== done close loggers" << std::endl; + printf("=== done close loggers\n"); RTServices::getInstance().destroy(); - std::cout << "=== done destroy RTServices\n\n\n" << std::endl; + printf("=== done destroy RTServices\n\n\n\n"); } IMessageService* SubSystemClassBase::getMsgService(int idx) const { return RTServices::getInstance().getMsgSvcCtrl().getMsgSvc(idx); } -ActorClassBase* SubSystemClassBase::getInstance(const std::string& path) const { +ActorClassBase* SubSystemClassBase::getInstance(const String& path) const { IRTObject* object = getObject(path); return dynamic_cast(object); } -void SubSystemClassBase::addPathToThread(const std::string& path, int thread) { +void SubSystemClassBase::addPathToThread(const String& path, int thread) { m_path2thread[path] = thread; } -int SubSystemClassBase::getThreadForPath(const std::string& path) const { - std::map ::const_iterator it = m_path2thread.find(path); +int SubSystemClassBase::getThreadForPath(const String& path) const { + Map ::const_iterator it = m_path2thread.find(path); if (it == m_path2thread.end()) return -1; diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/SubSystemClassBase.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/SubSystemClassBase.h index 11bd28c61..f0172333f 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/SubSystemClassBase.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/SubSystemClassBase.h @@ -13,13 +13,12 @@ #ifndef SUBSYSTEMCLASSBASE_H_ #define SUBSYSTEMCLASSBASE_H_ +#include "common/containers/Map.h" #include "common/modelbase/IEventReceiver.h" #include "common/modelbase/IInterfaceItemOwner.h" #include "common/modelbase/IReplicatedInterfaceItem.h" #include "common/modelbase/RTSystemProtocol.h" #include "etDatatypes.h" -#include -#include namespace etRuntime { @@ -43,10 +42,10 @@ public: IMessageService* getMsgService(int idx) const; Address getFreeAddress(int msgSvcId) const; - ActorClassBase* getInstance(const std::string& path) const; + ActorClassBase* getInstance(const String& path) const; - void addPathToThread(const std::string& path, int thread); - int getThreadForPath(const std::string& path) const; + void addPathToThread(const String& path, int thread); + int getThreadForPath(const String& path) const; void resetAll(); @@ -68,7 +67,7 @@ public: protected: - SubSystemClassBase(IRTObject* parent, std::string name); + SubSystemClassBase(IRTObject* parent, String name); //--------------------- ports RTSystemConjPort m_RTSystemPort; @@ -78,7 +77,7 @@ protected: private: - std::map m_path2thread; + Map m_path2thread; SubSystemClassBase(); SubSystemClassBase(SubSystemClassBase const&); diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/SubSystemRunnerBase.cpp b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/SubSystemRunnerBase.cpp index 931527644..09c8102d0 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/SubSystemRunnerBase.cpp +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/SubSystemRunnerBase.cpp @@ -15,26 +15,24 @@ #include "common/modelbase/SubSystemClassBase.h" #include "runtime/etRuntime.h" #include "etUnit/etUnit.h" -#include -#include #include namespace etRuntime { -const std::string SubSystemRunnerBase::OPTION_RUN_AS_TEST = "-run_as_test"; -const std::string SubSystemRunnerBase::OPTION_RUN_HEADLESS = "-headless"; +const String SubSystemRunnerBase::OPTION_RUN_AS_TEST = "-run_as_test"; +const String SubSystemRunnerBase::OPTION_RUN_HEADLESS = "-headless"; void SubSystemRunnerBase::run(SubSystemClassBase& main_component, int argc, char* argv[]) { - std::cout << "*** T H E B E G I N ***" << std::endl; + printf("*** T H E B E G I N ***\n"); etBool headless = false; for (int i = 1; i < argc; ++i) { // omit first argument, which is the program name if (OPTION_RUN_AS_TEST.compare(argv[i]) == 0) { - std::cout << "*** running as test" << std::endl; + printf("*** running as test\n"); headless = true; } else if (OPTION_RUN_HEADLESS.compare(argv[i]) == 0) { - std::cout << "*** running headless" << std::endl; + printf("*** running headless\n"); headless = true; } } @@ -52,7 +50,7 @@ void SubSystemRunnerBase::run(SubSystemClassBase& main_component, int argc, char main_component.stop(); // lifecycle stop main_component.destroy(); // lifecycle destroy - std::cout << "*** T H E E N D ***" << std::endl; + printf("*** T H E E N D ***\n"); } @@ -83,9 +81,9 @@ void SubSystemRunnerBase::waitForQuit() { } void SubSystemRunnerBase::waitForTerminate() { - std::cout << "=== waitForTestcase: before acq. semaphore" << std::endl; + printf("=== waitForTestcase: before acq. semaphore\n"); etSema_waitForWakeup(etRuntime_getTerminateSemaphore()); - std::cout << "=== waitForTestcase: after acq. semaphore" << std::endl; + printf("=== waitForTestcase: after acq. semaphore\n"); } } /* namespace etRuntime */ diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/SubSystemRunnerBase.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/SubSystemRunnerBase.h index 156f1d096..89e44f535 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/SubSystemRunnerBase.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/SubSystemRunnerBase.h @@ -13,7 +13,7 @@ #ifndef SUBSYSTEMRUNNERBASE_H_ #define SUBSYSTEMRUNNERBASE_H_ -#include +#include "common/containers/String.h" namespace etRuntime { @@ -33,8 +33,8 @@ protected: static void waitForQuit(); private: - static const std::string OPTION_RUN_AS_TEST; - static const std::string OPTION_RUN_HEADLESS; + static const String OPTION_RUN_AS_TEST; + static const String OPTION_RUN_HEADLESS; SubSystemRunnerBase(SubSystemRunnerBase const&); SubSystemRunnerBase& operator=(SubSystemRunnerBase const&); diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/SystemPortOwner.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/SystemPortOwner.h index 4cd43f9a6..8b74e9d20 100644 --- a/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/SystemPortOwner.h +++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/modelbase/SystemPortOwner.h @@ -15,7 +15,6 @@ #include "common/messaging/RTObject.h" #include "common/modelbase/EventReceiver.h" #include "common/modelbase/IInterfaceItemOwner.h" -#include namespace etRuntime { @@ -39,7 +38,7 @@ public: } protected: - SystemPortOwner(IRTObject* parent, const std::string& name) : + SystemPortOwner(IRTObject* parent, const String& name) : EventReceiver(parent, name) { } -- cgit v1.2.3