| /******************************************************************************* |
| * Copyright (c) 2016 CEA LIST. |
| * |
| * 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: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and implementation |
| ******************************************************************************/ |
| #ifndef BASEBUFFERQUEUE_H_ |
| #define BASEBUFFERQUEUE_H_ |
| |
| #include <fml/buffer/BaseBufferForm.h> |
| #include <collection/BFContainer.h> |
| |
| #include <fml/runtime/Message.h> |
| |
| |
| namespace sep |
| { |
| |
| |
| class RuntimeID; |
| |
| |
| class BaseBufferQueue : public BaseBufferForm |
| { |
| |
| public: |
| /** |
| * TYPEDEF |
| */ |
| typedef ListOfMessage::const_iterator const_iterator; |
| |
| protected: |
| /* |
| * ATTRIBUTE |
| */ |
| ListOfMessage mMessages; |
| |
| avm_size_t mCapacity; |
| |
| |
| public: |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| BaseBufferQueue(class_kind_t aClassKind, InstanceOfBuffer * aBuffer) |
| : BaseBufferForm(aClassKind, aBuffer), |
| mMessages( ), |
| mCapacity( aBuffer->capacity() ) |
| { |
| //!! NOTHING |
| } |
| |
| /** |
| * CONSTRUCTOR |
| * Copy |
| */ |
| BaseBufferQueue(const BaseBufferQueue & aBuffer) |
| : BaseBufferForm( aBuffer ), |
| mMessages( aBuffer.mMessages ), |
| mCapacity( aBuffer.mCapacity ) |
| { |
| //!! NOTHING |
| } |
| |
| /** |
| * DESTRUCTOR |
| */ |
| virtual ~BaseBufferQueue() |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mMessages |
| */ |
| inline const_iterator beginMessages() const |
| { |
| return( mMessages.begin() ); |
| } |
| |
| inline const_iterator endMessages() const |
| { |
| return( mMessages.end() ); |
| } |
| |
| inline ListOfMessage & getMessages() |
| { |
| return( mMessages ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mCapacity |
| */ |
| inline avm_size_t capacity() const |
| { |
| return( mCapacity ); |
| } |
| |
| inline long realCapacity() const |
| { |
| return( (mCapacity == AVM_NUMERIC_MAX_SIZE_T)? -1 : mCapacity ); |
| } |
| |
| inline void setCapacity(long aCapacity) |
| { |
| mCapacity = (aCapacity < 0) ? AVM_NUMERIC_MAX_SIZE_T : aCapacity; |
| } |
| |
| inline bool isFinite() const |
| { |
| return( mCapacity < AVM_NUMERIC_MAX_SIZE_T ); |
| } |
| |
| inline bool isInfinite() const |
| { |
| return( mCapacity == AVM_NUMERIC_MAX_SIZE_T ); |
| } |
| |
| |
| /** |
| * Comparison |
| * operator== |
| */ |
| virtual bool equals(const BaseBufferForm & aBuffer) const; |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // BUFFER MANAGEMENT API |
| //////////////////////////////////////////////////////////////////////////// |
| /** |
| * emptiness |
| * size |
| */ |
| inline virtual bool empty() const |
| { |
| return( mMessages.empty() ); |
| } |
| |
| inline virtual bool nonempty() const |
| { |
| return( mMessages.nonempty() ); |
| } |
| |
| inline virtual bool singleton() const |
| { |
| return( mMessages.singleton() ); |
| } |
| |
| inline virtual bool populated() const |
| { |
| return( mMessages.populated() ); |
| } |
| |
| inline virtual bool full() const |
| { |
| return( size() == mCapacity ); |
| } |
| |
| inline virtual avm_size_t size() const |
| { |
| return( mMessages.size() ); |
| } |
| |
| /** |
| * clear |
| * resize |
| * remove |
| */ |
| inline virtual void clear() |
| { |
| mMessages.clear(); |
| } |
| |
| inline virtual void resize(avm_size_t newSize) |
| { |
| if( mCapacity > newSize ) |
| { |
| if( (mCapacity = size()) > newSize ) |
| { |
| for( ; mCapacity > newSize ; --mCapacity ) |
| { |
| pop(); |
| } |
| return; |
| } |
| } |
| mCapacity = newSize; |
| } |
| |
| inline virtual void resize(avm_size_t newSize, const Message & aMsg) |
| { |
| if( mCapacity > newSize ) |
| { |
| if( (mCapacity = size()) > newSize ) |
| { |
| for( ; mCapacity > newSize ; --mCapacity ) |
| { |
| pop(); |
| } |
| return; |
| } |
| } |
| else if( (mCapacity = size()) < newSize ) |
| { |
| for( ; mCapacity < newSize ; ++mCapacity ) |
| { |
| push(aMsg); |
| } |
| } |
| |
| mCapacity = newSize; |
| } |
| |
| |
| inline virtual void remove(InstanceOfPort * aSignal) |
| { |
| ListOfMessage::iterator it = mMessages.begin(); |
| for( ; it != mMessages.end() ; ) |
| { |
| if( (*it).isSignal(aSignal) ) |
| { |
| it = mMessages.erase(it); |
| } |
| else |
| { |
| ++it; |
| } |
| } |
| } |
| |
| |
| inline virtual void remove(const RuntimeID & aReceiverRID) |
| { |
| if( aReceiverRID.valid() ) |
| { |
| ListOfMessage::iterator it = mMessages.begin(); |
| for( ; it != mMessages.end() ; ) |
| { |
| if( (*it).isReceiver(aReceiverRID) ) |
| { |
| it = mMessages.erase( it ); |
| } |
| else |
| { |
| ++it; |
| } |
| } |
| } |
| else |
| { |
| clear(); |
| } |
| } |
| |
| |
| |
| /** |
| * contains |
| * uncontains |
| */ |
| inline virtual bool contains(avm_size_t mid, |
| const RuntimeID & aReceiverRID = RuntimeID::REF_NULL) const |
| { |
| const_iterator it = mMessages.begin(); |
| const_iterator itEnd = mMessages.end(); |
| for( ; it != itEnd ; ++it ) |
| { |
| if( (*it).isCompatible(mid, aReceiverRID) ) |
| { |
| return( true ); |
| } |
| } |
| return( false ); |
| } |
| |
| |
| inline virtual bool contains(InstanceOfPort * aSignal, |
| const RuntimeID & aReceiverRID = RuntimeID::REF_NULL) const |
| { |
| const_iterator it = mMessages.begin(); |
| const_iterator itEnd = mMessages.end(); |
| for( ; it != itEnd ; ++it ) |
| { |
| if( (*it).isCompatible(aSignal, aReceiverRID) ) |
| { |
| return( true ); |
| } |
| } |
| return( false ); |
| } |
| |
| |
| inline virtual bool contains(ListOfInstanceOfPort & aSignalTrace, |
| const RuntimeID & aReceiverRID = RuntimeID::REF_NULL) const |
| { |
| ListOfInstanceOfPort::const_iterator itSignal = aSignalTrace.begin(); |
| ListOfInstanceOfPort::const_iterator endSignal = aSignalTrace.end(); |
| for( ; itSignal != endSignal ; ++itSignal ) |
| { |
| if( not contains( *itSignal , aReceiverRID ) ) |
| { |
| return( false ); |
| } |
| } |
| |
| return( itSignal == endSignal ); |
| } |
| |
| |
| inline virtual bool uncontains(ListOfInstanceOfPort & aSignalTrace, |
| const RuntimeID & aReceiverRID = RuntimeID::REF_NULL) const |
| { |
| ListOfInstanceOfPort::iterator itSignal = aSignalTrace.begin(); |
| ListOfInstanceOfPort::iterator endSignal = aSignalTrace.end(); |
| for( ; itSignal != endSignal ; ) |
| { |
| if( contains( *itSignal, aReceiverRID ) ) |
| { |
| itSignal = aSignalTrace.erase( itSignal ); |
| } |
| } |
| |
| return( aSignalTrace.nonempty() ); |
| } |
| |
| |
| /** |
| * Serialization |
| */ |
| virtual void toStream(OutStream & os) const; |
| |
| virtual void toFscn(OutStream & os, const RuntimeID & aRID, |
| const BaseBufferForm * prevBuf = NULL) const; |
| |
| }; |
| |
| |
| } |
| |
| #endif /*BASEBUFFERQUEUE_H_*/ |
