.. _program_listing_file__tmp_ws_src_fastrtps_include_fastdds_rtps_common_LocatorList.hpp:

Program Listing for File LocatorList.hpp
========================================

|exhale_lsh| :ref:`Return to documentation for file <file__tmp_ws_src_fastrtps_include_fastdds_rtps_common_LocatorList.hpp>` (``/tmp/ws/src/fastrtps/include/fastdds/rtps/common/LocatorList.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   // Copyright 2021 Proyectos y Sistemas de Mantenimiento SL (eProsima).
   //
   // Licensed under the Apache License, Version 2.0 (the "License");
   // you may not use this file except in compliance with the License.
   // You may obtain a copy of the License at
   //
   //     http://www.apache.org/licenses/LICENSE-2.0
   //
   // Unless required by applicable law or agreed to in writing, software
   // distributed under the License is distributed on an "AS IS" BASIS,
   // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   // See the License for the specific language governing permissions and
   // limitations under the License.
   
   #ifndef _FASTDDS_RTPS_COMMON_LOCATORLIST_HPP_
   #define _FASTDDS_RTPS_COMMON_LOCATORLIST_HPP_
   
   #include <fastrtps/fastrtps_dll.h>
   
   #include <fastdds/rtps/common/Locator.h>
   #include <fastdds/rtps/common/LocatorsIterator.hpp>
   
   #include <vector>
   #include <cstdint>
   #include <cstring>
   #include <iomanip>
   #include <algorithm>
   
   namespace eprosima {
   namespace fastdds {
   namespace rtps {
   
   typedef std::vector<Locator>::iterator LocatorListIterator;
   typedef std::vector<Locator>::const_iterator LocatorListConstIterator;
   
   class Locators : public LocatorsIterator
   {
   public:
   
       Locators(
               const LocatorListConstIterator& it)
           : it_(it)
       {
       }
   
       Locators(
               const Locators& other)
           : it_(other.it_)
       {
       }
   
       LocatorsIterator& operator ++()
       {
           ++it_;
           return *this;
       }
   
       bool operator ==(
               const LocatorsIterator& other) const
       {
           return it_ == static_cast<const Locators&>(other).it_;
       }
   
       bool operator !=(
               const LocatorsIterator& other) const
       {
           return it_ != static_cast<const Locators&>(other).it_;
       }
   
       const Locator& operator *() const
       {
           return (*it_);
       }
   
   private:
   
       LocatorListConstIterator it_;
   };
   
   class LocatorList
   {
   public:
   
       using value_type = typename std::vector<Locator>::value_type;
   
       RTPS_DllAPI LocatorList()
       {
       }
   
       RTPS_DllAPI ~LocatorList()
       {
       }
   
       RTPS_DllAPI LocatorList(
               const LocatorList& list)
           : m_locators(list.m_locators)
       {
       }
   
       RTPS_DllAPI LocatorList(
               LocatorList&& list)
           : m_locators(std::move(list.m_locators))
       {
       }
   
       RTPS_DllAPI LocatorList& operator =(
               const LocatorList& list)
       {
           m_locators = list.m_locators;
           return *this;
       }
   
       RTPS_DllAPI LocatorList& operator =(
               LocatorList&& list)
       {
           m_locators = std::move(list.m_locators);
           return *this;
       }
   
       RTPS_DllAPI bool operator ==(
               const LocatorList& locator_list) const
       {
           if (locator_list.m_locators.size() == m_locators.size())
           {
               bool returnedValue = true;
   
               for (auto it = locator_list.m_locators.begin(); returnedValue &&
                       it != locator_list.m_locators.end(); ++it)
               {
                   returnedValue = false;
   
                   for (auto it2 = m_locators.begin(); !returnedValue && it2 != m_locators.end(); ++it2)
                   {
                       if (*it == *it2)
                       {
                           returnedValue = true;
                       }
                   }
               }
   
               return returnedValue;
           }
   
           return false;
       }
   
       RTPS_DllAPI LocatorListIterator begin()
       {
           return m_locators.begin();
       }
   
       RTPS_DllAPI LocatorListIterator end()
       {
           return m_locators.end();
       }
   
       RTPS_DllAPI LocatorListConstIterator begin() const
       {
           return m_locators.begin();
       }
   
       RTPS_DllAPI LocatorListConstIterator end() const
       {
           return m_locators.end();
       }
   
       RTPS_DllAPI size_t size() const
       {
           return m_locators.size();
       }
   
       RTPS_DllAPI LocatorList& assign(
               const LocatorList& list)
       {
           if (!(*this == list))
           {
               m_locators = list.m_locators;
           }
           return *this;
       }
   
       RTPS_DllAPI void clear()
       {
           return m_locators.clear();
       }
   
       RTPS_DllAPI void reserve(
               size_t num)
       {
           return m_locators.reserve(num);
       }
   
       RTPS_DllAPI void resize(
               size_t num)
       {
           return m_locators.resize(num);
       }
   
       RTPS_DllAPI void push_back(
               const Locator& loc)
       {
           bool already = false;
           for (LocatorListIterator it = this->begin(); it != this->end(); ++it)
           {
               if (loc == *it)
               {
                   already = true;
                   break;
               }
           }
           if (!already)
           {
               m_locators.push_back(loc);
           }
       }
   
       RTPS_DllAPI void push_back(
               const LocatorList& locList)
       {
           for (auto it = locList.m_locators.begin(); it != locList.m_locators.end(); ++it)
           {
               this->push_back(*it);
           }
       }
   
       RTPS_DllAPI bool empty() const
       {
           return m_locators.empty();
       }
   
       RTPS_DllAPI void erase(
               const Locator& loc)
       {
           auto it = std::find(m_locators.begin(), m_locators.end(), loc);
           if (it != m_locators.end())
           {
               m_locators.erase(it);
           }
       }
   
       FASTDDS_DEPRECATED_UNTIL(3, "eprosima::fastrtps::rtps::LocatorList::contains(const Locator&)",
               "Unused method.")
       RTPS_DllAPI bool contains(
               const Locator& loc)
       {
           for (LocatorListIterator it = this->begin(); it != this->end(); ++it)
           {
               if (IsAddressDefined(*it))
               {
                   if (loc == *it)
                   {
                       return true;
                   }
               }
               else
               {
                   if (loc.kind == (*it).kind && loc.port == (*it).port)
                   {
                       return true;
                   }
               }
           }
   
           return false;
       }
   
       RTPS_DllAPI bool isValid() const
       {
           for (LocatorListConstIterator it = this->begin(); it != this->end(); ++it)
           {
               if (!IsLocatorValid(*it))
               {
                   return false;
               }
           }
           return true;
       }
   
       RTPS_DllAPI void swap(
               LocatorList& locatorList)
       {
           this->m_locators.swap(locatorList.m_locators);
       }
   
       // Check if there are specific transport locators associated
       // the template parameter is the locator kind (e.g. LOCATOR_KIND_UDPv4)
       template<int kind> bool has_kind() const
       {
           for (auto& loc : m_locators)
           {
               if ( kind == loc.kind )
               {
                   return true;
               }
           }
   
           return false;
       }
   
   private:
   
       std::vector<Locator> m_locators;
   };
   
   inline std::ostream& operator <<(
           std::ostream& output,
           const LocatorList& locList)
   {
       output << "[";
       if (!locList.empty())
       {
           output << *(locList.begin());
           for (auto it = locList.begin() + 1; it != locList.end(); ++it)
           {
               output << "," << *it;
           }
       }
       else
       {
           output << "_";
       }
       output << "]";
       return output;
   }
   
   inline std::istream& operator >>(
           std::istream& input,
           LocatorList& locList)
   {
       std::istream::sentry s(input);
       locList = LocatorList();
   
       if (s)
       {
           char punct;
           Locator loc;
           std::ios_base::iostate excp_mask = input.exceptions();
   
           try
           {
               input.exceptions(excp_mask | std::ios_base::failbit | std::ios_base::badbit);
   
               // Get [
               input >> punct;
   
               while (punct != ']')
               {
                   input >> loc >> punct;
                   if (loc.kind != LOCATOR_KIND_INVALID)
                   {
                       locList.push_back(loc);
                   }
               }
           }
           catch (std::ios_base::failure& )
           {
               locList.clear();
               EPROSIMA_LOG_WARNING(LOCATOR_LIST, "Error deserializing LocatorList");
           }
   
           input.exceptions(excp_mask);
       }
   
       return input;
   }
   
   } // namespace rtps
   } // namespace fastdds
   } // namespace eprosima
   
   #endif /* _FASTDDS_RTPS_COMMON_LOCATORLIST_HPP_ */