PSFramework

1.7.249

functions/utility/Compare-PSFArray.ps1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 function Compare-PSFArray
{
    <#
    .SYNOPSIS
        Compares two arrays.
     
    .DESCRIPTION
        Compares two arrays.
     
    .PARAMETER ReferenceObject
        The first array to compare with the second array.
     
    .PARAMETER DifferenceObject
        The second array to compare with the first array.
     
    .PARAMETER OrderSpecific
        Makes the comparison order specific.
        By default, the command does not care for the order the objects are stored in.
     
    .PARAMETER Quiet
        Rather than returning a delta report object, return a single truth statement:
        - $true if the two arrays are equal
        - $false if the two arrays are NOT equal.
     
    .EXAMPLE
        PS C:\> Compare-PSFArray -ReferenceObject $arraySource -DifferenceObject $arrayDestination -Quiet -OrderSpecific
 
        Compares the two sets of objects, and returns ...
        - $true if both sets contains the same objects in the same order
        - $false if they do not
    #>
    [Diagnostics.CodeAnalysis.SuppressMessageAttribute("PSUseOutputTypeCorrectly", "")]
    [CmdletBinding()]
    param (
        [Parameter(Mandatory = $true, Position = 0)]
        [object[]]
        $ReferenceObject,
        
        [Parameter(Mandatory = $true, Position = 1)]
        [object[]]
        $DifferenceObject,
        
        [switch]
        $OrderSpecific,
        
        [switch]
        $Quiet
    )
    
    process
    {
        #region Not Order Specific
        if (-not $OrderSpecific)
        {
            $delta = Compare-Object -ReferenceObject $ReferenceObject -DifferenceObject $DifferenceObject
            if ($delta)
            {
                if ($Quiet) { return $false }
                [PSCustomObject]@{
                    ReferenceObject  = $ReferenceObject
                    DifferenceObject = $DifferenceObject
                    Delta             = $delta
                    IsEqual             = $false
                }
                return
            }
            else
            {
                if ($Quiet) { return $true }
                [PSCustomObject]@{
                    ReferenceObject  = $ReferenceObject
                    DifferenceObject = $DifferenceObject
                    Delta             = $delta
                    IsEqual             = $true
                }
                return
            }
        }
        #endregion Not Order Specific
        
        #region Order Specific
        else
        {
            if ($Quiet -and ($ReferenceObject.Count -ne $DifferenceObject.Count)) { return $false }
            $result = [PSCustomObject]@{
                ReferenceObject  = $ReferenceObject
                DifferenceObject = $DifferenceObject
                Delta             = @()
                IsEqual             = $true
            }
            
            $maxCount = [math]::Max($ReferenceObject.Count, $DifferenceObject.Count)
            [System.Collections.ArrayList]$indexes = @()
            
            foreach ($number in (0 .. ($maxCount - 1)))
            {
                if ($number -ge $ReferenceObject.Count)
                {
                    $null = $indexes.Add($number)
                    continue
                }
                if ($number -ge $DifferenceObject.Count)
                {
                    $null = $indexes.Add($number)
                    continue
                }
                if ($ReferenceObject[$number] -ne $DifferenceObject[$number])
                {
                    if ($Quiet) { return $false }
                    $null = $indexes.Add($number)
                    continue
                }
            }
            
            if ($indexes.Count -gt 0)
            {
                $result.IsEqual = $false
                $result.Delta = $indexes.ToArray()
            }
            
            $result
        }
        #endregion Order Specific
    }
}