Limit-Type.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
<#
.SYNOPSIS
 
 
.DESCRIPTION
Long description
 
.PARAMETER Type
Parameter description
 
.PARAMETER Strict
If $True - only the type
otherwise check the type decedants
 
.EXAMPLE
 
 ls | Limit-Type -Type [FileSystemInfo] -Strict $false
 "a", 3, 5 | Limit-Type -TypeName "string"
 Import-FsStore "def" | Limit-Type -TypeName "ConcurrentDictionary```2[string,object]"
#>


filter Limit-Type {
    param (
 
     #[Parameter(Position = 0, ParameterSetName = 'Type')]
     [System.Type]$Type,
     #[Parameter(Position = 1, ParameterSetName = 'Type')]
     [bool]$Strict=$true,
 
     #[Parameter(Position = 0, ParameterSetName = 'TypeName')]
     [string]$TypeName
    )
    BEGIN
    {
    } 
    PROCESS
    {
         $argType = $_.GetType()
         
         #type name check
         if( -not [string]::IsNullOrWhitespace( $typeName) ) {
 
             $itemTypeName = $argType.Name
     
             if( $argType.IsGenericType) {
                 $itemTypeName += '['
                 foreach( $arg in $argType.GetGenericArguments()){
                     $itemTypeName += $arg.Name
                     $itemTypeName += ','
                 }
                 $itemTypeName = $itemTypeName.TrimEnd(",")
                 $itemTypeName += ']'
             }
 
             if( $Strict){
                 if([String]::Compare( $TypeName, $itemTypeName, $true) -eq 0 ) {
                     return $_
                 }
             }
             else{
                if(  $itemTypeName -like $TypeName ) {
                    return $_
                }
             }

         }
         else{
 
             if($Strict){
                 if( $argType -eq $Type ){
                     return $_
                 }
             }
             else {
                 if ( $Type.IsAssignableFrom( $_.GetType() ) ) {
                     return $_
                 }
             }
         }
    }
 }


 "a", 3, 5 |  Where-Type -TypeName "string"