github.com/urso/go-structform@v0.0.2/gotype/fold_map_inline.generated.go (about)

     1  // This file has been generated from 'fold_map_inline.yml', do not edit
     2  package gotype
     3  
     4  import (
     5  	"reflect"
     6  	"unsafe"
     7  )
     8  
     9  var _mapInlineMapping = map[reflect.Type]reFoldFn{
    10  	tBool:    foldMapInlineBool,
    11  	tString:  foldMapInlineString,
    12  	tUint:    foldMapInlineUint,
    13  	tUint8:   foldMapInlineUint8,
    14  	tUint16:  foldMapInlineUint16,
    15  	tUint32:  foldMapInlineUint32,
    16  	tUint64:  foldMapInlineUint64,
    17  	tInt:     foldMapInlineInt,
    18  	tInt8:    foldMapInlineInt8,
    19  	tInt16:   foldMapInlineInt16,
    20  	tInt32:   foldMapInlineInt32,
    21  	tInt64:   foldMapInlineInt64,
    22  	tFloat32: foldMapInlineFloat32,
    23  	tFloat64: foldMapInlineFloat64,
    24  }
    25  
    26  func getMapInlineByPrimitiveElem(t reflect.Type) reFoldFn {
    27  	if t == tInterface {
    28  		return foldMapInlineInterface
    29  	}
    30  	return _mapInlineMapping[t]
    31  }
    32  
    33  func foldMapInlineInterface(C *foldContext, v reflect.Value) (err error) {
    34  	ptr := unsafe.Pointer(v.Pointer())
    35  	if ptr == nil {
    36  		return nil
    37  	}
    38  
    39  	m := *((*map[string]interface{})(unsafe.Pointer(&ptr)))
    40  	for k, v := range m {
    41  		if err = C.OnKey(k); err != nil {
    42  			return err
    43  		}
    44  		if err = foldInterfaceValue(C, v); err != nil {
    45  			return err
    46  		}
    47  	}
    48  	return
    49  }
    50  
    51  func foldMapInlineBool(C *foldContext, v reflect.Value) (err error) {
    52  	ptr := unsafe.Pointer(v.Pointer())
    53  	if ptr == nil {
    54  		return nil
    55  	}
    56  
    57  	m := *((*map[string]bool)(unsafe.Pointer(&ptr)))
    58  	for k, v := range m {
    59  		if err = C.OnKey(k); err != nil {
    60  			return err
    61  		}
    62  		if err = C.OnBool(v); err != nil {
    63  			return err
    64  		}
    65  	}
    66  	return
    67  }
    68  
    69  func foldMapInlineString(C *foldContext, v reflect.Value) (err error) {
    70  	ptr := unsafe.Pointer(v.Pointer())
    71  	if ptr == nil {
    72  		return nil
    73  	}
    74  
    75  	m := *((*map[string]string)(unsafe.Pointer(&ptr)))
    76  	for k, v := range m {
    77  		if err = C.OnKey(k); err != nil {
    78  			return err
    79  		}
    80  		if err = C.OnString(v); err != nil {
    81  			return err
    82  		}
    83  	}
    84  	return
    85  }
    86  
    87  func foldMapInlineUint(C *foldContext, v reflect.Value) (err error) {
    88  	ptr := unsafe.Pointer(v.Pointer())
    89  	if ptr == nil {
    90  		return nil
    91  	}
    92  
    93  	m := *((*map[string]uint)(unsafe.Pointer(&ptr)))
    94  	for k, v := range m {
    95  		if err = C.OnKey(k); err != nil {
    96  			return err
    97  		}
    98  		if err = C.OnUint(v); err != nil {
    99  			return err
   100  		}
   101  	}
   102  	return
   103  }
   104  
   105  func foldMapInlineUint8(C *foldContext, v reflect.Value) (err error) {
   106  	ptr := unsafe.Pointer(v.Pointer())
   107  	if ptr == nil {
   108  		return nil
   109  	}
   110  
   111  	m := *((*map[string]uint8)(unsafe.Pointer(&ptr)))
   112  	for k, v := range m {
   113  		if err = C.OnKey(k); err != nil {
   114  			return err
   115  		}
   116  		if err = C.OnUint8(v); err != nil {
   117  			return err
   118  		}
   119  	}
   120  	return
   121  }
   122  
   123  func foldMapInlineUint16(C *foldContext, v reflect.Value) (err error) {
   124  	ptr := unsafe.Pointer(v.Pointer())
   125  	if ptr == nil {
   126  		return nil
   127  	}
   128  
   129  	m := *((*map[string]uint16)(unsafe.Pointer(&ptr)))
   130  	for k, v := range m {
   131  		if err = C.OnKey(k); err != nil {
   132  			return err
   133  		}
   134  		if err = C.OnUint16(v); err != nil {
   135  			return err
   136  		}
   137  	}
   138  	return
   139  }
   140  
   141  func foldMapInlineUint32(C *foldContext, v reflect.Value) (err error) {
   142  	ptr := unsafe.Pointer(v.Pointer())
   143  	if ptr == nil {
   144  		return nil
   145  	}
   146  
   147  	m := *((*map[string]uint32)(unsafe.Pointer(&ptr)))
   148  	for k, v := range m {
   149  		if err = C.OnKey(k); err != nil {
   150  			return err
   151  		}
   152  		if err = C.OnUint32(v); err != nil {
   153  			return err
   154  		}
   155  	}
   156  	return
   157  }
   158  
   159  func foldMapInlineUint64(C *foldContext, v reflect.Value) (err error) {
   160  	ptr := unsafe.Pointer(v.Pointer())
   161  	if ptr == nil {
   162  		return nil
   163  	}
   164  
   165  	m := *((*map[string]uint64)(unsafe.Pointer(&ptr)))
   166  	for k, v := range m {
   167  		if err = C.OnKey(k); err != nil {
   168  			return err
   169  		}
   170  		if err = C.OnUint64(v); err != nil {
   171  			return err
   172  		}
   173  	}
   174  	return
   175  }
   176  
   177  func foldMapInlineInt(C *foldContext, v reflect.Value) (err error) {
   178  	ptr := unsafe.Pointer(v.Pointer())
   179  	if ptr == nil {
   180  		return nil
   181  	}
   182  
   183  	m := *((*map[string]int)(unsafe.Pointer(&ptr)))
   184  	for k, v := range m {
   185  		if err = C.OnKey(k); err != nil {
   186  			return err
   187  		}
   188  		if err = C.OnInt(v); err != nil {
   189  			return err
   190  		}
   191  	}
   192  	return
   193  }
   194  
   195  func foldMapInlineInt8(C *foldContext, v reflect.Value) (err error) {
   196  	ptr := unsafe.Pointer(v.Pointer())
   197  	if ptr == nil {
   198  		return nil
   199  	}
   200  
   201  	m := *((*map[string]int8)(unsafe.Pointer(&ptr)))
   202  	for k, v := range m {
   203  		if err = C.OnKey(k); err != nil {
   204  			return err
   205  		}
   206  		if err = C.OnInt8(v); err != nil {
   207  			return err
   208  		}
   209  	}
   210  	return
   211  }
   212  
   213  func foldMapInlineInt16(C *foldContext, v reflect.Value) (err error) {
   214  	ptr := unsafe.Pointer(v.Pointer())
   215  	if ptr == nil {
   216  		return nil
   217  	}
   218  
   219  	m := *((*map[string]int16)(unsafe.Pointer(&ptr)))
   220  	for k, v := range m {
   221  		if err = C.OnKey(k); err != nil {
   222  			return err
   223  		}
   224  		if err = C.OnInt16(v); err != nil {
   225  			return err
   226  		}
   227  	}
   228  	return
   229  }
   230  
   231  func foldMapInlineInt32(C *foldContext, v reflect.Value) (err error) {
   232  	ptr := unsafe.Pointer(v.Pointer())
   233  	if ptr == nil {
   234  		return nil
   235  	}
   236  
   237  	m := *((*map[string]int32)(unsafe.Pointer(&ptr)))
   238  	for k, v := range m {
   239  		if err = C.OnKey(k); err != nil {
   240  			return err
   241  		}
   242  		if err = C.OnInt32(v); err != nil {
   243  			return err
   244  		}
   245  	}
   246  	return
   247  }
   248  
   249  func foldMapInlineInt64(C *foldContext, v reflect.Value) (err error) {
   250  	ptr := unsafe.Pointer(v.Pointer())
   251  	if ptr == nil {
   252  		return nil
   253  	}
   254  
   255  	m := *((*map[string]int64)(unsafe.Pointer(&ptr)))
   256  	for k, v := range m {
   257  		if err = C.OnKey(k); err != nil {
   258  			return err
   259  		}
   260  		if err = C.OnInt64(v); err != nil {
   261  			return err
   262  		}
   263  	}
   264  	return
   265  }
   266  
   267  func foldMapInlineFloat32(C *foldContext, v reflect.Value) (err error) {
   268  	ptr := unsafe.Pointer(v.Pointer())
   269  	if ptr == nil {
   270  		return nil
   271  	}
   272  
   273  	m := *((*map[string]float32)(unsafe.Pointer(&ptr)))
   274  	for k, v := range m {
   275  		if err = C.OnKey(k); err != nil {
   276  			return err
   277  		}
   278  		if err = C.OnFloat32(v); err != nil {
   279  			return err
   280  		}
   281  	}
   282  	return
   283  }
   284  
   285  func foldMapInlineFloat64(C *foldContext, v reflect.Value) (err error) {
   286  	ptr := unsafe.Pointer(v.Pointer())
   287  	if ptr == nil {
   288  		return nil
   289  	}
   290  
   291  	m := *((*map[string]float64)(unsafe.Pointer(&ptr)))
   292  	for k, v := range m {
   293  		if err = C.OnKey(k); err != nil {
   294  			return err
   295  		}
   296  		if err = C.OnFloat64(v); err != nil {
   297  			return err
   298  		}
   299  	}
   300  	return
   301  }