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

     1  // This file has been generated from 'unfold_lookup_go.yml', do not edit
     2  package gotype
     3  
     4  import (
     5  	"reflect"
     6  	"unsafe"
     7  )
     8  
     9  func lookupGoTypeUnfolder(to interface{}) (unsafe.Pointer, ptrUnfolder) {
    10  	switch ptr := to.(type) {
    11  	case *interface{}:
    12  		return unsafe.Pointer(ptr), newUnfolderIfc()
    13  	case *[]interface{}:
    14  		return unsafe.Pointer(ptr), newUnfolderArrIfc()
    15  	case *map[string]interface{}:
    16  		return unsafe.Pointer(ptr), newUnfolderMapIfc()
    17  
    18  	case *bool:
    19  		return unsafe.Pointer(ptr), newUnfolderBool()
    20  	case *[]bool:
    21  		return unsafe.Pointer(ptr), newUnfolderArrBool()
    22  	case *map[string]bool:
    23  		return unsafe.Pointer(ptr), newUnfolderMapBool()
    24  
    25  	case *string:
    26  		return unsafe.Pointer(ptr), newUnfolderString()
    27  	case *[]string:
    28  		return unsafe.Pointer(ptr), newUnfolderArrString()
    29  	case *map[string]string:
    30  		return unsafe.Pointer(ptr), newUnfolderMapString()
    31  
    32  	case *uint:
    33  		return unsafe.Pointer(ptr), newUnfolderUint()
    34  	case *[]uint:
    35  		return unsafe.Pointer(ptr), newUnfolderArrUint()
    36  	case *map[string]uint:
    37  		return unsafe.Pointer(ptr), newUnfolderMapUint()
    38  
    39  	case *uint8:
    40  		return unsafe.Pointer(ptr), newUnfolderUint8()
    41  	case *[]uint8:
    42  		return unsafe.Pointer(ptr), newUnfolderArrUint8()
    43  	case *map[string]uint8:
    44  		return unsafe.Pointer(ptr), newUnfolderMapUint8()
    45  
    46  	case *uint16:
    47  		return unsafe.Pointer(ptr), newUnfolderUint16()
    48  	case *[]uint16:
    49  		return unsafe.Pointer(ptr), newUnfolderArrUint16()
    50  	case *map[string]uint16:
    51  		return unsafe.Pointer(ptr), newUnfolderMapUint16()
    52  
    53  	case *uint32:
    54  		return unsafe.Pointer(ptr), newUnfolderUint32()
    55  	case *[]uint32:
    56  		return unsafe.Pointer(ptr), newUnfolderArrUint32()
    57  	case *map[string]uint32:
    58  		return unsafe.Pointer(ptr), newUnfolderMapUint32()
    59  
    60  	case *uint64:
    61  		return unsafe.Pointer(ptr), newUnfolderUint64()
    62  	case *[]uint64:
    63  		return unsafe.Pointer(ptr), newUnfolderArrUint64()
    64  	case *map[string]uint64:
    65  		return unsafe.Pointer(ptr), newUnfolderMapUint64()
    66  
    67  	case *int:
    68  		return unsafe.Pointer(ptr), newUnfolderInt()
    69  	case *[]int:
    70  		return unsafe.Pointer(ptr), newUnfolderArrInt()
    71  	case *map[string]int:
    72  		return unsafe.Pointer(ptr), newUnfolderMapInt()
    73  
    74  	case *int8:
    75  		return unsafe.Pointer(ptr), newUnfolderInt8()
    76  	case *[]int8:
    77  		return unsafe.Pointer(ptr), newUnfolderArrInt8()
    78  	case *map[string]int8:
    79  		return unsafe.Pointer(ptr), newUnfolderMapInt8()
    80  
    81  	case *int16:
    82  		return unsafe.Pointer(ptr), newUnfolderInt16()
    83  	case *[]int16:
    84  		return unsafe.Pointer(ptr), newUnfolderArrInt16()
    85  	case *map[string]int16:
    86  		return unsafe.Pointer(ptr), newUnfolderMapInt16()
    87  
    88  	case *int32:
    89  		return unsafe.Pointer(ptr), newUnfolderInt32()
    90  	case *[]int32:
    91  		return unsafe.Pointer(ptr), newUnfolderArrInt32()
    92  	case *map[string]int32:
    93  		return unsafe.Pointer(ptr), newUnfolderMapInt32()
    94  
    95  	case *int64:
    96  		return unsafe.Pointer(ptr), newUnfolderInt64()
    97  	case *[]int64:
    98  		return unsafe.Pointer(ptr), newUnfolderArrInt64()
    99  	case *map[string]int64:
   100  		return unsafe.Pointer(ptr), newUnfolderMapInt64()
   101  
   102  	case *float32:
   103  		return unsafe.Pointer(ptr), newUnfolderFloat32()
   104  	case *[]float32:
   105  		return unsafe.Pointer(ptr), newUnfolderArrFloat32()
   106  	case *map[string]float32:
   107  		return unsafe.Pointer(ptr), newUnfolderMapFloat32()
   108  
   109  	case *float64:
   110  		return unsafe.Pointer(ptr), newUnfolderFloat64()
   111  	case *[]float64:
   112  		return unsafe.Pointer(ptr), newUnfolderArrFloat64()
   113  	case *map[string]float64:
   114  		return unsafe.Pointer(ptr), newUnfolderMapFloat64()
   115  
   116  	default:
   117  		return nil, nil
   118  	}
   119  }
   120  
   121  func lookupGoPtrUnfolder(t reflect.Type) ptrUnfolder {
   122  	switch t.Kind() {
   123  	case reflect.Interface:
   124  		return newUnfolderIfc()
   125  
   126  	case reflect.Bool:
   127  		return newUnfolderBool()
   128  
   129  	case reflect.String:
   130  		return newUnfolderString()
   131  
   132  	case reflect.Uint:
   133  		return newUnfolderUint()
   134  
   135  	case reflect.Uint8:
   136  		return newUnfolderUint8()
   137  
   138  	case reflect.Uint16:
   139  		return newUnfolderUint16()
   140  
   141  	case reflect.Uint32:
   142  		return newUnfolderUint32()
   143  
   144  	case reflect.Uint64:
   145  		return newUnfolderUint64()
   146  
   147  	case reflect.Int:
   148  		return newUnfolderInt()
   149  
   150  	case reflect.Int8:
   151  		return newUnfolderInt8()
   152  
   153  	case reflect.Int16:
   154  		return newUnfolderInt16()
   155  
   156  	case reflect.Int32:
   157  		return newUnfolderInt32()
   158  
   159  	case reflect.Int64:
   160  		return newUnfolderInt64()
   161  
   162  	case reflect.Float32:
   163  		return newUnfolderFloat32()
   164  
   165  	case reflect.Float64:
   166  		return newUnfolderFloat64()
   167  
   168  	case reflect.Slice:
   169  		et := t.Elem()
   170  		switch et.Kind() {
   171  		case reflect.Interface:
   172  			return newUnfolderArrIfc()
   173  
   174  		case reflect.Bool:
   175  			return newUnfolderArrBool()
   176  
   177  		case reflect.String:
   178  			return newUnfolderArrString()
   179  
   180  		case reflect.Uint:
   181  			return newUnfolderArrUint()
   182  
   183  		case reflect.Uint8:
   184  			return newUnfolderArrUint8()
   185  
   186  		case reflect.Uint16:
   187  			return newUnfolderArrUint16()
   188  
   189  		case reflect.Uint32:
   190  			return newUnfolderArrUint32()
   191  
   192  		case reflect.Uint64:
   193  			return newUnfolderArrUint64()
   194  
   195  		case reflect.Int:
   196  			return newUnfolderArrInt()
   197  
   198  		case reflect.Int8:
   199  			return newUnfolderArrInt8()
   200  
   201  		case reflect.Int16:
   202  			return newUnfolderArrInt16()
   203  
   204  		case reflect.Int32:
   205  			return newUnfolderArrInt32()
   206  
   207  		case reflect.Int64:
   208  			return newUnfolderArrInt64()
   209  
   210  		case reflect.Float32:
   211  			return newUnfolderArrFloat32()
   212  
   213  		case reflect.Float64:
   214  			return newUnfolderArrFloat64()
   215  
   216  		}
   217  
   218  	case reflect.Map:
   219  		if t.Key().Kind() != reflect.String {
   220  			return nil
   221  		}
   222  
   223  		et := t.Elem()
   224  		switch et.Kind() {
   225  		case reflect.Interface:
   226  			return newUnfolderMapIfc()
   227  
   228  		case reflect.Bool:
   229  			return newUnfolderMapBool()
   230  
   231  		case reflect.String:
   232  			return newUnfolderMapString()
   233  
   234  		case reflect.Uint:
   235  			return newUnfolderMapUint()
   236  
   237  		case reflect.Uint8:
   238  			return newUnfolderMapUint8()
   239  
   240  		case reflect.Uint16:
   241  			return newUnfolderMapUint16()
   242  
   243  		case reflect.Uint32:
   244  			return newUnfolderMapUint32()
   245  
   246  		case reflect.Uint64:
   247  			return newUnfolderMapUint64()
   248  
   249  		case reflect.Int:
   250  			return newUnfolderMapInt()
   251  
   252  		case reflect.Int8:
   253  			return newUnfolderMapInt8()
   254  
   255  		case reflect.Int16:
   256  			return newUnfolderMapInt16()
   257  
   258  		case reflect.Int32:
   259  			return newUnfolderMapInt32()
   260  
   261  		case reflect.Int64:
   262  			return newUnfolderMapInt64()
   263  
   264  		case reflect.Float32:
   265  			return newUnfolderMapFloat32()
   266  
   267  		case reflect.Float64:
   268  			return newUnfolderMapFloat64()
   269  
   270  		}
   271  
   272  	}
   273  
   274  	return nil
   275  }
   276  
   277  func lookupReflUnfolder(ctx *unfoldCtx, t reflect.Type) (reflUnfolder, error) {
   278  	if f := unfoldRegistry.find(t); f != nil {
   279  		return f, nil
   280  	}
   281  
   282  	f, err := buildReflUnfolder(ctx, t)
   283  	if err != nil {
   284  		return nil, err
   285  	}
   286  
   287  	unfoldRegistry.set(t, f)
   288  	return f, nil
   289  }
   290  
   291  func buildReflUnfolder(ctx *unfoldCtx, t reflect.Type) (reflUnfolder, error) {
   292  	// we always expect a pointer
   293  	bt := t.Elem()
   294  
   295  	switch bt.Kind() {
   296  	case reflect.Interface:
   297  		return unfolderReflIfc, nil
   298  
   299  	case reflect.Bool:
   300  		return unfolderReflBool, nil
   301  
   302  	case reflect.String:
   303  		return unfolderReflString, nil
   304  
   305  	case reflect.Uint:
   306  		return unfolderReflUint, nil
   307  
   308  	case reflect.Uint8:
   309  		return unfolderReflUint8, nil
   310  
   311  	case reflect.Uint16:
   312  		return unfolderReflUint16, nil
   313  
   314  	case reflect.Uint32:
   315  		return unfolderReflUint32, nil
   316  
   317  	case reflect.Uint64:
   318  		return unfolderReflUint64, nil
   319  
   320  	case reflect.Int:
   321  		return unfolderReflInt, nil
   322  
   323  	case reflect.Int8:
   324  		return unfolderReflInt8, nil
   325  
   326  	case reflect.Int16:
   327  		return unfolderReflInt16, nil
   328  
   329  	case reflect.Int32:
   330  		return unfolderReflInt32, nil
   331  
   332  	case reflect.Int64:
   333  		return unfolderReflInt64, nil
   334  
   335  	case reflect.Float32:
   336  		return unfolderReflFloat32, nil
   337  
   338  	case reflect.Float64:
   339  		return unfolderReflFloat64, nil
   340  
   341  	case reflect.Array:
   342  		return nil, errTODO()
   343  
   344  	case reflect.Ptr:
   345  		unfolderElem, err := lookupReflUnfolder(ctx, bt)
   346  		if err != nil {
   347  			return nil, err
   348  		}
   349  		return newUnfolderReflPtr(unfolderElem), nil
   350  
   351  	case reflect.Slice:
   352  		et := bt.Elem()
   353  		switch et.Kind() {
   354  		case reflect.Interface:
   355  			return unfolderReflArrIfc, nil
   356  
   357  		case reflect.Bool:
   358  			return unfolderReflArrBool, nil
   359  
   360  		case reflect.String:
   361  			return unfolderReflArrString, nil
   362  
   363  		case reflect.Uint:
   364  			return unfolderReflArrUint, nil
   365  
   366  		case reflect.Uint8:
   367  			return unfolderReflArrUint8, nil
   368  
   369  		case reflect.Uint16:
   370  			return unfolderReflArrUint16, nil
   371  
   372  		case reflect.Uint32:
   373  			return unfolderReflArrUint32, nil
   374  
   375  		case reflect.Uint64:
   376  			return unfolderReflArrUint64, nil
   377  
   378  		case reflect.Int:
   379  			return unfolderReflArrInt, nil
   380  
   381  		case reflect.Int8:
   382  			return unfolderReflArrInt8, nil
   383  
   384  		case reflect.Int16:
   385  			return unfolderReflArrInt16, nil
   386  
   387  		case reflect.Int32:
   388  			return unfolderReflArrInt32, nil
   389  
   390  		case reflect.Int64:
   391  			return unfolderReflArrInt64, nil
   392  
   393  		case reflect.Float32:
   394  			return unfolderReflArrFloat32, nil
   395  
   396  		case reflect.Float64:
   397  			return unfolderReflArrFloat64, nil
   398  
   399  		}
   400  
   401  		unfolderElem, err := lookupReflUnfolder(ctx, reflect.PtrTo(et))
   402  		if err != nil {
   403  			return nil, err
   404  		}
   405  		return newUnfolderReflSlice(unfolderElem), nil
   406  
   407  	case reflect.Map:
   408  		et := bt.Elem()
   409  		switch et.Kind() {
   410  		case reflect.Interface:
   411  			return unfolderReflMapIfc, nil
   412  
   413  		case reflect.Bool:
   414  			return unfolderReflMapBool, nil
   415  
   416  		case reflect.String:
   417  			return unfolderReflMapString, nil
   418  
   419  		case reflect.Uint:
   420  			return unfolderReflMapUint, nil
   421  
   422  		case reflect.Uint8:
   423  			return unfolderReflMapUint8, nil
   424  
   425  		case reflect.Uint16:
   426  			return unfolderReflMapUint16, nil
   427  
   428  		case reflect.Uint32:
   429  			return unfolderReflMapUint32, nil
   430  
   431  		case reflect.Uint64:
   432  			return unfolderReflMapUint64, nil
   433  
   434  		case reflect.Int:
   435  			return unfolderReflMapInt, nil
   436  
   437  		case reflect.Int8:
   438  			return unfolderReflMapInt8, nil
   439  
   440  		case reflect.Int16:
   441  			return unfolderReflMapInt16, nil
   442  
   443  		case reflect.Int32:
   444  			return unfolderReflMapInt32, nil
   445  
   446  		case reflect.Int64:
   447  			return unfolderReflMapInt64, nil
   448  
   449  		case reflect.Float32:
   450  			return unfolderReflMapFloat32, nil
   451  
   452  		case reflect.Float64:
   453  			return unfolderReflMapFloat64, nil
   454  
   455  		}
   456  
   457  		unfolderElem, err := lookupReflUnfolder(ctx, reflect.PtrTo(et))
   458  		if err != nil {
   459  			return nil, err
   460  		}
   461  		return newUnfolderReflMap(unfolderElem), nil
   462  
   463  	case reflect.Struct:
   464  		return createUnfolderReflStruct(ctx, t)
   465  
   466  	default:
   467  		return nil, errTODO()
   468  	}
   469  }