Discover Packages 
           
        
          
            github.com/pion/webrtc/v4 
           
        
          
            pkg 
           
        
        
          
            null
           
          
            
               
             
          
        
       
     
   
  
    
  
    
       
     
    
    
      package 
    
    
      
        
           
         
      
    
   
    
      
  
    
      
  
    
      Version:  
        v4.0.10
     
    
      Opens a new window with list of versions in this module.
    
    
    
   
      
  
    Published: Feb 17, 2025
   
      
  
    License: MIT 
      
    
   
  
    Opens a new window with license information.
  
      
        
  
    
      Imports:  0
     
   
  
    Opens a new window with list of imports.
  
        
  
    
       Imported by:  0
     
   
  
    Opens a new window with list of known importers.
  
      
    
   
  
  
    
   
 
    
      
    
    
  
  
    
      
        
          Documentation 
        
       
     
  
 
    
  
    
      
      
        
          
  
    
       
      Documentation
      ¶ 
     
    
  
    
  
    
      
        
 
    
Package null is used to represent values where the 0 value is significant
This pattern is common in ECMAScript, this allows us to maintain a matching API
 
  
  
  
  
  
  
  
      
  
  
    
    
    
      type Bool struct {
	Valid bool 
 	Bool  bool 
 } 
     
  Bool is used to represent a bool that may be null.
    
  
  
    
    
    
  NewBool turns a bool into a valid null.Bool.
  
   
  
     
      
  
  
    
    
    
      type Byte struct {
	Valid bool 
 	Byte  byte 
 } 
     
  Byte is used to represent a byte that may be null.
    
  
  
    
    
    
  NewByte turns a byte into a valid null.Byte.
  
   
  
     
      
  
  
    
    
    
  Complex128 is used to represent a complex128 that may be null.
    
  
  
    
    
    
  NewComplex128 turns a complex128 into a valid null.Complex128.
  
   
  
     
      
  
  
    
    
    
  Complex64 is used to represent a complex64 that may be null.
    
  
  
    
    
    
  NewComplex64 turns a complex64 into a valid null.Complex64.
  
   
  
     
      
  
  
    
    
    
  Float32 is used to represent a float32 that may be null.
    
  
  
    
    
    
  NewFloat32 turns a float32 into a valid null.Float32.
  
   
  
     
      
  
  
    
    
    
  Float64 is used to represent a float64 that may be null.
    
  
  
    
    
    
  NewFloat64 turns a float64 into a valid null.Float64.
  
   
  
     
      
  
  
    
    
    
      type Int struct {
	Valid bool 
 	Int   int 
 } 
     
  Int is used to represent a int that may be null.
    
  
  
    
    
    
  NewInt turns a int into a valid null.Int.
  
   
  
     
      
  
  
    
    
    
  Int16 is used to represent a int16 that may be null.
    
  
  
    
    
    
  NewInt16 turns a int16 into a valid null.Int16.
  
   
  
     
      
  
  
    
    
    
  Int32 is used to represent a int32 that may be null.
    
  
  
    
    
    
  NewInt32 turns a int32 into a valid null.Int32.
  
   
  
     
      
  
  
    
    
    
  Int64 is used to represent a int64 that may be null.
    
  
  
    
    
    
  NewInt64 turns a int64 into a valid null.Int64.
  
   
  
     
      
  
  
    
    
    
      type Int8 struct {
	Valid bool 
 	Int8  int8 
 } 
     
  Int8 is used to represent a int8 that may be null.
    
  
  
    
    
    
  NewInt8 turns a int8 into a valid null.Int8.
  
   
  
     
      
  
  
    
    
    
      type Rune struct {
	Valid bool 
 	Rune  rune 
 } 
     
  Rune is used to represent a rune that may be null.
    
  
  
    
    
    
  NewRune turns a rune into a valid null.Rune.
  
   
  
     
      
  
  
    
    
    
  String is used to represent a string that may be null.
    
  
  
    
    
    
  NewString turns a string into a valid null.String.
  
   
  
     
      
  
  
    
    
    
      type Uint struct {
	Valid bool 
 	Uint  uint 
 } 
     
  Uint is used to represent a uint that may be null.
    
  
  
    
    
    
  NewUint turns a uint into a valid null.Uint.
  
   
  
     
      
  
  
    
    
    
  Uint16 is used to represent a uint16 that may be null.
    
  
  
    
    
    
  NewUint16 turns a uint16 into a valid null.Uint16.
  
   
  
     
      
  
  
    
    
    
  Uint32 is used to represent a uint32 that may be null.
    
  
  
    
    
    
  NewUint32 turns a uint32 into a valid null.Uint32.
  
   
  
     
      
  
  
    
    
    
  Uint64 is used to represent a uint64 that may be null.
    
  
  
    
    
    
  NewUint64 turns a uint64 into a valid null.Uint64.
  
   
  
     
      
  
  
    
    
    
  Uint8 is used to represent a uint8 that may be null.
    
  
  
    
    
    
  NewUint8 turns a uint8 into a valid null.Uint8.
  
   
  
       
      
     
   
        
      
      
        
  
    
       
      Source Files
      ¶ 
     
   
      
      
     
   
   Click to show internal directories. 
   Click to hide internal directories.