argument.go

Documentation: github.com/udacity/graphb

     1  package graphb
     2  
     3  import (
     4  	"fmt"
     5  )
     6  
     7  type argumentValue interface {
     8  	stringChan() <-chan string
     9  }
    10  
    11  type Argument struct {
    12  	Name  string
    13  	Value argumentValue
    14  }
    15  
    16  func (a *Argument) stringChan() <-chan string {
    17  	tokenChan := make(chan string)
    18  	go func() {
    19  		tokenChan <- a.Name
    20  		tokenChan <- ":"
    21  		for str := range a.Value.stringChan() {
    22  			tokenChan <- str
    23  		}
    24  		close(tokenChan)
    25  	}()
    26  	return tokenChan
    27  }
    28  
    29  func ArgumentAny(name string, value interface{}) (Argument, error) {
    30  	switch v := value.(type) {
    31  	case bool:
    32  		return ArgumentBool(name, v), nil
    33  	case []bool:
    34  		return ArgumentBoolSlice(name, v...), nil
    35  
    36  	case int:
    37  		return ArgumentInt(name, v), nil
    38  	case []int:
    39  		return ArgumentIntSlice(name, v...), nil
    40  
    41  	case string:
    42  		return ArgumentString(name, v), nil
    43  	case []string:
    44  		return ArgumentStringSlice(name, v...), nil
    45  
    46  	default:
    47  		return Argument{}, ArgumentTypeNotSupportedErr{Value: value}
    48  	}
    49  }
    50  
    51  func ArgumentBool(name string, value bool) Argument {
    52  	return Argument{name, argBool(value)}
    53  }
    54  
    55  func ArgumentInt(name string, value int) Argument {
    56  	return Argument{name, argInt(value)}
    57  }
    58  
    59  func ArgumentString(name string, value string) Argument {
    60  	return Argument{name, argString(value)}
    61  }
    62  
    63  func ArgumentBoolSlice(name string, values ...bool) Argument {
    64  	return Argument{name, argBoolSlice(values)}
    65  }
    66  
    67  func ArgumentIntSlice(name string, values ...int) Argument {
    68  	return Argument{name, argIntSlice(values)}
    69  }
    70  
    71  func ArgumentStringSlice(name string, values ...string) Argument {
    72  	return Argument{name, argStringSlice(values)}
    73  }
    74  
    75  // ArgumentCustomType returns a custom GraphQL type's argument representation, which could be a recursive structure.
    76  func ArgumentCustomType(name string, values ...Argument) Argument {
    77  	return Argument{name, argumentSlice(values)}
    78  }
    79  
    80  func ArgumentCustomTypeSlice(name string, values ...[]Argument) Argument {
    81  	return Argument{name, argCustomTypeSlice(values)}
    82  }
    83  
    84  func ArgumentCustomTypeSliceElem(values ...Argument) []Argument {
    85  	return values
    86  }
    87  
    88  /////////////////////////////
    89  // Primitive Wrapper Types //
    90  /////////////////////////////
    91  
    92  // argBool represents a boolean value.
    93  type argBool bool
    94  
    95  func (v argBool) stringChan() <-chan string {
    96  	tokenChan := make(chan string)
    97  	go func() {
    98  		tokenChan <- fmt.Sprintf("%t", v)
    99  		close(tokenChan)
   100  	}()
   101  	return tokenChan
   102  }
   103  
   104  // argInt represents an integer value.
   105  type argInt int
   106  
   107  func (v argInt) stringChan() <-chan string {
   108  	tokenChan := make(chan string)
   109  	go func() {
   110  		tokenChan <- fmt.Sprintf("%d", v)
   111  		close(tokenChan)
   112  	}()
   113  	return tokenChan
   114  }
   115  
   116  // argString represents a string value.
   117  type argString string
   118  
   119  func (v argString) stringChan() <-chan string {
   120  	tokenChan := make(chan string)
   121  	go func() {
   122  		tokenChan <- fmt.Sprintf(`"%s"`, v)
   123  		close(tokenChan)
   124  	}()
   125  	return tokenChan
   126  }
   127  
   128  //////////////////////////////////
   129  // Primitive List Wrapper Types //
   130  //////////////////////////////////
   131  
   132  // argBoolSlice implements valueSlice
   133  type argBoolSlice []bool
   134  
   135  func (s argBoolSlice) stringChan() <-chan string {
   136  	tokenChan := make(chan string)
   137  	go func() {
   138  		tokenChan <- "["
   139  		for i, v := range s {
   140  			if i != 0 {
   141  				tokenChan <- ","
   142  			}
   143  			tokenChan <- fmt.Sprintf("%t", v)
   144  		}
   145  		tokenChan <- "]"
   146  		close(tokenChan)
   147  	}()
   148  	return tokenChan
   149  }
   150  
   151  // argIntSlice implements valueSlice
   152  type argIntSlice []int
   153  
   154  func (s argIntSlice) stringChan() <-chan string {
   155  	tokenChan := make(chan string)
   156  	go func() {
   157  		tokenChan <- "["
   158  		for i, v := range s {
   159  			if i != 0 {
   160  				tokenChan <- ","
   161  			}
   162  			tokenChan <- fmt.Sprintf("%d", v)
   163  		}
   164  		tokenChan <- "]"
   165  		close(tokenChan)
   166  	}()
   167  	return tokenChan
   168  }
   169  
   170  // argStringSlice implements valueSlice
   171  type argStringSlice []string
   172  
   173  func (s argStringSlice) stringChan() <-chan string {
   174  	tokenChan := make(chan string)
   175  	go func() {
   176  		tokenChan <- "["
   177  		for i, v := range s {
   178  			if i != 0 {
   179  				tokenChan <- ","
   180  			}
   181  			tokenChan <- fmt.Sprintf(`"%s"`, v)
   182  		}
   183  		tokenChan <- "]"
   184  		close(tokenChan)
   185  	}()
   186  	return tokenChan
   187  }
   188  
   189  type argumentSlice []Argument
   190  
   191  func (s argumentSlice) stringChan() <-chan string {
   192  	tokenChan := make(chan string)
   193  	go func() {
   194  		tokenChan <- "{"
   195  		for i, v := range s {
   196  			if i != 0 {
   197  				tokenChan <- ","
   198  			}
   199  			for str := range v.stringChan() {
   200  				tokenChan <- str
   201  			}
   202  		}
   203  		tokenChan <- "}"
   204  		close(tokenChan)
   205  	}()
   206  	return tokenChan
   207  }
   208  
   209  type argCustomTypeSlice [][]Argument
   210  
   211  func (s argCustomTypeSlice) stringChan() <-chan string {
   212  	tokenChan := make(chan string)
   213  	go func() {
   214  		tokenChan <- "["
   215  		for i, v := range s {
   216  			if i != 0 {
   217  				tokenChan <- ","
   218  			}
   219  			for str := range argumentSlice(v).stringChan() {
   220  				tokenChan <- str
   221  			}
   222  		}
   223  		tokenChan <- "]"
   224  		close(tokenChan)
   225  	}()
   226  	return tokenChan
   227  }
   228
View as plain text