gitlab.com/evatix-go/core@v1.3.55/coredata/corejson/deserializeFromResultTo.go (about)

     1  package corejson
     2  
     3  import "gitlab.com/evatix-go/core/errcore"
     4  
     5  type deserializeFromResultTo struct{}
     6  
     7  func (it deserializeFromResultTo) String(
     8  	jsonResult *Result,
     9  ) (line string, err error) {
    10  	err = Deserialize.Apply(jsonResult, &line)
    11  
    12  	return line, err
    13  }
    14  
    15  func (it deserializeFromResultTo) Bool(
    16  	jsonResult *Result,
    17  ) (isResult bool, err error) {
    18  	err = Deserialize.Apply(jsonResult, &isResult)
    19  
    20  	return isResult, err
    21  }
    22  
    23  func (it deserializeFromResultTo) Byte(
    24  	jsonResult *Result,
    25  ) (byteVal byte, err error) {
    26  	err = Deserialize.Apply(jsonResult, &byteVal)
    27  
    28  	return byteVal, err
    29  }
    30  
    31  func (it deserializeFromResultTo) ByteMust(
    32  	jsonResult *Result,
    33  ) byte {
    34  	result, err := it.Byte(jsonResult)
    35  
    36  	if err != nil {
    37  		panic(err)
    38  	}
    39  
    40  	return result
    41  }
    42  
    43  func (it deserializeFromResultTo) BoolMust(
    44  	jsonResult *Result,
    45  ) bool {
    46  	result, err := it.Bool(jsonResult)
    47  
    48  	if err != nil {
    49  		panic(err)
    50  	}
    51  
    52  	return result
    53  }
    54  
    55  func (it deserializeFromResultTo) StringMust(
    56  	jsonResult *Result,
    57  ) string {
    58  	result, err := it.String(jsonResult)
    59  
    60  	if err != nil {
    61  		panic(err)
    62  	}
    63  
    64  	return result
    65  }
    66  
    67  func (it deserializeFromResultTo) StringsMust(
    68  	jsonResult *Result,
    69  ) (lines []string) {
    70  	err := jsonResult.Deserialize(&lines)
    71  
    72  	if err != nil {
    73  		panic(err)
    74  	}
    75  
    76  	return lines
    77  }
    78  
    79  func (it deserializeFromResultTo) MapAnyItem(
    80  	jsonResult *Result,
    81  ) (mapAnyItem map[string]interface{}, err error) {
    82  	err = jsonResult.Deserialize(
    83  		&mapAnyItem)
    84  
    85  	return mapAnyItem, err
    86  }
    87  
    88  func (it deserializeFromResultTo) MapAnyItemMust(
    89  	jsonResult *Result,
    90  ) (mapAnyItem map[string]interface{}) {
    91  	err := jsonResult.Deserialize(
    92  		&mapAnyItem)
    93  
    94  	errcore.HandleErr(err)
    95  
    96  	return mapAnyItem
    97  }
    98  
    99  func (it deserializeFromResultTo) MapStringString(
   100  	jsonResult *Result,
   101  ) (mappedItems map[string]string, err error) {
   102  	err = jsonResult.Deserialize(
   103  		&mappedItems)
   104  
   105  	return mappedItems, err
   106  }
   107  
   108  func (it deserializeFromResultTo) MapStringStringMust(
   109  	jsonResult *Result,
   110  ) (mappedItems map[string]string) {
   111  	err := jsonResult.Deserialize(
   112  		&mappedItems)
   113  	errcore.HandleErr(err)
   114  
   115  	return mappedItems
   116  }
   117  
   118  func (it deserializeFromResultTo) ResultCollection(
   119  	jsonResult *Result,
   120  ) (*ResultsCollection, error) {
   121  	empty := NewResultsCollection.
   122  		Empty()
   123  	err := jsonResult.
   124  		Deserialize(empty)
   125  
   126  	if err == nil {
   127  		return empty, nil
   128  	}
   129  
   130  	// has error
   131  	return nil, err
   132  }
   133  
   134  func (it deserializeFromResultTo) ResultCollectionMust(
   135  	jsonResult *Result,
   136  ) *ResultsCollection {
   137  	rs, err := it.ResultCollection(jsonResult)
   138  	errcore.HandleErr(err)
   139  
   140  	return rs
   141  }
   142  
   143  func (it deserializeFromResultTo) ResultsPtrCollection(
   144  	jsonResult *Result,
   145  ) (*ResultsPtrCollection, error) {
   146  	empty := NewResultsPtrCollection.
   147  		Empty()
   148  	err := jsonResult.
   149  		Deserialize(empty)
   150  
   151  	if err == nil {
   152  		return empty, nil
   153  	}
   154  
   155  	// has error
   156  	return nil, err
   157  }
   158  
   159  func (it deserializeFromResultTo) ResultsPtrCollectionMust(
   160  	jsonResult *Result,
   161  ) *ResultsPtrCollection {
   162  	rs, err := it.ResultsPtrCollection(
   163  		jsonResult)
   164  	errcore.HandleErr(err)
   165  
   166  	return rs
   167  }
   168  
   169  func (it deserializeFromResultTo) Result(
   170  	jsonResultInput *Result,
   171  ) (jsonResult Result, err error) {
   172  	empty := Empty.ResultPtr()
   173  	err = jsonResultInput.
   174  		Deserialize(empty)
   175  
   176  	if err == nil {
   177  		return empty.NonPtr(), nil
   178  	}
   179  
   180  	// has error
   181  	return jsonResult, errcore.MergeErrors(
   182  		err,
   183  		jsonResult.MeaningfulError())
   184  }
   185  
   186  func (it deserializeFromResultTo) ResultMust(
   187  	jsonResultInput *Result,
   188  ) (jsonResult Result) {
   189  	jsonResult, err := it.Result(jsonResultInput)
   190  	errcore.MustBeEmpty(err)
   191  
   192  	return jsonResult
   193  }
   194  
   195  func (it deserializeFromResultTo) ResultPtr(
   196  	jsonResultInput *Result,
   197  ) (jsonResultPtr *Result, err error) {
   198  	jsonResult, err := it.Result(jsonResultInput)
   199  
   200  	return jsonResult.Ptr(), err
   201  }
   202  
   203  func (it deserializeFromResultTo) ResultPtrMust(
   204  	jsonResultInput *Result,
   205  ) (jsonResultPtr *Result) {
   206  	jsonResult, err := it.Result(jsonResultInput)
   207  	errcore.HandleErr(err)
   208  
   209  	return jsonResult.Ptr()
   210  }
   211  
   212  func (it deserializeFromResultTo) MapResults(
   213  	jsonResult *Result,
   214  ) (*MapResults, error) {
   215  	empty := NewMapResults.
   216  		Empty()
   217  	err := jsonResult.
   218  		Deserialize(empty)
   219  
   220  	if err == nil {
   221  		return empty, nil
   222  	}
   223  
   224  	// has error
   225  	return nil, err
   226  }
   227  
   228  func (it deserializeFromResultTo) Bytes(
   229  	jsonResult *Result,
   230  ) (nextDeserializedBytes []byte, err error) {
   231  	jsonResultOut, err := it.Result(jsonResult)
   232  
   233  	if err == nil {
   234  		return jsonResultOut.Bytes, jsonResultOut.MeaningfulError()
   235  	}
   236  
   237  	return jsonResultOut.Bytes, err
   238  }
   239  
   240  func (it deserializeFromResultTo) BytesMust(
   241  	jsonResult *Result,
   242  ) (nextDeserializedBytes []byte) {
   243  	nextDeserializedBytes, err := it.Bytes(jsonResult)
   244  	errcore.HandleErr(err)
   245  
   246  	return nextDeserializedBytes
   247  }
   248  
   249  func (it deserializeFromResultTo) MapResultsMust(
   250  	jsonResult *Result,
   251  ) *MapResults {
   252  	rs, err := it.MapResults(jsonResult)
   253  	errcore.HandleErr(err)
   254  
   255  	return rs
   256  }