ip_iterator.hpp

Go to the documentation of this file.

/**
 * @author: Daniel Fuchs
 * @contact: fuxeysolutions@gmail.com
 *
 * distributed under the MIT License (MIT).
 * Copyright (c) Daniel Fuchs
 *
 */
#pragma once
 
#include <algorithm>
 
 
class ipv4_Range {
public:
    class ipv4_Address {
    public:
 
        ipv4_Address() {
 
        }
 
        ipv4_Address(uint8_t p1, uint8_t p2, uint8_t p3, uint8_t p4) :
                ipv4_part1(p1), ipv4_part2(p2), ipv4_part3(p3), ipv4_part4(p4) {
            convertU8toU32();
        }
 
        std::string toString() const {
            return std::to_string(static_cast<int>(ipv4_part1)) + "." +
                   std::to_string(static_cast<int>(ipv4_part2)) + "." +
                   std::to_string(static_cast<int>(ipv4_part3)) + "." +
                   std::to_string(static_cast<int>(ipv4_part4));
        }
 
        bool operator==(const ipv4_Address &rhs) const {
            return ipv4 == rhs.ipv4;
        }
 
        bool operator>(const ipv4_Address &rhs) const {
            return ipv4 > rhs.ipv4;
        }
 
        bool operator<(const ipv4_Address &rhs) const {
            return ipv4 < rhs.ipv4;
        }
 
        ipv4_Address operator=(ipv4_Address &adr) {
            ipv4_Address newAdr(adr.ipv4_part1,
                                adr.ipv4_part2,
                                adr.ipv4_part3,
                                adr.ipv4_part4
            );
            return newAdr;
        }
 
        ipv4_Address operator++(int) {
            ipv4_Address i = *this;
            ipv4 += 1;
            convertU32toU8();
            return i;
        }
 
    private:
        uint8_t ipv4_part1;
        uint8_t ipv4_part2;
        uint8_t ipv4_part3;
        uint8_t ipv4_part4;
        uint32_t ipv4;
 
        void convertU32toU8() {
            ipv4_part1 = static_cast<uint8_t>(ipv4 >> 24);
            ipv4_part2 = static_cast<uint8_t>(ipv4 >> 16);
            ipv4_part3 = static_cast<uint8_t>(ipv4 >> 8);
            ipv4_part4 = static_cast<uint8_t>(ipv4);
 
        }
 
        void convertU8toU32() {
            ipv4 = (static_cast<uint32_t>(ipv4_part1) << 24) +
                   (static_cast<uint32_t>(ipv4_part2) << 16) +
                   (static_cast<uint32_t>(ipv4_part3) << 8) +
                   static_cast<uint32_t>(ipv4_part4);
        }
 
    };
 
 
    class iterator : public std::iterator<
            std::input_iterator_tag,
            ipv4_Address,
            ipv4_Address,
            const ipv4_Address *,
            ipv4_Address> {
 
        ipv4_Address start;
    public:
        explicit iterator(ipv4_Address startAdr) : start(startAdr) {}
 
        iterator &operator++() {
            start++;
            return *this;
        }
 
        bool operator!=(iterator other) const {
            return !(start == other.start);
        }
 
        bool operator==(iterator other) const {
            return start == other.start;
        }
 
        reference operator*() const { return start; }
    };
 
 
    ipv4_Range(ipv4_Address start, ipv4_Address end) : startAddress(start), endAddress(end) {
        validate();
    }
 
    iterator begin() {
        return iterator(startAddress);
    }
 
    iterator end() {
        return iterator(endAddress++);
    }
 
private:
    void validate() {
        if (startAddress == endAddress) {
            throw std::invalid_argument("start and end are equal");
        }
        if (startAddress > endAddress) {
            // ok
        } else {
            // switch
            ipv4_Address temp = startAddress;
            startAddress = endAddress;
            endAddress = temp;
        }
    }
 
 
    ipv4_Address startAddress;
    ipv4_Address endAddress;
 
 
};