Line data    Source code

       1             : /**
       2             : * @file      BList.cpp
       3             : * @copyright (c) 2014 by Petr Zemek (s3rvac@gmail.com) and contributors
       4             : * @license   BSD, see the @c LICENSE file for more details
       5             : * @brief     Implementation of the BList class.
       6             : */
       7             : 
       8             : #include "BList.h"
       9             : 
      10             : #include <cassert>
      11             : 
      12             : #include "BItemVisitor.h"
      13             : 
      14             : namespace bencoding {
      15             : 
      16             : /**
      17             : * @brief Constructs an empty list.
      18             : */
      19             : BList::BList() = default;
      20             : 
      21             : /**
      22             : * @brief Constructs a list containing the given @a items.
      23             : */
      24           2 : BList::BList(std::initializer_list<value_type> items):
      25           2 :     itemList(items) {}
      26             : 
      27             : /**
      28             : * @brief Creates and returns a new list.
      29             : */
      30          24 : std::unique_ptr<BList> BList::create() {
      31          24 :     return std::unique_ptr<BList>(new BList());
      32             : }
      33             : 
      34             : /**
      35             : * @brief Creates a returns a new list containing the given @a items.
      36             : */
      37           2 : std::unique_ptr<BList> BList::create(std::initializer_list<value_type> items) {
      38           2 :     return std::unique_ptr<BList>(new BList(items));
      39             : }
      40             : 
      41             : /**
      42             : * @brief Returns the number of items in the list.
      43             : */
      44           8 : BList::size_type BList::size() const {
      45           8 :     return itemList.size();
      46             : }
      47             : 
      48             : /**
      49             : * @brief Checks if the list is empty.
      50             : *
      51             : * @return @c true if the list is empty, @c false otherwise.
      52             : */
      53          17 : bool BList::empty() const {
      54          17 :     return itemList.empty();
      55             : }
      56             : 
      57             : /**
      58             : * @brief Appends the given item to the end of the list.
      59             : *
      60             : * @preconditions
      61             : *  - @a bItem is non-null
      62             : */
      63          28 : void BList::push_back(const value_type &bItem) {
      64          28 :     assert(bItem && "cannot add a null item to the list");
      65             : 
      66          28 :     itemList.push_back(bItem);
      67          28 : }
      68             : 
      69             : /**
      70             : * @brief Removes the last element of the list.
      71             : *
      72             : * References and iterators to the erased element are invalidated.
      73             : *
      74             : * @preconditions
      75             : *  - list is non-empty
      76             : */
      77           1 : void BList::pop_back() {
      78           1 :     assert(!empty() && "cannot call pop_back() on an empty list");
      79             : 
      80           1 :     itemList.pop_back();
      81           1 : }
      82             : 
      83             : /**
      84             : * @brief Returns a reference to the first item in the list.
      85             : *
      86             : * @preconditions
      87             : *  - list is non-empty
      88             : */
      89           5 : BList::reference BList::front() {
      90           5 :     assert(!empty() && "cannot call front() on an empty list");
      91             : 
      92           5 :     return itemList.front();
      93             : }
      94             : 
      95             : /**
      96             : * @brief Returns a constant reference to the first item in the list.
      97             : *
      98             : * @preconditions
      99             : *  - list is non-empty
     100             : */
     101           1 : BList::const_reference BList::front() const {
     102           1 :     assert(!empty() && "cannot call front() on an empty list");
     103             : 
     104           1 :     return itemList.front();
     105             : }
     106             : 
     107             : /**
     108             : * @brief Returns a reference to the last item in the list.
     109             : *
     110             : * @preconditions
     111             : *  - list is non-empty
     112             : */
     113           3 : BList::reference BList::back() {
     114           3 :     assert(!empty() && "cannot call back() on an empty list");
     115             : 
     116           3 :     return itemList.back();
     117             : }
     118             : 
     119             : /**
     120             : * @brief Returns a constant reference to the last item in the list.
     121             : *
     122             : * @preconditions
     123             : *  - list is non-empty
     124             : */
     125           1 : BList::const_reference BList::back() const {
     126           1 :     assert(!empty() && "cannot call back() on an empty list");
     127             : 
     128           1 :     return itemList.back();
     129             : }
     130             : 
     131             : /**
     132             : * @brief Returns an iterator to the beginning of the list.
     133             : */
     134           6 : BList::iterator BList::begin() {
     135           6 :     return itemList.begin();
     136             : }
     137             : 
     138             : /**
     139             : * @brief Returns an iterator to the end of the list.
     140             : */
     141           6 : BList::iterator BList::end() {
     142           6 :     return itemList.end();
     143             : }
     144             : 
     145             : /**
     146             : * @brief Returns a constant iterator to the beginning of the list.
     147             : */
     148           2 : BList::const_iterator BList::begin() const {
     149           2 :     return itemList.begin();
     150             : }
     151             : 
     152             : /**
     153             : * @brief Returns a constant iterator to the end of the list.
     154             : */
     155           2 : BList::const_iterator BList::end() const {
     156           2 :     return itemList.end();
     157             : }
     158             : 
     159             : /**
     160             : * @brief Returns a constant iterator to the beginning of the list.
     161             : */
     162           2 : BList::const_iterator BList::cbegin() const {
     163           2 :     return itemList.cbegin();
     164             : }
     165             : 
     166             : /**
     167             : * @brief Returns a constant iterator to the end of the list.
     168             : */
     169           2 : BList::const_iterator BList::cend() const {
     170           2 :     return itemList.cend();
     171             : }
     172             : 
     173           4 : void BList::accept(BItemVisitor *visitor) {
     174           4 :     visitor->visit(this);
     175           4 : }
     176             : 
     177             : } // namespace bencoding