NAME

Net::IP::RangeCompare - Perl extension for IP Range Comparisons

SYNOPSIS

use Net::IP::RangeCompare;
my $obj=Net::IP::RangeCompare::Simple->new;

$obj->add_range('Tom','10.0.0.2 - 10.0.0.11');
$obj->add_range('Tom','10.0.0.32 - 10.0.0.66');
$obj->add_range('Tom','11/32');

$obj->add_range('Sally','10.0.0.7 - 10.0.0.12');
$obj->add_range('Sally','172.16/255.255.255');

$obj->add_range('Harry','192.168.2');
$obj->add_range('Harry','10.0.0.128/30');

$obj->compare_ranges; # optional

      while(my ($common,%row)=$obj->get_row) {
              print "\nCommon Range: ",$common,"\n";
              my $tom=$row{Tom};
              my $sally=$row{Sally};
              my $harry=$row{Harry};
              print "Tom: ",$tom
                      ,' '
                      ,($tom->missing ? 'not used' : 'in use')
                      ,"\n";

              print "Sally: ",$sally
                      ,' '
                      , ($sally->missing ? 'not used' : 'in use')
                      ,"\n";

              print "Harry: ",$harry,
                      ' '
                      ,($harry->missing ? 'not used' : 'in use')
                      ,"\n";
      }


Output: 

Common Range: 10.0.0.2 - 10.0.0.6
Tom: 10.0.0.2 - 10.0.0.11 in use
Sally: 10.0.0.2 - 10.0.0.6 not used
Harry: 10.0.0.2 - 10.0.0.127 not used

Common Range: 10.0.0.7 - 10.0.0.11
Tom: 10.0.0.2 - 10.0.0.11 in use
Sally: 10.0.0.7 - 10.0.0.12 in use
Harry: 10.0.0.2 - 10.0.0.127 not used

Common Range: 10.0.0.12 - 10.0.0.12
Tom: 10.0.0.12 - 10.0.0.31 not used
Sally: 10.0.0.7 - 10.0.0.12 in use
Harry: 10.0.0.2 - 10.0.0.127 not used

Common Range: 10.0.0.32 - 10.0.0.66
Tom: 10.0.0.32 - 10.0.0.66 in use
Sally: 10.0.0.13 - 172.15.255.255 not used
Harry: 10.0.0.2 - 10.0.0.127 not used

Common Range: 10.0.0.128 - 10.0.0.131
Tom: 10.0.0.67 - 10.255.255.255 not used
Sally: 10.0.0.13 - 172.15.255.255 not used
Harry: 10.0.0.128 - 10.0.0.131 in use

Common Range: 11.0.0.0 - 11.0.0.0
Tom: 11.0.0.0 - 11.0.0.0 in use
Sally: 10.0.0.13 - 172.15.255.255 not used
Harry: 10.0.0.132 - 192.168.1.255 not used

Common Range: 172.16.0.0 - 172.16.0.255
Tom: 11.0.0.1 - 192.168.2.0 not used
Sally: 172.16.0.0 - 172.16.0.255 in use
Harry: 10.0.0.132 - 192.168.1.255 not used

Common Range: 172.16.1.0 - 192.168.1.255
Tom: 11.0.0.1 - 192.168.2.0 not used
Sally: 172.16.1.0 - 192.168.2.0 not used
Harry: 10.0.0.132 - 192.168.1.255 not used

Common Range: 192.168.2.0 - 192.168.2.0
Tom: 11.0.0.1 - 192.168.2.0 not used
Sally: 172.16.1.0 - 192.168.2.0 not used
Harry: 192.168.2.0 - 192.168.2.0 in use

DESCRIPTION

Fast scalable ip range aggregation and summary tool kit. Find intersections across multiple lists of IP ranges, fast.

Although similar in functionality to Net::CIDR::Compare, Net::Netmask and NetAddr::IP, Net::IP::RangeCompare is a completely range driven ip management and evaluation tool allowing more flexibility and scalability when dealing with the somewhat organic nature of IP-Ranges.

If you have a large number of ipv4 ranges and need to inventory lists of ranges for intersections, this is the Module for you!

DEPENDENCIES

As of version 4.02 Net::IP::RangeCompare Depends on the following modules:

Data::Range::Compare - Framework for calculating range intersections

Data::IPV4::Range::Parse - Perl extension parsing ipv4 ranges

Export list

Net::IP::RangeCompare does not export anything by default. The functions listed in this section can be imported by using the standard import syntax.

Import example:

use Net::IP::RangeCompare qw(consolidate_ranges sort_ranges);

To import all functions:

use Net::IP::RangeCompare qw(:ALL);

Helper functions :HELPER

  use Net::IP::RangeCompare qw(:HELPER);

  Imports the following:

          hostmask
          ip_to_int
          int_to_ip
          cidr_to_int
	  size_from_mask 
	  base_int 
	  broadcast_int 
	  cmp_int
	  sort_quad
	  sort_notations
  	  add_one
          sub_one

Overlap functions :OVERLAP

  use Net::IP::RangeCompare qw(:OVERLAP);

  Imports the following:

          get_common_range
          get_overlapping_range
	  grep_overlap
	  grep_non_overlap

Sort Functions :SORT

use Net::IP::RangeCompare qw(:SORT);

Imports the following:

        sort_ranges
        sort_largest_first_int_first
        sort_smallest_last_int_first
        sort_largest_last_int_first
        sort_smallest_first_int_first

Range processing functions :PROCESS

  use Net::IP::RangeCompare qw(:PROCESS);

  Imports the following:

          consolidate_ranges
          fill_missing_ranges
          range_start_end_fill
          range_compare
          compare_row
	  range_compare_force_cidr

OO Methods

This section defines the OO interfaces.

my $obj=Net::IP::RangeCompare->parse_new_range( '10/32' );

Creates a new Net::IP::RangeCompare object.

Examples:
$obj=Net::IP::RangeCompare->parse_new_range('10');
$obj=Net::IP::RangeCompare->parse_new_range('10.0.0.0 - 10.0.0.0');
$obj=Net::IP::RangeCompare->parse_new_range('10/32');
$obj=Net::IP::RangeCompare->parse_new_range('10/255.255.255');
$obj=Net::IP::RangeCompare->parse_new_range('10.0.0.0','10.0.0.0');

All of the above will parse the same range: 
  10.0.0.0 - 10.0.0.0
Notes:
  When using a list syntax: start and end range are
  assumed.  Using 2 arguments will not work as 
  expected when the list consists of ip and cidr.
Example:
  $obj=Net::IP::RangeCompare->parse_new_range('10.0.0.0',32);
  Returns: 10.0.0.0 - 32.0.0.0

  $obj=Net::IP::RangeCompare->parse_new_range(
    '10.0.0.0'
    ,'255.255.255.255
  );
  Returns: 10.0.0.0 - 32.0.0.0

  If you wish to create an object from cidr boundaries
  pass the argument as a single string.
Example:
  $obj=Net::IP::RangeCompare->parse_new_range(
    '10.0.0.0'.'/'.32
  );
  Returns: 10.0.0.0 - 10.0.0.0
Example: 
  $obj=Net::IP::RangeCompare->parse_new_range(
    '10.0.0.0'
    .'/'
    .'255.255.255.255
  );
  Returns: 10.0.0.0 - 10.0.0.0

my $obj=Net::IP::RangeCompare->new(0,1);

Creates a new Net::IP::RangeCompare object from 2 integers. See: Net::IP::RangeCompare->parse_new_range for a more useful OO constructor.
my $int=$obj->first_int;

Returns the integer that represents the start of the ip range
my $int=$obj->last_int;

Returns the integer that represents the end of the ip range
my $first_ip=$obj->first_ip;

Returns the first ip in the range.
my $last_ip=$obj->last_ip;

Returns the last ip in the range;
if($obj->missing) { .. do something } else { .. do something else }

If the value is true, this range is a filler representing an ip range that was not found.
if($obj->generated) { .. do something } else { .. do something else }

If the value is true, this range was created internally by one of the following functions: fill_missing_ranges, range_start_end_fill, consolidate_ranges.

When a range is $obj->generated but not $obj->missing it represents a collection of overlapping ranges.
my $last_error=$obj->error;

Returns the last error
my $total_ips=$obj->size;

Returns the total number of ipv4 addresses in this range.
$obj->data->{some_tag}=$some_data; # sets the data
my $some_data=$obj->data->{some_tag}; # gets the data

Returns an anonymous hash that can be used to tag this block with your data.
my $notation=$obj->notation;

Returns the ip range in the standard "x.x.x.x - x.x.x.x" notation.

Simply calling the Net::IP::RangeCompare object in a string context will return the same output as using the $obj->notation Method. Example:
```
my $obj=Net::IP::RangeCompare->parse_new_range( '10.0.0.1/255' );
print $obj,"\n";
print $obj->notation,"\n";

Output:

10.0.0.0 - 10.255.255.255
10.0.0.0 - 10.255.255.255
```

my $cidr_notation=$obj->get_cidr_notation;

Returns string representing all the cidrs in a given range.

Example a:

  $obj=Net::IP::RangeCompare->parse_new_range('10/32');
  print $obj->get_cidr_notation,"\n"

  Output:
  10.0.0.0/32


Example b:
  $obj=Net::IP::RangeCompare->parse_new_range(
    '10.0.0.0 10.0.0.4'
  );
  print $obj->get_cidr_notation,"\n"

  Output:
  10.0.0.0/30, 10.0.0.4/32

if($obj->overlap('10/32') { }

Returns true if the 2 ranges overlap. Strings are auto converted to Net::IP::RangeCompare Objects on the fly.
my $int=$obj->next_first_int;

Fetches the starting integer for the next range;
my $int=$obj->previous_last_int;

Returns an integer representing the first interger of the pervious range.

my ($range,$cidr_nota,$next)=$obj->get_first_cidr;

Iterator function:

Returns the following
$range
  First range on a cidr boundary in $obj
$cidr_ntoa
  String containing the cidr format
$next
  Next Range to process, undef when complete

Example:

my $obj=Net::IP::RangeCompare->parse_new_range(
  '10.0.0.0 - 10.0.0.4'
);
my ($first,$cidr_note,$next)=$obj->get_first_cidr;

Example:

# this gets every range
my $obj=Net::IP::RangeCompare->parse_new_range(
  '10.0.0.0 - 10.0.0.4'
);
my ($first,$cidr,$next);
$next=$obj;
while($next) {
  ($first,$cidr,$next)=$next->get_first_cidr;
  print "Range Notation: ",$first,"\n";
  print "Cidr Notation : ",$cidr,"\n";
}

Output:
Range Notation: 10.0.0.0 - 10.0.0.3
Cidr Notation : 10.0.0.0/30
Range Notation: 10.0.0.4 - 10.0.0.4
Cidr Notation : 10.0.0.4/32

if($obj->is_cidr) { do something }

This function can be used to check if a range represents a single cidr.
if($obj->is_range) { do something }

This function can be used to check if a range contains multiple cidrs.

my $ipv4=$obj->nth(0);

Returns the nth ipv4 address in the range. Returns undef if the ip is out of the range.

Example:

my $obj=Net::IP::RangeCompare->parse_new_range('10/24');
my $base=$obj->nth(0);
my $broadcast=$obj->nth(255);

print $base,"\n";
print $broadcast,"\n";

Output
10.0.0.0
10.0.0.255

my @list=$obj->base_list_int;

Returns each start address as an integer for every cidr boundry.
my @list=$obj->base_list_ip;

Returns each start address as an ipv4 quad for every cidr boundry.
my @list=$obj->broadcast_list_ip;

Returns each end address as an ipv4 quad for every cidr boundry.
my @list=$obj->broadcast_list_int;

Returns each end address as an integer for every cidr boundry.
my @list=$obj->netmask_int_list;

Returns a netmask as an integer for every cidr in this range.
my @list=$obj->netmask_list;

Returns a netmask as an ip in quad notation for every cidr in this range.
my $sub=$obj->enumerate(1-32);

my $sub=$obj->enumerate;

Returns an anonymous subroutine that can be used to iterate through the entire range. The iterator can be used to safely walk any range even 0/0. Each iteration of $sub returns a new Net::IP::RangeCompare object or undef on completion.

The default cidr to iterate by is "32".

Example:

my $obj=Net::IP::RangeCompare->parse_new_range('10/30');
my $sub=$obj->enumerate;
while(my $range=$sub->()) {
  print $range,"\n"
}
Output:
10.0.0.0 - 10.0.0.0
10.0.0.1 - 10.0.0.1
10.0.0.2 - 10.0.0.2
10.0.0.3 - 10.0.0.3

$sub=$obj->enumerate(31);
while(my $range=$sub->()) {
  print $range,"\n"
}
Output:
10.0.0.0 - 10.0.0.1
10.0.0.2 - 10.0.0.3

my $sub=$obj->enumerate_size;

my $sub=$obj->enumerate_size(2);

Returns an anonymous subruteen that can be used to walk the current range in ingrements of x ips. Default value is 1.

Example:

my $obj=Net::IP::RangeCompare->parse_new_range( '10.0.0.0 - 10.0.0.6' );

my $sub=$obj->enumerate_size;

print "Inc by 1\n";
while(my $range=$sub->()) {
  print $range,"\n";
}

print "Inc by 3\n";
$sub=$obj->enumerate_size(3);
while(my $range=$sub->()) {
  print $range,"\n";
}

Output:
Inc by 1
10.0.0.0 - 10.0.0.1
10.0.0.2 - 10.0.0.3
10.0.0.4 - 10.0.0.5
10.0.0.6 - 10.0.0.6

Inc by 3
10.0.0.0 - 10.0.0.3
10.0.0.4 - 10.0.0.6

if($obj_a->cmp_first_int($obj_b)==0) { }

This function compares the first integer of 2 Net::IP::RangeCompare objects.

Returns

0  if $obj_a->first_int==$obj_b->last_int
-1 if $obj_a->first_int<$obj_b->first_int
1  if $obj_a->first_int>$obj_b->first_int

if($obj_a->cmp_last_int($obj_b)==0) { }

This function compares the last integer of 2 Net::IP::RangeCompare objects.

Returns
```
0  if $obj_a->last_int==$obj_b->last_int
-1 if $obj_a->last_int<$obj_b->last_int
1  if $obj_a->last_int>$obj_b->last_int
```
if($obj->contiguous_check($obj_next)) { do something }

Returns true if $obj_next dirrectly follows $obj
my $mod=$obj->mod_first_int($x);

Returns the modulus if the first integer and $x.

my $cmp=$obj_a->cmp_ranges($obj_b);

Compares 2 Net::IP::RangeCompare objects

Returns 0 if both ranges have the same first_int and last_int
Returns -1 if $obj_a->first_int starts before $obj_b->first_int
  or if $obj_a and $obj_b have the same first_int
     and $obj_a ends before $obj_b
Returns 1 if $obj_a->first_int starts after $obj_b->first_int
  or if $obj_a and $obj_b have the same first_int
     and $obj_a ends after $obj_b

Helper functions

my $integer=ip_to_int('0.0.0.0');

Converts an ipv4 address to an integer usable by perl
my $ipv4=int_to_ip(11);

Converts integers to ipv4 notation
my $hostmask=hostmask($netmask);

Given a netmask (as an integer) returns the corresponding hostmask.
my $int=add_one($var);

Returns $var incremented by 1
my $int=sub_one($var);

Returns $var decremented by 1
my $size=size_from_mask($mask);

Given a netmask ( as an integer ) returns the size of the network.
item my $base=base_int($ip_int,$mask_int);

Returns the base address of an ip as an integer given the proper mask as an integer.
my $broadcast=broadcast_int($ip_int,$ip_mask);

Returns the broadcast address as an integer given the proper mask and ip as integers.
my $netmask=cidr_to_int(32);

Given a cidr(0 - 32) return the netmask as an integer.
my $reult=cmp_int(1,2);

Returns the same thing as: 1 <=> 2
my @sorted_quads=sort sort_quad qw(10.0.0.1 10.0.0.10);

Sorts ipv4 quad strings in ascending order
my @sorted=sort sort_notations qw(10/24 10/22 9/8 );

Sorts ip notations in ascending order. Carp::croak is called if a ranged cannot be parsed.

Example:
```
my @sorted=sort sort_notations qw(10/24 10/22 9/8  8-11 );
print join("\n",@sorted),"\n";

Output:

8-11
9/8
10/24
10/22
```

Overlap functions

This section documents the functions used to find and compute range overlaps.

my $obj=get_common_range([$range_a,$range_b]);

Returns an Net::IP::RangeCompare object representing the smallest common overlapping range. Returns undef if no overlapping range is found.
my $obj=get_overlapping_range( [ $range_a,$range_b, $range_c] );

Returns an Net::IP::RangeCompare object that overlaps with the provided ranges
my $list=grep_overlap('10/24',\@list_of_ranges);
my $list=grep_overlap($range,\@list_of_ranges);

Returns an array refrence of ranges that overlap with this range.
my $list=grep_non_overlap('10/24',\@list_of_ranges);
my $list=grep_non_overlap($range,\@list_of_ranges);

Returns an array refrence of ranges that do not overlap with this range.

Sort Functions

This section describes the order in wich each function sorts a list of Net::IP::RangeCompare objects.

All functions in this section use the following syntax modle

Example: my @list=sort sort_largest_last_int_first @netiprangecomapre_objects;

my @list=sort sort_largest_last_int_first @list;

Sorts by $obj->last_int in descending order
my @list=sort sort_smallest_first_int_first @list;

Sorts by $obj->first_int in ascending order
my @list=sort sort_smallest_last_int_first @list;

Sorts by $obj->last_int in ascending order

my @list=sort sort_largest_first_int_first @list;

Sorts by $obj->first_int in descending order

sort_ranges
  Sorts by 
    $obj->first_int in ascending order
    or
    $obj->last_int in descending order

Net::IP::RangeCompare list processing functions

This section covers how to use the list and list of lists processing functions that do the actual comparison work.

my $list_ref=consolidate_ranges( \@list_of_netiprangeobjects );

Given a list reference of Net::IP::RangeCompare Objects: Returns a consolidated list reference representing the input ranges. The list input reference is depleted during the consolidation process. If you want to keep the original list of ranges, make a copy of the list before passing it to consolidate_ranges.

Example:

my $list=[];
push @$list,Net::IP::RangeCompare->parse_new_range('10/32');
push @$list,Net::IP::RangeCompare->parse_new_range('10/32');
push @$list,Net::IP::RangeCompare->parse_new_range('10/30');
push @$list,Net::IP::RangeCompare->parse_new_range('10/24');
push @$list,Net::IP::RangeCompare->parse_new_range('8/24');

my $list=consolidate_ranges($list);

while(my $range=shift @$list) {
  print $range,"\n";
}

OUTPUT
8.0.0.0 - 8.0.0.255
10.0.0.0 - 10.0.0.255

my $ranges=fill_missing_ranges( \@consolidated_list );
my $ranges=fill_missing_ranges( \@list, consolidate_ranges=>1 );

my $ranges=fill_missing_ranges( \@list, consolidate_ranges=>0 );

Given a consolidated list of Net::IP::RangeCompare objects, it returns a contiguous list reference of ranges. All ranges generated by the fill_missing_ranges are $obj->missing==true and $obj->generated==true.

Optional argument(s)

consolidate_ranges=>0||1
  Default value 1 
    Performs a consolidate_ranges on each list
  Disalble consolidation 0
    Skips the consolidate_ranges call

Example:

my $list=[];
push @$list,Net::IP::RangeCompare->parse_new_range('10/32');
push @$list,Net::IP::RangeCompare->parse_new_range('10/32');
push @$list,Net::IP::RangeCompare->parse_new_range('10/30');
push @$list,Net::IP::RangeCompare->parse_new_range('10/24');
push @$list,Net::IP::RangeCompare->parse_new_range('8/24');

$list=fill_missing_ranges($list);

while(my $range=shift @$list) {
  print $range,"\n";
}

OUTPUT
8.0.0.0 - 8.0.0.255
8.0.1.0 - 9.255.255.255
10.0.0.0 - 10.0.0.255

my $list=range_start_end_fill([$list_a,$list_b]);

Given a list of lists of Net::IP::RangeCompare objects returns a list of list objects with the same start and end ranges.

Example:

my $list_a=[];
my $list_b=[];

push @$list_a,Net::IP::RangeCompare->parse_new_range('10/24');
push @$list_a,Net::IP::RangeCompare->parse_new_range('10/25');
push @$list_a,Net::IP::RangeCompare->parse_new_range('11/24');

push @$list_b,Net::IP::RangeCompare->parse_new_range('7/24');
push @$list_b,Net::IP::RangeCompare->parse_new_range('8/24');

#to prevent strange results always consolidate first
$list_a=consolidate_ranges($list_a);
$list_b=consolidate_ranges($list_b);

my $list_of_lists=range_start_end_fill([$list_a,$list_b]);
my @name=qw(a b);
foreach my $list (@$list_of_lists) {
  my $name=shift @name;
  print '$list_',$name,"\n";
  foreach my $range (@$list) {
      print $range,"\n";
  }
}

Output:

$list_a
7.0.0.0 - 9.255.255.255
10.0.0.0 - 10.0.0.255
11.0.0.0 - 11.0.0.255
$list_b
7.0.0.0 - 7.0.0.255
8.0.0.0 - 8.0.0.255
8.0.1.0 - 11.0.0.255

Notes:

To prevent strange results make sure each list is 
consolidated first.

my $sub=range_compare( [ $list_a, $list_b, $list_c] );
my $sub=range_compare( [ $list_a, $list_b, $list_c], consolidate_ranges=>1 );

my $sub=range_compare( [ $list_a, $list_b, $list_c ], consolidate_ranges=>0 );

Compares a list of lists of Net::IP::RangeCompare objects

Optional argument(s)

consolidate_ranges=>0||1
  Default value 1 
    Performs a consolidate_ranges on each list
  Disalble consolidation 0
    Skips the consolidate_ranges call

Example:

my $list_a=[];
my $list_b=[];
my $list_c=[];

push @$list_a, Net::IP::RangeCompare->parse_new_range(
  '10.0.0.0 - 10.0.0.1'
  );
push @$list_a, Net::IP::RangeCompare->parse_new_range(
  '10.0.0.2 - 10.0.0.5'
  );


push @$list_b, Net::IP::RangeCompare->parse_new_range(
  '10.0.0.0 - 10.0.0.1'
  );
push @$list_b, Net::IP::RangeCompare->parse_new_range(
  '10.0.0.3 - 10.0.0.4'
  );
push @$list_b, Net::IP::RangeCompare->parse_new_range(
  '10.0.0.4 - 10.0.0.5'
  );

push @$list_c, Net::IP::RangeCompare->parse_new_range(
  '10.0.0.0 - 10.0.0.1'
  );
push @$list_c, Net::IP::RangeCompare->parse_new_range(
  '10.0.0.3 - 10.0.0.3'
  );
push @$list_c, Net::IP::RangeCompare->parse_new_range(
  '10.0.0.4 - 10.0.0.5'
  );

my $sub=range_compare([  $list_a,$list_b,$list_c] );

while(my ($common,$range_a,$range_b,$range_c)=$sub->()) {
  print "\nCommon Range: ",$common,"\n";
  print 'a: ',$range_a
    ,' '
    ,($range_a->missing ? 'not used' : 'in use')
    ,"\n";
  print 'b: ',$range_b
    ,' '
    ,($range_b->missing ? 'not used' : 'in use')
    ,"\n";
  print 'c: ',$range_c
    ,' '
    ,($range_c->missing ? 'not used' : 'in use')
    ,"\n";
}

Output:

Common Range: 10.0.0.0 - 10.0.0.1
a: 10.0.0.0 - 10.0.0.1 in use
b: 10.0.0.0 - 10.0.0.1 in use
c: 10.0.0.0 - 10.0.0.1 in use

Common Range: 10.0.0.2 - 10.0.0.2
a: 10.0.0.2 - 10.0.0.5 in use
b: 10.0.0.2 - 10.0.0.2 not used
c: 10.0.0.2 - 10.0.0.2 not used

Common Range: 10.0.0.3 - 10.0.0.3
a: 10.0.0.2 - 10.0.0.5 in use
b: 10.0.0.3 - 10.0.0.5 in use
c: 10.0.0.3 - 10.0.0.3 in use

Common Range: 10.0.0.4 - 10.0.0.5
a: 10.0.0.2 - 10.0.0.5 in use
b: 10.0.0.3 - 10.0.0.5 in use
c: 10.0.0.4 - 10.0.0.5 in use

my $sub=range_compare_force_cidr(\@ranges,%args);

my $sub=range_compare_force_cidr(\@ranges);

This is just a wrapper for range_compare, that returns the common ranges on cidr boundries, along with the cidr notation.

Example:

my $ranges=[
  [
    map { $package_name->new(@{$_}[0,1]) }
      [0,8]
  ]

  ,[
    map { $package_name->new(@{$_}[0,1]) }
      [0,1]
      ,[3,4]
      ,[4,5]
  ]

  ,[
    map { $package_name->new(@{$_}[0,1]) }
      [0,1]
      ,[3,3]
      ,[4,5]
  ]
];

my $sub=range_compare_force_cidr($ranges);
while(my ($common,$cidr,@cols)=$sub->()) {
      print $common,', ',$cidr,"\n";
      print join(', ',@cols),"\n\n";
      last if --$max<=0;
      ++$count;
}

Output

0.0.0.0 - 0.0.0.1, 0.0.0.0/31
0.0.0.0 - 0.0.0.8, 0.0.0.0 - 0.0.0.1, 0.0.0.0 - 0.0.0.1

0.0.0.2 - 0.0.0.2, 0.0.0.2/32
0.0.0.0 - 0.0.0.8, 0.0.0.2 - 0.0.0.2, 0.0.0.2 - 0.0.0.2

0.0.0.3 - 0.0.0.3, 0.0.0.3/32
0.0.0.0 - 0.0.0.8, 0.0.0.3 - 0.0.0.5, 0.0.0.3 - 0.0.0.3

0.0.0.4 - 0.0.0.5, 0.0.0.4/31
0.0.0.0 - 0.0.0.8, 0.0.0.3 - 0.0.0.5, 0.0.0.4 - 0.0.0.5

0.0.0.6 - 0.0.0.7, 0.0.0.6/31
0.0.0.0 - 0.0.0.8, 0.0.0.6 - 0.0.0.8, 0.0.0.6 - 0.0.0.8

0.0.0.8 - 0.0.0.8, 0.0.0.8/32
0.0.0.0 - 0.0.0.8, 0.0.0.6 - 0.0.0.8, 0.0.0.6 - 0.0.0.8

($row,$cols,$next,$missing)=compare_row($data,undef,undef);

($row,$cols,$next,$missing)=compare_row($data,$row,$cols);

This function is used to iterate over a list of consolidated Net::IP::RangeCompare Objects. see: "range_compare" for a more practical iterator method.

Example:

my $ranges=[
  [
    map { Net::IP::RangeCompare->parse_new_range(@{$_}[0,1]) }
      [qw(10.0.0 10.0.0.1)]
      ,[qw(10.0.0.2 10.0.0.5)]
  ]

  ,[
    map { Net::IP::RangeCompare->parse_new_range(@{$_}[0,1]) }
      [qw(10.0.0.0 10.0.0.1)]
      ,[qw(10.0.0.3 10.0.0.4)]
      ,[qw(10.0.0.4 10.0.0.5)]
  ]

  ,[
    map { Net::IP::RangeCompare->parse_new_range(@{$_}[0,1]) }
      [qw(10.0.0.0 10.0.0.1)]
      ,[qw(10.0.0.3 10.0.0.3)]
      ,[qw(10.0.0.4 10.0.0.5)]
  ]
];

my $data=[];
# consolidate ranges -- prevents odd results
while(my $list=shift @$ranges) {
  push @$data,consolidate_ranges($list);
}
my ($row,$cols,$next);
while(1) {
  ($row,$cols,$next)=compare_row($data,$row,$cols);
  print join(', ',@$row),"\n";
  last unless $next;
}
OUTPUT:
10.0.0.0 - 10.0.0.1, 10.0.0.0 - 10.0.0.1, 10.0.0.0 - 10.0.0.1
10.0.0.2 - 10.0.0.5, 10.0.0.2 - 10.0.0.2, 10.0.0.2 - 10.0.0.2
10.0.0.2 - 10.0.0.5, 10.0.0.3 - 10.0.0.5, 10.0.0.3 - 10.0.0.3
10.0.0.2 - 10.0.0.5, 10.0.0.3 - 10.0.0.5, 10.0.0.4 - 10.0.0.5

Net::IP::RangeCompare::Simple

Helper Class that wraps the features of Net::IP::RangeCompare into a single easy to use OO instance.

my $obj=Net::IP::RangeCompare::Simple->new;

Creates new instance of Net::IP::RangeCompare::Simple->new;
$obj->add_range(key,range);

Adds a new "range" to the "key". The command will croak if the key is undef or the range cannot be parsed.

Example:
```
$obj->add_range('Tom','10.0.0.2 - 10.0.0.11');
```
my $list_ref=$obj->get_ranges_by_key(key);

Given a key, return the list reference. Returns undef if the key does not exist. Carp::croak is called if the key is undef.
$obj->compare_ranges;
$obj->compare_ranges(key,key,key);

Used to initialize or re-initialize the compare process. When called with a key or a list of keys: The compare process excludes those columns.

Example:
```
Given ranges from: Tom, Sally, Harry, Bob

$obj->compare_ranges(qw(Bob Sally));

The resulting %row from $obj->get_row would only contain keys 
for Tom and Harry.
```
Notes: If %row would be empty during $obj->get_row function call will croak.

while(my ($common,%row)=$obj->get_row) { do something }

Returns the current row of the compare process.

$common
  Represents the common range between all of the
  source ranges in the current row.

%row
  Represents the consolidated range from the 
  relative source "key".

Notes:

This function will croak if no ranges have been
added to the Net::IP::RangeCompare::Simple object.

my @keys=$s->get_keys;

Returns the list of keys in this instance.

AUTHOR

Michael Shipper

COPYRIGHT

This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)

NAME

SYNOPSIS

DESCRIPTION

DEPENDENCIES

Export list

OO Methods

Helper functions

Overlap functions

Sort Functions

Net::IP::RangeCompare list processing functions

Net::IP::RangeCompare::Simple

AUTHOR

COPYRIGHT

SEE ALSO

Module Install Instructions