github.com/coveo/gotemplate@v2.7.7+incompatible/collections/implementation/generic.go (about)

     1  package implementation
     2  
     3  import (
     4  	"github.com/coveo/gotemplate/collections"
     5  )
     6  
     7  // ListTypeName implementation of IGenericList for baseList
     8  type ListTypeName = baseList
     9  type baseIList = collections.IGenericList
    10  type baseList []interface{}
    11  
    12  func (l baseList) AsArray() []interface{}              { return []interface{}(l) }
    13  func (l baseList) Cap() int                            { return cap(l) }
    14  func (l baseList) Capacity() int                       { return cap(l) }
    15  func (l baseList) Clone() baseIList                    { return baseListHelper.Clone(l) }
    16  func (l baseList) Contains(values ...interface{}) bool { return baseListHelper.Contains(l, values...) }
    17  func (l baseList) Count() int                          { return len(l) }
    18  func (l baseList) Create(args ...int) baseIList        { return baseListHelper.CreateList(args...) }
    19  func (l baseList) CreateDict(args ...int) baseIDict    { return baseListHelper.CreateDictionary(args...) }
    20  func (l baseList) First() interface{}                  { return baseListHelper.GetIndexes(l, 0) }
    21  func (l baseList) Get(indexes ...int) interface{}      { return baseListHelper.GetIndexes(l, indexes...) }
    22  func (l baseList) Has(values ...interface{}) bool      { return l.Contains(values...) }
    23  func (l baseList) Join(sep interface{}) str            { return l.StringArray().Join(sep) }
    24  func (l baseList) Last() interface{}                   { return baseListHelper.GetIndexes(l, len(l)-1) }
    25  func (l baseList) Len() int                            { return len(l) }
    26  func (l baseList) New(args ...interface{}) baseIList   { return baseListHelper.NewList(args...) }
    27  func (l baseList) Reverse() baseIList                  { return baseListHelper.Reverse(l) }
    28  func (l baseList) StringArray() strArray               { return baseListHelper.GetStringArray(l) }
    29  func (l baseList) Strings() []string                   { return baseListHelper.GetStrings(l) }
    30  func (l baseList) TypeName() str                       { return "base" }
    31  func (l baseList) Unique() baseIList                   { return baseListHelper.Unique(l) }
    32  
    33  func (l baseList) GetHelpers() (collections.IDictionaryHelper, collections.IListHelper) {
    34  	return baseDictHelper, baseListHelper
    35  }
    36  
    37  func (l baseList) Append(values ...interface{}) baseIList {
    38  	return baseListHelper.Add(l, false, values...)
    39  }
    40  
    41  func (l baseList) Intersect(values ...interface{}) baseIList {
    42  	return baseListHelper.Intersect(l, values...)
    43  }
    44  
    45  func (l baseList) Pop(indexes ...int) (interface{}, baseIList) {
    46  	if len(indexes) == 0 {
    47  		indexes = []int{len(l) - 1}
    48  	}
    49  	return l.Get(indexes...), l.Remove(indexes...)
    50  }
    51  
    52  func (l baseList) Prepend(values ...interface{}) baseIList {
    53  	return baseListHelper.Add(l, true, values...)
    54  }
    55  
    56  func (l baseList) Remove(indexes ...int) baseIList {
    57  	return baseListHelper.Remove(l, indexes...)
    58  }
    59  
    60  func (l baseList) Set(i int, v interface{}) (baseIList, error) {
    61  	return baseListHelper.SetIndex(l, i, v)
    62  }
    63  
    64  func (l baseList) Union(values ...interface{}) baseIList {
    65  	return baseListHelper.Add(l, false, values...).Unique()
    66  }
    67  
    68  func (l baseList) Without(values ...interface{}) baseIList {
    69  	return baseListHelper.Without(l, values...)
    70  }
    71  
    72  // DictTypeName implementation of IDictionary for baseDict
    73  type DictTypeName = baseDict
    74  type baseIDict = collections.IDictionary
    75  type baseDict map[string]interface{}
    76  
    77  func (d baseDict) Add(key, v interface{}) baseIDict    { return baseDictHelper.Add(d, key, v) }
    78  func (d baseDict) AsMap() map[string]interface{}       { return (map[string]interface{})(d) }
    79  func (d baseDict) Clone(keys ...interface{}) baseIDict { return baseDictHelper.Clone(d, keys) }
    80  func (d baseDict) Count() int                          { return len(d) }
    81  func (d baseDict) Create(args ...int) baseIDict        { return baseListHelper.CreateDictionary(args...) }
    82  func (d baseDict) CreateList(args ...int) baseIList    { return baseHelper.CreateList(args...) }
    83  func (d baseDict) Flush(keys ...interface{}) baseIDict { return baseDictHelper.Flush(d, keys) }
    84  func (d baseDict) Get(keys ...interface{}) interface{} { return baseDictHelper.Get(d, keys) }
    85  func (d baseDict) GetKeys() baseIList                  { return baseDictHelper.GetKeys(d) }
    86  func (d baseDict) GetValues() baseIList                { return baseDictHelper.GetValues(d) }
    87  func (d baseDict) Has(keys ...interface{}) bool        { return baseDictHelper.Has(d, keys) }
    88  func (d baseDict) KeysAsString() strArray              { return baseDictHelper.KeysAsString(d) }
    89  func (d baseDict) Len() int                            { return len(d) }
    90  func (d baseDict) Native() interface{}                 { return collections.ToNativeRepresentation(d) }
    91  func (d baseDict) Pop(keys ...interface{}) interface{} { return baseDictHelper.Pop(d, keys) }
    92  func (d baseDict) Set(key, v interface{}) baseIDict    { return baseDictHelper.Set(d, key, v) }
    93  func (d baseDict) Transpose() baseIDict                { return baseDictHelper.Transpose(d) }
    94  func (d baseDict) TypeName() str                       { return "base" }
    95  
    96  func (d baseDict) GetHelpers() (collections.IDictionaryHelper, collections.IListHelper) {
    97  	return baseDictHelper, baseListHelper
    98  }
    99  
   100  func (d baseDict) Default(key, defVal interface{}) interface{} {
   101  	return baseDictHelper.Default(d, key, defVal)
   102  }
   103  
   104  func (d baseDict) Delete(key interface{}, otherKeys ...interface{}) (baseIDict, error) {
   105  	return baseDictHelper.Delete(d, append([]interface{}{key}, otherKeys...))
   106  }
   107  
   108  func (d baseDict) Merge(dict baseIDict, otherDicts ...baseIDict) baseIDict {
   109  	return baseDictHelper.Merge(d, append([]baseIDict{dict}, otherDicts...))
   110  }
   111  
   112  func (d baseDict) Omit(key interface{}, otherKeys ...interface{}) baseIDict {
   113  	return baseDictHelper.Omit(d, append([]interface{}{key}, otherKeys...))
   114  }
   115  
   116  // Generic helpers to simplify physical implementation
   117  func baseListConvert(list baseIList) baseIList { return baseList(list.AsArray()) }
   118  func baseDictConvert(dict baseIDict) baseIDict { return baseDict(dict.AsMap()) }
   119  func needConversion(object interface{}, strict bool) bool {
   120  	return needConversionImpl(object, strict, "base")
   121  }
   122  
   123  var baseHelper = helperBase{ConvertList: baseListConvert, ConvertDict: baseDictConvert, NeedConversion: needConversion}
   124  var baseListHelper = helperList{BaseHelper: baseHelper}
   125  var baseDictHelper = helperDict{BaseHelper: baseHelper}
   126  
   127  // DictionaryHelper gives public access to the basic dictionary functions
   128  var DictionaryHelper collections.IDictionaryHelper = baseDictHelper
   129  
   130  // GenericListHelper gives public access to the basic list functions
   131  var GenericListHelper collections.IListHelper = baseListHelper
   132  
   133  type (
   134  	str      = collections.String
   135  	strArray = collections.StringArray
   136  )
   137  
   138  var iif = collections.IIf