LocatorList.hpp

// 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 <fastdds/fastdds_dll.hpp>
 
#include <fastdds/rtps/common/Locator.hpp>
#include <fastdds/rtps/common/LocatorsIterator.hpp>
#include <fastdds/utils/collections/ResourceLimitedVector.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;
 
    FASTDDS_EXPORTED_API LocatorList()
    {
    }
 
    FASTDDS_EXPORTED_API ~LocatorList()
    {
    }
 
    FASTDDS_EXPORTED_API LocatorList(
            const LocatorList& list)
        : m_locators(list.m_locators)
    {
    }
 
    FASTDDS_EXPORTED_API LocatorList(
            LocatorList&& list)
        : m_locators(std::move(list.m_locators))
    {
    }
 
    FASTDDS_EXPORTED_API LocatorList& operator =(
            const LocatorList& list)
    {
        m_locators = list.m_locators;
        return *this;
    }
 
    FASTDDS_EXPORTED_API LocatorList& operator =(
            LocatorList&& list)
    {
        m_locators = std::move(list.m_locators);
        return *this;
    }
 
    FASTDDS_EXPORTED_API 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;
    }
 
    FASTDDS_EXPORTED_API bool operator !=(
            const LocatorList& locator_list) const
    {
        return !(*this == locator_list);
    }
 
    FASTDDS_EXPORTED_API LocatorListIterator begin()
    {
        return m_locators.begin();
    }
 
    FASTDDS_EXPORTED_API LocatorListIterator end()
    {
        return m_locators.end();
    }
 
    FASTDDS_EXPORTED_API LocatorListConstIterator begin() const
    {
        return m_locators.begin();
    }
 
    FASTDDS_EXPORTED_API LocatorListConstIterator end() const
    {
        return m_locators.end();
    }
 
    FASTDDS_EXPORTED_API size_t size() const
    {
        return m_locators.size();
    }
 
    FASTDDS_EXPORTED_API LocatorList& assign(
            const LocatorList& list)
    {
        if (!(*this == list))
        {
            m_locators = list.m_locators;
        }
        return *this;
    }
 
    FASTDDS_EXPORTED_API void clear()
    {
        return m_locators.clear();
    }
 
    FASTDDS_EXPORTED_API void reserve(
            size_t num)
    {
        return m_locators.reserve(num);
    }
 
    FASTDDS_EXPORTED_API void resize(
            size_t num)
    {
        return m_locators.resize(num);
    }
 
    FASTDDS_EXPORTED_API 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);
        }
    }
 
    FASTDDS_EXPORTED_API void push_back(
            const LocatorList& locList)
    {
        for (auto it = locList.m_locators.begin(); it != locList.m_locators.end(); ++it)
        {
            this->push_back(*it);
        }
    }
 
    FASTDDS_EXPORTED_API bool empty() const
    {
        return m_locators.empty();
    }
 
    FASTDDS_EXPORTED_API 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_EXPORTED_API bool isValid() const
    {
        for (LocatorListConstIterator it = this->begin(); it != this->end(); ++it)
        {
            if (!IsLocatorValid(*it))
            {
                return false;
            }
        }
        return true;
    }
 
    FASTDDS_EXPORTED_API 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;
    }
 
    // Copy the inner locator list to a ResourceLimitedVector locator list.
    FASTDDS_EXPORTED_API void copy_to(
            eprosima::fastdds::ResourceLimitedVector<Locator>& locator_list) const
    {
        for (auto& locator : m_locators)
        {
            locator_list.emplace_back(locator);
        }
    }
 
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;
}
 
using Locators = eprosima::fastdds::rtps::Locators;
using LocatorList_t = eprosima::fastdds::rtps::LocatorList;
 
} // namespace rtps
} // namespace fastdds
} // namespace eprosima
 
#endif // FASTDDS_RTPS_COMMON__LOCATORLIST_HPP