identifiers.hpp

Go to the documentation of this file.

/*PGR-GNU*****************************************************************
 
FILE: identifiers.hpp
 
Generated with Template by:
Copyright (c) 2015 pgRouting developers
Mail: [email protected]
 
Function's developer:
Copyright (c) 2016 Rohith Reddy
Mail:
 
------
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 ********************************************************************PGR-GNU*/
 
#ifndef INCLUDE_CPP_COMMON_IDENTIFIERS_HPP_
#define INCLUDE_CPP_COMMON_IDENTIFIERS_HPP_
#pragma once
 
#include <set>
#include <algorithm>
#include <iterator>
#include <sstream>
#include <iostream>
#include <stdexcept>
 
/* TODO(vicky)
 * compiler check that type T is a integral type
 */
 
template <typename T>
class Identifiers {
 public:
    typedef typename std::set<T>::iterator iterator;
    typedef typename std::set<T>::const_iterator const_iterator;
 
 
 
    Identifiers<T>() = default;
    Identifiers<T>(const Identifiers<T>&) = default;
    explicit Identifiers<T>(const std::set<T>& data) {
        m_ids = data;
    }
 
    /* @brief initializes with {0 ~ number - 1}
     *
     * @params [in] number
     */
    explicit Identifiers<T>(const size_t number) {
      std::generate_n(std::inserter(m_ids, m_ids.end()), number, [&]{ return m_ids.size(); });
    }
 
 
 
    size_t size() const {return m_ids.size(); }
    inline bool empty() const {return m_ids.empty(); }
    inline T front() const {return *m_ids.begin();}
    inline T back() const {return *m_ids.end();}
    const_iterator begin() const {return m_ids.begin();}
    const_iterator end() const {return m_ids.end();}
 
    inline void pop_front() {m_ids.erase(m_ids.begin());}
 
    inline void clear() {m_ids.clear();}
    iterator begin() {return m_ids.begin();}
    iterator end() {return m_ids.end();}
 
 
 private:
    std::set<T> m_ids;
 
 public:
 
    bool has(const T other) const {
        return (m_ids.find(other) != m_ids.end());
    }
 
 
 
    bool operator==(const Identifiers<T> &rhs) const {
        return m_ids.size() == rhs.m_ids.size() && std::equal(m_ids.begin(), m_ids.end(), rhs.m_ids.begin());
    }
 
 
    friend Identifiers<T> operator +(
            const Identifiers<T> &lhs,
            const Identifiers<T> &rhs) {
        Identifiers<T> union_ids(lhs);
        union_ids += rhs;
        return union_ids;
    }
 
 
    Identifiers<T>& operator +=(
            const Identifiers<T> &other) {
        m_ids.insert(other.m_ids.begin(), other.m_ids.end());
        return *this;
    }
 
    Identifiers<T>& operator +=(const T &element) {
        m_ids.insert(element);
        return *this;
    }
 
 
 
 
 
    friend Identifiers<T> operator *(
                const Identifiers<T> &lhs,
                const Identifiers<T> &rhs) {
            std::set<T> result;
            std::set_intersection(
                    lhs.m_ids.begin(), lhs.m_ids.end(),
                    rhs.m_ids.begin(), rhs.m_ids.end(),
                    std::inserter(result, result.begin()));
            return Identifiers<T>(result);
        }
 
 
    Identifiers<T>& operator *=(
            const Identifiers<T> &other) {
        *this = *this * other;
        return *this;
    }
 
 
    Identifiers<T>& operator *=(const T &element) {
        if (has(element)) {
            m_ids.clear();
            m_ids.insert(element);
        } else {
            m_ids.clear();
        }
        return *this;
    }
 
 
 
 
    /* \brief set DIFFERENCE set
     *
     * @param[in] lhs Identifiers
     * @param[in] rhs Identifiers
     */
    friend
        Identifiers<T> operator -(
                const Identifiers<T> &lhs,
                const Identifiers<T> &rhs) {
            std::set<T> result;
            std::set_difference(
                    lhs.m_ids.begin(), lhs.m_ids.end(),
                    rhs.m_ids.begin(), rhs.m_ids.end(),
                    std::inserter(result, result.begin()));
            return Identifiers<T>(result);
        }
 
 
 
 
    Identifiers<T>& operator -=(const Identifiers<T> &other) {
        *this = *this - other;
        return *this;
    }
 
 
    Identifiers<T>& operator -=(const T &element) {
            m_ids.erase(element);
        return *this;
    }
 
 
    friend
        std::ostream&
        operator<<(std::ostream& os, const Identifiers<T>& identifiers) {
            os << "{";
            for (auto identifier : identifiers.m_ids) {
                os << identifier << ", ";
            }
            os << "}";
            return os;
        }
};
 
#endif  // INCLUDE_CPP_COMMON_IDENTIFIERS_HPP_