/* Check the uniqueness of a Uid.
*
* FIXME: RESTify this!
*/
func CheckUidHandler(w http.ResponseWriter, r *http.Request) {
log.Println("CheckUidHandler got request with method: " + r.Method)
if r.Method == "POST" {
context := appengine.NewContext(r)
isUnique := controller.IsUidUnique(context, r.FormValue("uid"))
encoder := json.NewEncoder(w)
type UidResponse struct {
Uid string
Available string
}
response := new(UidResponse)
response.Uid = r.FormValue("uid")
log.Println("Result from IsUidUnique is: " + strconv.Btoa(isUnique) + " : " + reflect.TypeOf(isUnique).String())
if isUnique {
log.Println("Username " + response.Uid + " is available")
response.Available = "available"
} else {
log.Println("Username " + response.Uid + " is not available")
response.Available = "not available"
}
log_, _ := json.Marshal(&response)
log.Println("Sending to JQuery: " + string(log_))
if err := encoder.Encode(&response); err != nil {
log.Println("Cannot send JSON to AJAX code: " + err.String())
}
}
return
}
// updatePackage sends package build results and info dashboard
func (b *Builder) updatePackage(pkg string, ok bool, buildLog, info string) os.Error {
return dash("POST", "package", nil, param{
"builder": b.name,
"key": b.key,
"path": pkg,
"ok": strconv.Btoa(ok),
"log": buildLog,
"info": info,
})
}
func save_options() {
file, _ := os.OpenFile(os.Getenv("HOME")+"/.tabbyoptions", os.O_CREATE|os.O_WRONLY, 0644)
if nil == file {
tabby_log("unable to save options")
return
}
file.Truncate(0)
file.WriteString("show_search\t" + strconv.Btoa(opt.show_search) + "\n")
file.WriteString("show_error\t" + strconv.Btoa(opt.show_error) + "\n")
file.WriteString("space_not_tab\t" + strconv.Btoa(opt.space_not_tab) + "\n")
file.WriteString("ihp_position\t" + strconv.Itoa(opt.ihp_position) + "\n")
file.WriteString("ohp_position\t" + strconv.Itoa(opt.ohp_position) + "\n")
file.WriteString("vvp_position\t" + strconv.Itoa(opt.vvp_position) + "\n")
file.WriteString("alloc_window\t" + strconv.Itoa(opt.window_width) + "\t" +
strconv.Itoa(opt.window_height) + "\t" + strconv.Itoa(opt.window_x) + "\t" +
strconv.Itoa(opt.window_y) + "\n")
file.WriteString("font\t" + opt.font + "\n")
file.WriteString("tabsize\t" + strconv.Itoa(opt.tabsize) + "\n")
file.Close()
}
// updatePackage sends package build results and info to the dashboard
func (b *Builder) updatePackage(pkg string, state bool, buildLog, info string, hash string) os.Error {
return dash("POST", "package", nil, param{
"builder": b.name,
"key": b.key,
"path": pkg,
"state": strconv.Btoa(state),
"log": buildLog,
"info": info,
"go_rev": hash[:12],
})
}
func formatReflectValue(x reflect.Value) (string, os.Error) {
/*
if !x.CanSet() {
return "", ErrorCantSet
}
*/
var (
errc os.Error
kind = x.Kind()
//vintstr string
)
switch kind {
// Format pointers to standard types.
case reflect.String:
return x.Interface().(string), nil
case reflect.Int:
return strconv.Itoa(x.Interface().(int)), nil
case reflect.Int8:
return strconv.Itoa64(int64(x.Interface().(int8))), nil
case reflect.Int16:
return strconv.Itoa64(int64(x.Interface().(int16))), nil
case reflect.Int32:
return strconv.Itoa64(int64(x.Interface().(int32))), nil
case reflect.Int64:
return strconv.Itoa64(x.Interface().(int64)), nil
case reflect.Uint:
return strconv.Uitoa(x.Interface().(uint)), nil
case reflect.Uint8:
return strconv.Uitoa64(uint64(x.Interface().(uint8))), nil
case reflect.Uint16:
return strconv.Uitoa64(uint64(x.Interface().(uint16))), nil
case reflect.Uint32:
return strconv.Uitoa64(uint64(x.Interface().(uint32))), nil
case reflect.Uint64:
return strconv.Uitoa64(x.Interface().(uint64)), nil
case reflect.Float32:
return strconv.Ftoa32(x.Interface().(float32), FloatFmt, FloatPrec), nil
case reflect.Float64:
return strconv.Ftoa64(x.Interface().(float64), FloatFmt, FloatPrec), nil
case reflect.Complex64:
fallthrough
case reflect.Complex128:
errc = ErrorUnimplemented
case reflect.Bool:
return strconv.Btoa(x.Interface().(bool)), nil
default:
errc = ErrorFieldType
}
return "", errc
}
func (m *SelectManager) Project(any interface{}) *SelectManager {
switch val := any.(type) {
case ast.Node:
m.project(val)
case string:
m.project(ast.NewSqlLiteral(any.(string)))
case bool:
m.project(ast.NewSqlLiteral(strconv.Btoa(any.(bool))))
case int:
m.project(ast.NewSqlLiteral(strconv.Itoa(any.(int))))
case int64:
m.project(ast.NewSqlLiteral(strconv.Itoa64(any.(int64))))
case float32:
m.project(ast.NewSqlLiteral(strconv.Ftoa32(any.(float32), 'f', 0)))
case float64:
m.project(ast.NewSqlLiteral(strconv.Ftoa64(any.(float64), 'f', 0)))
}
return m
}
func (c *ToSql) Convert(unknown interface{}) (s string) {
switch val := unknown.(type) {
case string:
s = strconv.Quote(val)
case bool:
s = strconv.Btoa(val)
case int:
s = strconv.Itoa(val)
case int64:
s = strconv.Itoa64(val)
case uint:
s = strconv.Uitoa(val)
case uint64:
s = strconv.Uitoa64(val)
case float32:
s = strconv.Ftoa32(val, 'f', -1)
case float64:
s = strconv.Ftoa64(val, 'f', -1)
default:
s = c.ConvertUnknown(unknown)
}
return
}
func (p *printer) marshalValue(val reflect.Value, name string) os.Error {
if !val.IsValid() {
return nil
}
kind := val.Kind()
typ := val.Type()
// Try Marshaler
if typ.NumMethod() > 0 {
if marshaler, ok := val.Interface().(Marshaler); ok {
bytes, err := marshaler.MarshalXML()
if err != nil {
return err
}
p.Write(bytes)
return nil
}
}
// Drill into pointers/interfaces
if kind == reflect.Ptr || kind == reflect.Interface {
if val.IsNil() {
return nil
}
return p.marshalValue(val.Elem(), name)
}
// Slices and arrays iterate over the elements. They do not have an enclosing tag.
if (kind == reflect.Slice || kind == reflect.Array) && typ.Elem().Kind() != reflect.Uint8 {
for i, n := 0, val.Len(); i < n; i++ {
if err := p.marshalValue(val.Index(i), name); err != nil {
return err
}
}
return nil
}
// Find XML name
xmlns := ""
if kind == reflect.Struct {
if f, ok := typ.FieldByName("XMLName"); ok {
if tag := f.Tag.Get("xml"); tag != "" {
if i := strings.Index(tag, " "); i >= 0 {
xmlns, name = tag[:i], tag[i+1:]
} else {
name = tag
}
} else if v, ok := val.FieldByIndex(f.Index).Interface().(Name); ok && v.Local != "" {
xmlns, name = v.Space, v.Local
}
}
}
p.WriteByte('<')
p.WriteString(name)
// Attributes
if kind == reflect.Struct {
if len(xmlns) > 0 {
p.WriteString(` xmlns="`)
Escape(p, []byte(xmlns))
p.WriteByte('"')
}
for i, n := 0, typ.NumField(); i < n; i++ {
if f := typ.Field(i); f.PkgPath == "" && f.Tag.Get("xml") == "attr" {
if f.Type.Kind() == reflect.String {
if str := val.Field(i).String(); str != "" {
p.WriteByte(' ')
p.WriteString(strings.ToLower(f.Name))
p.WriteString(`="`)
Escape(p, []byte(str))
p.WriteByte('"')
}
}
}
}
}
p.WriteByte('>')
switch k := val.Kind(); k {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
p.WriteString(strconv.Itoa64(val.Int()))
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
p.WriteString(strconv.Uitoa64(val.Uint()))
case reflect.Float32, reflect.Float64:
p.WriteString(strconv.Ftoa64(val.Float(), 'g', -1))
case reflect.String:
Escape(p, []byte(val.String()))
case reflect.Bool:
p.WriteString(strconv.Btoa(val.Bool()))
case reflect.Array:
// will be [...]byte
bytes := make([]byte, val.Len())
for i := range bytes {
bytes[i] = val.Index(i).Interface().(byte)
}
Escape(p, bytes)
case reflect.Slice:
// will be []byte
bytes := val.Interface().([]byte)
Escape(p, bytes)
case reflect.Struct:
s := parentStack{printer: p}
for i, n := 0, val.NumField(); i < n; i++ {
if f := typ.Field(i); f.Name != "XMLName" && f.PkgPath == "" {
name := f.Name
vf := val.Field(i)
switch tag := f.Tag.Get("xml"); tag {
case "":
s.trim(nil)
case "chardata":
if tk := f.Type.Kind(); tk == reflect.String {
Escape(p, []byte(vf.String()))
} else if tk == reflect.Slice {
if elem, ok := vf.Interface().([]byte); ok {
Escape(p, elem)
}
}
continue
case "innerxml":
iface := vf.Interface()
switch raw := iface.(type) {
case []byte:
p.Write(raw)
continue
case string:
p.WriteString(raw)
continue
}
case "attr":
continue
default:
parents := strings.Split(tag, ">")
if len(parents) == 1 {
parents, name = nil, tag
} else {
parents, name = parents[:len(parents)-1], parents[len(parents)-1]
if parents[0] == "" {
parents[0] = f.Name
}
}
s.trim(parents)
if !(vf.Kind() == reflect.Ptr || vf.Kind() == reflect.Interface) || !vf.IsNil() {
s.push(parents[len(s.stack):])
}
}
if err := p.marshalValue(vf, name); err != nil {
return err
}
}
}
s.trim(nil)
default:
return &UnsupportedTypeError{typ}
}
p.WriteByte('<')
p.WriteByte('/')
p.WriteString(name)
p.WriteByte('>')
return nil
}
func (x Bool) String() string { return strconv.Btoa(bool(x)) }
