add GrB_ALL

Author: abhinavmehndiratta

src/Operations/Extract.jl

@@ -75,10 +75,10 @@ function GrB_Vector_extract(            # w<mask> = accum (w, u(I))
         mask::T,                        # optional mask for w, unused if NULL
         accum::U,                       # optional accum for z=accum(w,t)
         u::GrB_Vector,                  # first input:  vector u
-        I::Vector{X},                   # row indices
+        I::Y,                           # row indices
         ni::X,                          # number of row indices
         desc::V                         # descriptor for w and mask
-) where {T <: valid_vector_mask_types, U <: valid_accum_types, V <: valid_desc_types, X <: GrB_Index}
+) where {T <: valid_vector_mask_types, U <: valid_accum_types, V <: valid_desc_types, X <: GrB_Index, Y <: Union{Vector{X}, GrB_ALL_Type}}
 
     return GrB_Info(
                 ccall(
@@ -153,12 +153,12 @@ function GrB_Matrix_extract(            # C<Mask> = accum (C, A(I,J))
         Mask::T,                        # optional mask for C, unused if NULL
         accum::U,                       # optional accum for Z=accum(C,T)
         A::GrB_Matrix,                  # first input:  matrix A
-        I::Vector{X},                   # row indices
+        I::Y,                           # row indices
         ni::X,                          # number of row indices
-        J::Vector{X},                   # column indices
+        J::Y,                           # column indices
         nj::X,                          # number of column indices
         desc::V                         # descriptor for C, Mask, and A
-) where {T <: valid_matrix_mask_types, U <: valid_accum_types, V <: valid_desc_types, X <: GrB_Index}
+) where {T <: valid_matrix_mask_types, U <: valid_accum_types, V <: valid_desc_types, X <: GrB_Index, Y <: Union{Vector{X}, GrB_ALL_Type}}
 
     return GrB_Info(
                 ccall(
@@ -242,11 +242,11 @@ function GrB_Col_extract(               # w<mask> = accum (w, A(I,j))
         mask::T,                        # optional mask for w, unused if NULL
         accum::U,                       # optional accum for z=accum(w,t)
         A::GrB_Matrix,                  # first input:  matrix A
-        I::Vector{X},                   # row indices
+        I::Y,                           # row indices
         ni::X,                          # number of row indices
         j::X,                           # column index
         desc::V                         # descriptor for w, mask, and A
-) where {T <: valid_vector_mask_types, U <: valid_accum_types, V <: valid_desc_types, X <: GrB_Index}
+) where {T <: valid_vector_mask_types, U <: valid_accum_types, V <: valid_desc_types, X <: GrB_Index, Y <: Union{Vector{X}, GrB_ALL_Type}}
 
     return GrB_Info(
                 ccall(

src/Structures.jl

@@ -1,5 +1,6 @@
 import Base.show
 import Base.==
+import Base.pointer
 export GrB_Type, GrB_UnaryOp, GrB_BinaryOp, GrB_Monoid, GrB_Semiring,
        GrB_Vector, GrB_Matrix, GrB_Descriptor
 
@@ -8,52 +9,59 @@ abstract type GrB_Struct end
 mutable struct GrB_Type{T} <: GrB_Struct
     p::Ptr{Cvoid}
 end
-GrB_Type{T}() where T = GrB_Type{T}(Ptr{Cvoid}(0)) 
+GrB_Type{T}() where T = GrB_Type{T}(C_NULL) 
 Base.show(io::IO, ::GrB_Type{T}) where T = print("GrB_Type{" * string(T) * "}")
 
 mutable struct GrB_UnaryOp <: GrB_Struct
     p::Ptr{Cvoid}
 end
-GrB_UnaryOp() = GrB_UnaryOp(Ptr{Cvoid}(0))
+GrB_UnaryOp() = GrB_UnaryOp(C_NULL)
 Base.show(io::IO, ::GrB_UnaryOp) = print("GrB_UnaryOp")
 
 mutable struct GrB_BinaryOp <: GrB_Struct
     p::Ptr{Cvoid}
 end
-GrB_BinaryOp() = GrB_BinaryOp(Ptr{Cvoid}(0))
+GrB_BinaryOp() = GrB_BinaryOp(C_NULL)
 Base.show(io::IO, ::GrB_BinaryOp) = print("GrB_BinaryOp")
 
 mutable struct GrB_Monoid <: GrB_Struct
     p::Ptr{Cvoid}
 end
-GrB_Monoid() = GrB_Monoid(Ptr{Cvoid}(0))
+GrB_Monoid() = GrB_Monoid(C_NULL)
 Base.show(io::IO, ::GrB_Monoid) = print("GrB_Monoid")
 
 mutable struct GrB_Semiring <: GrB_Struct
     p::Ptr{Cvoid}
 end
-GrB_Semiring() = GrB_Semiring(Ptr{Cvoid}(0))
+GrB_Semiring() = GrB_Semiring(C_NULL)
 Base.show(io::IO, ::GrB_Semiring) = print("GrB_Semiring")
 
 mutable struct GrB_Vector{T} <: GrB_Struct
     p::Ptr{Cvoid}
 end
-GrB_Vector{T}() where T = GrB_Vector{T}(Ptr{Cvoid}(0))
+GrB_Vector{T}() where T = GrB_Vector{T}(C_NULL)
 Base.show(io::IO, ::GrB_Vector{T}) where T = print("GrB_Vector{" * string(T) * "}")
 
 mutable struct GrB_Matrix{T} <: GrB_Struct
     p::Ptr{Cvoid}
 end
-GrB_Matrix{T}() where T = GrB_Matrix{T}(Ptr{Cvoid}(0))
+GrB_Matrix{T}() where T = GrB_Matrix{T}(C_NULL)
 Base.show(io::IO, ::GrB_Matrix{T}) where T = print("GrB_Matrix{" * string(T) * "}")
 
 mutable struct GrB_Descriptor <: GrB_Struct
     p::Ptr{Cvoid}
 end
-GrB_Descriptor() = GrB_Descriptor(Ptr{Cvoid}(0))
+GrB_Descriptor() = GrB_Descriptor(C_NULL)
 Base.show(io::IO, ::GrB_Descriptor) = print("GrB_Descriptor")
 
 struct GrB_NULL_Type
     p::Ptr{Cvoid} 
 end
-Base.show(io::IO, ::GrB_NULL_Type) = print("NULL")
+Base.show(io::IO, ::GrB_NULL_Type) = print("GrB_NULL")
+
+mutable struct GrB_ALL_Type
+    p::Ptr{Cvoid} 
+end
+Base.pointer(x::GrB_ALL_Type) = x.p
+Base.show(io::IO, ::GrB_ALL_Type) = print("GrB_ALL")
+

src/SuiteSparseGraphBLAS.jl

@@ -60,6 +60,8 @@ valid_accum_types = Union{GrB_BinaryOp, GrB_NULL_Type}
 valid_desc_types = Union{GrB_Descriptor, GrB_NULL_Type}
 
 const GrB_NULL = GrB_NULL_Type(C_NULL)
+const GrB_ALL = GrB_ALL_Type(C_NULL)
+
 const GrB_LNOT = GrB_UnaryOp()
 const GrB_LOR = GrB_BinaryOp(); const GrB_LAND = GrB_BinaryOp(); const GrB_LXOR = GrB_BinaryOp()
 const GxB_LOR_BOOL_MONOID = GrB_Monoid(); const GxB_LAND_BOOL_MONOID = GrB_Monoid()
@@ -79,6 +81,8 @@ function __init__()
         return unsafe_load(cglobal(x, Ptr{Cvoid}))
     end
 
+    GrB_ALL.p = load_global("GrB_ALL")
+
     #load global types
     for t in [Bool, Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Float32, Float64]
         type_suffix = suffix(t)
@@ -274,7 +278,10 @@ for s in instances(GrB_Desc_Value)
     @eval export $(Symbol(s))
 end
 
-# NULL
+# GrB_NULL
 export GrB_NULL
 
+# GrB_ALL
+export GrB_ALL
+
 end #end of module