func MatchV(v interface{}, f *Filter) bool {
match := false
/*
rv0 := reflect.ValueOf(v)
if rv0.Kind() == reflect.Ptr {
rv0 = reflect.Indirect(rv0)
}
rv1 := reflect.ValueOf(f.Value)
if rv1.Kind()==reflect.Ptr{
rv1=reflect.Indirect(rv1)
}
*/
if toolkit.HasMember([]interface{}{FilterOpEqual, FilterOpNoEqual, FilterOpGt, FilterOpGte, FilterOpLt, FilterOpLte}, f.Op) {
return Compare(v, f.Value, f.Op)
} else if f.Op == FilterOpIn {
var values []interface{}
toolkit.FromBytes(toolkit.ToBytes(f.Value, ""), "", &values)
return toolkit.HasMember(values, v)
} else if f.Op == FilterOpNin {
var values []interface{}
toolkit.FromBytes(toolkit.ToBytes(f.Value, ""), "", &values)
return !toolkit.HasMember(values, v)
}
return match
}
func MatchV(v interface{}, f *Filter) bool {
match := false
/*
rv0 := reflect.ValueOf(v)
if rv0.Kind() == reflect.Ptr {
rv0 = reflect.Indirect(rv0)
}
rv1 := reflect.ValueOf(f.Value)
if rv1.Kind()==reflect.Ptr{
rv1=reflect.Indirect(rv1)
}
*/
//toolkit.Println("MatchV: ", f.Op, v, f.Value)
if toolkit.HasMember([]string{FilterOpEqual, FilterOpNoEqual, FilterOpGt, FilterOpGte, FilterOpLt, FilterOpLte}, f.Op) {
return toolkit.Compare(v, f.Value, f.Op)
} else if f.Op == FilterOpIn {
var values []interface{}
toolkit.FromBytes(toolkit.ToBytes(f.Value, ""), "", &values)
return toolkit.HasMember(values, v)
} else if f.Op == FilterOpNin {
var values []interface{}
toolkit.FromBytes(toolkit.ToBytes(f.Value, ""), "", &values)
return !toolkit.HasMember(values, v)
} else if f.Op == FilterOpContains {
var values []interface{}
var b bool
toolkit.FromBytes(toolkit.ToBytes(f.Value, ""), "", &values)
for _, val := range values {
// value := toolkit.Sprintf(".*%s.*", val.(string))
// b, _ = regexp.Match(value, []byte(v.(string)))
r := regexp.MustCompile(`(?i)` + val.(string))
b = r.Match([]byte(v.(string)))
if b {
return true
}
}
} else if f.Op == FilterOpStartWith || f.Op == FilterOpEndWith {
value := ""
if f.Op == FilterOpStartWith {
value = toolkit.Sprintf("^%s.*$", f.Value)
} else {
value = toolkit.Sprintf("^.*%s$", f.Value)
}
cond, _ := regexp.Match(value, []byte(v.(string)))
return cond
}
return match
}
func TestStorageWrite(t *testing.T) {
skipIfClientNil(t)
es := []string{}
toolkit.Printf("Writing Data:\n")
for i := 0; i < 200; i++ {
dataku := toolkit.RandInt(1000)
totalInt += dataku
//toolkit.Printf("%d ", dataku)
in := toolkit.M{}.Set("key", fmt.Sprintf("public.dataku.%d", i)).Set("data", toolkit.ToBytes(dataku, ""))
writeResult := client.Call("set", in)
if writeResult.Status != toolkit.Status_OK {
es = append(es, toolkit.Sprintf("Fail to write data %d : %d => %s", i, dataku, writeResult.Message))
}
}
if len(es) > 0 {
errorTxt := ""
if len(es) <= 10 {
errorTxt = strings.Join(es, "\n")
} else {
errorTxt = strings.Join(es[:10], "\n") + "\n... And others ..."
}
t.Errorf("Write data fail.\n%s", errorTxt)
}
}
func (s *Session) Read(key string) ([]byte, error) {
r := s.CallResult("read", toolkit.ToBytes(struct {
UserID, Secret, Key string
}{s.UserID, s.Secret, key}, "json"))
if r.Status == toolkit.Status_NOK {
return nil, errors.New(r.Message)
}
return r.Data.([]byte), nil
}
func (s *Session) Write(key string, data interface{}, mode int) error {
r := s.CallResult("write", toolkit.ToBytes(struct {
UserID, Secret, Key string
Data interface{}
Mode int
}{s.UserID, s.Secret, key, data, mode}, "json"))
if r.Status == toolkit.Status_NOK {
return errors.New(r.Message)
}
return nil
}
func (s *Session) Logout() {
url := MakeUrl(s.URL, "master", "logout")
toolkit.CallResult(url, "POST", toolkit.ToBytes(s, "json"))
}