diff --git a/.gitignore b/.gitignore index f91ff2b9..7945f299 100644 --- a/.gitignore +++ b/.gitignore @@ -7,6 +7,7 @@ .metadata bin/ tmp/ +docs/ *.tmp *.bak *.swp diff --git a/Doxyfile b/Doxyfile index e39969ef..28bec7c3 100644 --- a/Doxyfile +++ b/Doxyfile @@ -2107,7 +2107,7 @@ PERL_PATH = /usr/bin/perl # powerful graphs. # The default value is: YES. -CLASS_DIAGRAMS = NO +CLASS_DIAGRAMS = YES # You can define message sequence charts within doxygen comments using the \msc # command. Doxygen will then run the mscgen tool (see: @@ -2138,7 +2138,7 @@ HIDE_UNDOC_RELATIONS = YES # set to NO # The default value is: NO. -HAVE_DOT = YES +HAVE_DOT = NO # The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed # to run in parallel. When set to 0 doxygen will base this on the number of @@ -2180,7 +2180,7 @@ DOT_FONTPATH = # The default value is: YES. # This tag requires that the tag HAVE_DOT is set to YES. -CLASS_GRAPH = YES +CLASS_GRAPH = NO # If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a # graph for each documented class showing the direct and indirect implementation @@ -2196,7 +2196,7 @@ COLLABORATION_GRAPH = NO # The default value is: YES. # This tag requires that the tag HAVE_DOT is set to YES. -GROUP_GRAPHS = YES +GROUP_GRAPHS = NO # If the UML_LOOK tag is set to YES doxygen will generate inheritance and # collaboration diagrams in a style similar to the OMG's Unified Modeling @@ -2204,7 +2204,7 @@ GROUP_GRAPHS = YES # The default value is: NO. # This tag requires that the tag HAVE_DOT is set to YES. -UML_LOOK = NO +UML_LOOK = YES # If the UML_LOOK tag is enabled, the fields and methods are shown inside the # class node. If there are many fields or methods and many nodes the graph may @@ -2272,7 +2272,7 @@ CALLER_GRAPH = NO # The default value is: YES. # This tag requires that the tag HAVE_DOT is set to YES. -GRAPHICAL_HIERARCHY = NO +GRAPHICAL_HIERARCHY = YES # If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the # dependencies a directory has on other directories in a graphical way. The diff --git a/array.h b/array.h new file mode 100644 index 00000000..8b4b614b --- /dev/null +++ b/array.h @@ -0,0 +1,451 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. + +Copyright(c) 2014 jwellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef __etl_array__ +#define __etl_array__ + +#include +#include +#include +#include + +#include "exception.h" + +///\defgroup array array +/// A replacement for std::array if you haven't got C++0x11. +///\ingroup containers + +namespace etl +{ +#ifdef ETL_USE_EXCEPTIONS + //*************************************************************************** + ///\ingroup array + /// The base class for array exceptions. + //*************************************************************************** + class array_exception : public exception + { + public: + + array_exception(const char* what) + : exception(what) + { + } + }; + + //*************************************************************************** + ///\ingroup array + /// The out of range exceptions. + //*************************************************************************** + class array_out_of_range_exception : public array_exception + { + public: + + array_out_of_range_exception() + : array_exception("array out of range") + { + } + }; +#endif + + //*************************************************************************** + ///\ingroup array + /// A replacement for std::array if you haven't got C++0x11. + //*************************************************************************** + template + class array + { + public: + + //************************************************************************* + /// STL style typedefs. + //************************************************************************* + typedef T* iterator; + typedef const T* const_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef T* pointer; + typedef const T* const_pointer; + typedef T& reference; + typedef const T& const_reference; + typedef std::ptrdiff_t difference_type; + typedef std::size_t size_type; + typedef T value_type; + + //************************************************************************* + /// Returns an iterator to the beginning of the array. + //************************************************************************* + inline iterator begin() + { + return &_buffer[0]; + } + + //************************************************************************* + /// Returns a const iterator to the beginning of the array. + //************************************************************************* + inline const_iterator begin() const + { + return &_buffer[0]; + } + + //************************************************************************* + /// Returns a const iterator to the beginning of the array. + //************************************************************************* + inline const_iterator cbegin() const + { + return begin(); + } + + //************************************************************************* + // Returns an reverse iterator to the reverse beginning of the array. + //************************************************************************* + inline reverse_iterator rbegin() + { + return reverse_iterator(end()); + } + + //************************************************************************* + /// Returns a const reverse iterator to the reverse beginning of the array. + //************************************************************************* + inline const_reverse_iterator rbegin() const + { + return const_reverse_iterator(end()); + } + + //************************************************************************* + /// Returns a const reverse iterator to the reverse beginning of the array. + //************************************************************************* + inline const_reverse_iterator crbegin() const + { + return const_reverse_iterator(end()); + } + + //************************************************************************* + /// Returns an iterator to the end of the array. + //************************************************************************* + inline iterator end() + { + return &_buffer[SIZE]; + } + + //************************************************************************* + /// Returns a const iterator to the end of the array. + //************************************************************************* + inline const_iterator end() const + { + return &_buffer[SIZE]; + } + + //************************************************************************* + // Returns a const iterator to the end of the array. + //************************************************************************* + inline const_iterator cend() const + { + return &_buffer[SIZE]; + } + + //************************************************************************* + /// Returns a reverse iterator to the end of the array. + //************************************************************************* + inline reverse_iterator rend() + { + return reverse_iterator(begin()); + } + + //************************************************************************* + /// Returns a const reverse iterator to the end of the array. + //************************************************************************* + inline const_reverse_iterator rend() const + { + return const_reverse_iterator(begin()); + } + + //************************************************************************* + /// Returns a const reverse iterator to the end of the array. + //************************************************************************* + inline const_reverse_iterator crend() const + { + return const_reverse_iterator(begin()); + } + + //************************************************************************* + /// Returns a reference to the value at index 'i'. + /// If ETL_USE_EXCEPTIONS is defined then am array_out_of_range_exception is + /// thown if the index is out of range. + ///\param i The index of the element to access. + //************************************************************************* + inline reference at(size_t i) + { +#if ETL_USE_EXCEPTIONS + if (i >= SIZE) + { + throw array_out_of_range_exception(); + } +#endif + + return _buffer[i]; + } + + //************************************************************************* + /// Returns a const reference to the value at index 'i'. + /// If ETL_USE_EXCEPTIONS is defined then am array_out_of_range_exception is + /// thown if the index is out of range. + ///\param i The index of the element to access. + //************************************************************************* + inline const_reference at(size_t i) const + { +#if ETL_USE_EXCEPTIONS + if (i >= SIZE) + { + throw array_out_of_range_exception(); + } +#endif + + return _buffer[i]; + } + + //************************************************************************* + /// [] operator. + /// Returns a reference to the value at index 'i'. + ///\param i The index of the element to access. + //************************************************************************* + inline reference operator[](size_t i) + { + return _buffer[i]; + } + + //************************************************************************* + /// [] operator. + /// Returns a const reference to the value at index 'i'. + ///\param i The index of the element to access. + //************************************************************************* + inline const_reference operator[](size_t i) const + { + return _buffer[i]; + } + + //************************************************************************* + /// Returns true if the array size is zero. + /// + //************************************************************************* + inline bool empty() const + { + return (SIZE == 0); + } + + //************************************************************************* + /// Returns the size of the array. + //************************************************************************* + inline size_t size() const + { + return SIZE; + } + + //************************************************************************* + /// Returns the maximum possible size of the array. + //************************************************************************* + inline size_t max_size() const + { + return SIZE; + } + + //************************************************************************* + /// Fills the array with the specified value. + ///\param value The value to fill the array with. + //************************************************************************* + void fill(const T& value) + { + std::fill(begin(), end(), value); + } + + //************************************************************************* + /// Swaps the contents of this array and another. + ///\param other A reference to the other array. + //************************************************************************* + void swap(array& other) + { + for (size_t i = 0; i < SIZE; ++i) + { + std::swap(_buffer[i], other._buffer[i]); + } + } + + //************************************************************************* + /// Returns a reference to the first element. + //************************************************************************* + inline reference front() + { + return _buffer[0]; + } + + //************************************************************************* + /// Returns a const reference to the first element. + //************************************************************************* + inline const_reference front() const + { + return _buffer[0]; + } + + //************************************************************************* + /// Returns a reference to the last element. + //************************************************************************* + inline reference back() + { + return _buffer[SIZE - 1]; + } + + //************************************************************************* + /// Returns a const reference to the last element. + //************************************************************************* + inline const_reference back() const + { + return _buffer[SIZE - 1]; + } + + //************************************************************************* + /// Returns a pointer to the first element of the internal buffer. + //************************************************************************* + inline pointer data() + { + return &_buffer[0]; + } + + //************************************************************************* + /// Returns a const pointer to the first element of the internal buffer. + //************************************************************************* + inline const_pointer data() const + { + return &_buffer[0]; + } + + T _buffer[SIZE]; ///< The buffer that stores the array data. + }; + + //************************************************************************* + /// + /// Overloaded std::swap for etl::array + /// + ///\param lhs Reference to the first array. + ///\param rhs Reference to the second array. + //************************************************************************* + template + void swap(elt::array &lhs, etl::array &rhs) + { + lhs.swap(rhs); + } + + //************************************************************************* + /// + /// Equal operator. + /// + ///\param lhs Reference to the first array. + ///\param rhs Reference to the second array. + ///\return true if the arrays are equal, otherwise false + //************************************************************************* + template + bool operator ==(const elt::array& lhs, const elt::array& rhs) + { + return std::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin()); + } + + //************************************************************************* + /// Not equal operator. + ///\param lhs Reference to the first array. + ///\param rhs Reference to the second array. + ///\return true if the arrays are not equal, otherwise false + //************************************************************************* + template + bool operator !=(const elt::array& lhs, const elt::array& rhs) + { + return !(lhs == rhs); + } + + //************************************************************************* + /// Less than operator. + ///\param lhs Reference to the first array. + ///\param rhs Reference to the second array. + ///\return true if the first array is lexicographically less than the second, otherwise false + //************************************************************************* + template + bool operator <(const elt::array& lhs, const elt::array& rhs) + { + return std::lexicographical_compare(lhs.cbegin(), + lhs.cend(), + rhs.cbegin(), + rhs.cend()); + } + + //************************************************************************* + /// Less than or equal operator. + ///\param lhs Reference to the first array. + ///\param rhs Reference to the second array. + ///\return true if the first array is lexicographically less than or equal to the second, otherwise false + //************************************************************************* + template + bool operator <=(const elt::array& lhs, const elt::array& rhs) + { + return !std::lexicographical_compare(lhs.cbegin(), + lhs.cend(), + rhs.cbegin(), + rhs.cend(), + std::greater()); + } + + //************************************************************************* + /// Greater than operator. + ///\param lhs Reference to the first array. + ///\param rhs Reference to the second array. + ///\return true if the first array is lexicographically greater than the second, otherwise false + template + //************************************************************************* + bool operator >(const elt::array& lhs, const elt::array& rhs) + { + return std::lexicographical_compare(lhs.cbegin(), + lhs.cend(), + rhs.cbegin(), + rhs.cend(), + std::greater()); + } + + //************************************************************************* + /// Greater than or equal operator. + ///\param lhs Reference to the first array. + ///\param rhs Reference to the second array. + ///\return true if the first array is lexicographically greater than or equal to the second, otherwise false + //************************************************************************* + template + bool operator >=(const elt::array& lhs, const elt::array& rhs) + { + return !std::lexicographical_compare(lhs.cbegin(), + lhs.cend(), + rhs.cbegin(), + rhs.cend()); + } +} + +#endif + diff --git a/doxygen.h b/doxygen.h index f74080e6..308b0cef 100644 --- a/doxygen.h +++ b/doxygen.h @@ -24,18 +24,19 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ******************************************************************************/ -///\defgroup ETL Embedded Template Library +///\defgroup etl Embedded Template Library -///\defgroup Containers Containers -///\ingroup ETL +///\defgroup containers Containers +///\ingroup etl -///\defgroup Utilities Utilities -///\ingroup ETL +///\defgroup utilities Utilities +/// A set of utility templates. +///\ingroup etl -///\defgroup Math Math -///\ingroup ETL +///\defgroup math Math +///\ingroup etl -///\ingroup ETL +///\ingroup etl namespace etl {} diff --git a/enum_type.h b/enum_type.h new file mode 100644 index 00000000..c8895681 --- /dev/null +++ b/enum_type.h @@ -0,0 +1,114 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. + +Copyright(c) 2014 jwellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef __etl_enum_type__ +#define __etl_enum_type__ + +///\defgroup enum_type enum_type +/// Smart enumerations.
+/// A method of declaring enumerations that allow grouping within a structure. +/// Avoids the problem of clashing names that can occur with standard enumerations. +/// One way to think of the code is as a type with built-in constants and an optional conversion to a string.

+/// Declaring the enumeration. +///\code +/// struct CompassDirection +/// { +/// enum enum_type +/// { +/// North = 0, +/// South = 180, +/// East = 90, +/// West = 270 +/// }; +/// +/// DECLARE_ENUM_TYPE(CompassDirection, int) +/// ENUM_TYPE("North", North) +/// ENUM_TYPE("South", South) +/// ENUM_TYPE("East", East) +/// ENUM_TYPE("West", West) +/// END_ENUM_TYPE +/// }; +///\endcode +/// Using the enumeration. +///\code +/// CompassDirection direction; // Default construction. +/// +/// direction = CompassDirection::North; // Assignment from an enumeration constant; +/// +/// int value = direction; // Implicit conversion to 'int'. +/// +/// direction = CompassDirection(value); // Explicit conversion from 'int'. +/// +/// direction = CompassDirection(3); // Explicit conversion from an invalid value. This unfortunately cannot be avoided. Caveat emptor! +/// +/// direction = value; // **** Compilation error **** +/// +/// std::cout << "Direction = " << direction.to_string(); // Prints "Direction = North" +///\endcode +/// If a conversion to a string is not required then the 'ENUM_TYPE' declaration may be omitted. +/// In that case the to_string() function will return a "?". This will also be the case for any +/// enumeration value that does not have an ENUM_TYPE entry. +///\ingroup utilities + +//***************************************************************************** +// The declaration of the member functions and the first section of the 'to_string' function. +//***************************************************************************** +#define DECLARE_ENUM_TYPE(TypeName, ValueType) \ + typedef ValueType value_type; \ + inline TypeName() {} \ + inline TypeName(const TypeName &other) : value(other.value) {} \ + inline TypeName(enum_type value) : value(value) {} \ + inline TypeName& operator=(const TypeName &other) { value = other.value} \ + inline explicit TypeName(ValueType value) : value(static_cast(value)) {} \ + inline operator ValueType() const {return (static_cast(value));} \ + inline ValueType get_value() const {return (static_cast(value));} \ + inline enum_type get_enum() const {return value;} \ + const char* to_string() const \ + { \ + switch (value) \ + { + +//***************************************************************************** +// A case in the 'to_string' function's switch statement. +//***************************************************************************** +#define ENUM_TYPE(value, name) \ + case value: \ + return name; \ + +//***************************************************************************** +// The final section of the 'to_string' function and the value declaration. +//***************************************************************************** +#define END_ENUM_TYPE \ + default: \ + return "?"; \ + } \ + } \ +private: \ + enum_type value; + +#endif diff --git a/exception.h b/exception.h index dd1d8873..07c0a1bc 100644 --- a/exception.h +++ b/exception.h @@ -29,14 +29,14 @@ SOFTWARE. #ifndef __etl_exception__ #define __etl_exception__ -///\defgroup Exception Exceptions +///\defgroup exception exception /// The base class for all ETL exceptions. -///\ingroup Utilities +///\ingroup utilities namespace etl { //*************************************************************************** - ///\ingroup Exception + ///\ingroup exception /// A low overhead exception base class. //*************************************************************************** class exception diff --git a/function.h b/function.h index 4071503a..5d09c1e5 100644 --- a/function.h +++ b/function.h @@ -30,18 +30,18 @@ SOFTWARE. #define __etl_function__ //***************************************************************************** -///\defgroup Function Function +///\defgroup function function /// A set of wrapper templates to allow a member or static function to be called /// without the caller having to know the specific details of the callee. /// This template class may be used to link interrupt vectors to specific member /// functions of a handler class. -///\ingroup Utilities +///\ingroup utilities //***************************************************************************** namespace etl { //*************************************************************************** - ///\ingroup Function + ///\ingroup function /// The base interface template for function template specialisations. ///\tparam TParameter The parameter type expected by the function. //*************************************************************************** @@ -59,7 +59,7 @@ namespace etl }; //*************************************************************************** - ///\ingroup Function + ///\ingroup function /// The base interface template for functions taking void parameters. //*************************************************************************** template <> @@ -74,7 +74,7 @@ namespace etl }; //*************************************************************************** - ///\ingroup Function + ///\ingroup function /// A derived function template that takes an object type and parameter type. ///\tparam TObject The object type that contains the member function. ///\tparam TParameter The parameter type accepted by the member function. @@ -116,7 +116,7 @@ namespace etl }; //*************************************************************************** - ///\ingroup Function + ///\ingroup function /// A derived function template that takes a parameter type. ///\tparam TObject The object type that contains the member function. //*************************************************************************** @@ -152,7 +152,7 @@ namespace etl }; //*************************************************************************** - ///\ingroup Function + ///\ingroup function /// Specialisation for static or global functions that take a parameter. //*************************************************************************** template @@ -185,7 +185,7 @@ namespace etl }; //*************************************************************************** - ///\ingroup Function + ///\ingroup function /// Specialisation static functions taking void parameter. //*************************************************************************** template <> diff --git a/iqueue.h b/iqueue.h index 8f5fd116..a7f1948b 100644 --- a/iqueue.h +++ b/iqueue.h @@ -33,15 +33,12 @@ SOFTWARE. #include "queue_base.h" -///\defgroup Queue Queue -///\ingroup Containers - namespace etl { //*************************************************************************** - ///\ingroup Queue + ///\ingroup queue ///\brief This is the base for all queues that contain a particular type. - ///\detail Normally a reference to this type will be taken from a derived queue. + ///\details Normally a reference to this type will be taken from a derived queue. ///\code /// etl::queue myQueue; /// etl::iqueue& iQueue = myQueue; diff --git a/math.h b/math.h index e3b93c95..17ca40a1 100644 --- a/math.h +++ b/math.h @@ -31,10 +31,17 @@ SOFTWARE. #include +///\defgroup log log +/// A set of templates to generate compile time constants.
+/// log : Calculates logs to any base, rounded down to the nearest integer.
+/// log2 : Calculates logs to base 2, rounded down to the nearest integer.
+/// log10 : Calculates logs to base 10, rounded down to the nearest integer.
+///\ingroup math + namespace etl { //*************************************************************************** - ///\ingroup Math + ///\ingroup log /// The base generic log template. /// Defines 'value' as the log of the number at the specified base. /// The result is rounded down to the next integer. @@ -52,8 +59,7 @@ namespace etl }; //*************************************************************************** - ///\ingroup Math - /// Specialisation for N = 1 + // Specialisation for N = 1 //*************************************************************************** template struct log<1, BASE> @@ -65,8 +71,7 @@ namespace etl }; //*************************************************************************** - ///\ingroup Math - /// Specialisation for N = 0 + // Specialisation for N = 0 //*************************************************************************** template struct log<0, BASE> @@ -78,8 +83,8 @@ namespace etl }; //*************************************************************************** - ///\ingroup Math - /// The specialisation for base 2 logs. + ///\ingroup log + /// Calculates base 2 logs. //*************************************************************************** template struct Log2 @@ -91,8 +96,8 @@ namespace etl }; //*************************************************************************** - ///\ingroup Math - /// The specialisation for base 10 logs. + ///\ingroup log + /// Calculates base 10 logs. //*************************************************************************** template struct Log10 diff --git a/queue.h b/queue.h index 9c33056a..d26744a4 100644 --- a/queue.h +++ b/queue.h @@ -34,7 +34,7 @@ SOFTWARE. #include "IQueue.h" //***************************************************************************** -///\defgroup Queue Queue +///\defgroup queue queue /// A First-in / first-out queue with the capacity defined at compile time, /// written in the STL style. ///\ingroup Containers @@ -43,7 +43,7 @@ SOFTWARE. namespace etl { //*************************************************************************** - ///\ingroup Queue + ///\ingroup queue /// A fixed capacity queue. /// This queue does not support concurrent access by different threads. /// \tparam T The type this queue should support. diff --git a/queue_base.h b/queue_base.h index 39d8ad71..69835263 100644 --- a/queue_base.h +++ b/queue_base.h @@ -33,16 +33,14 @@ SOFTWARE. #include "exception.h" -///\defgroup Queue Queue -///\ingroup Containers +///\defgroup queue Queue +///\ingroup containers namespace etl { #ifdef ETL_USE_EXCEPTIONS //*************************************************************************** - ///\ingroup Queue - ///\brief This is the base for all queues. - ///\detail This is the base for all queues. Instances or references to this type should never need to be created. + ///\ingroup queue /// The base class for queue exceptions. //*************************************************************************** class queue_exception : public exception @@ -56,7 +54,7 @@ namespace etl }; //*************************************************************************** - ///\ingroup Queue + ///\ingroup queue /// The exception thrown when the queue is full. //*************************************************************************** class queue_full_exception : public queue_exception @@ -64,13 +62,13 @@ namespace etl public: queue_full_exception() - : queue_exception("queue full exception") + : queue_exception("queue full") { } }; //*************************************************************************** - ///\ingroup Queue + ///\ingroup queue /// The exception thrown when the queue is empty. //*************************************************************************** class queue_empty_exception : public queue_exception @@ -78,14 +76,14 @@ namespace etl public: queue_empty_exception() - : queue_exception("queue empty exception") + : queue_exception("queue empty") { } }; #endif //*************************************************************************** - ///\ingroup Queue + ///\ingroup queue /// A fixed capacity queue written in the STL style. /// \warning This queue cannot be used for concurrent access from multiple threads. //***************************************************************************