Example #1
0
// Data returns a slice containing the elements of iter.
func Data(iter Iterable) []interface{} {
	vec := new(vector.Vector)
	for e := range iter.Iter() {
		vec.Push(e)
	}
	return vec.Data()
}
Example #2
0
func TestDecodeFlushElem(t *testing.T) {
	testVec := new(vector.Vector).Resize(2, 2)
	nb := newDecoder(testVec, 1)
	nb.Float64(3.14159)
	nb.Flush()
	assertResult(t, testVec.Data(), []interface{}{nil, float64(3.14159)})
}
Example #3
0
func TestGroupBy(t *testing.T) {
	in := IntArray{1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5}
	exp := [][]int{[]int{1}, []int{2, 2}, []int{3, 3, 3}, []int{4, 4, 4, 4}, []int{5, 5, 5, 5, 5}}
	i := 0
	for x := range GroupBy(in, intkey{}).Iter() {
		gr := x.(Group)
		if gr.Key.(int) != i+1 {
			t.Fatal("group key wrong; expected", i+1, "but got", gr.Key.(int))
		}
		vals := Data(gr.Vals)
		assertArraysAreEqual(t, vals, exp[i])
		i++
	}
	if i != 5 {
		t.Fatal("did not return expected number of groups")
	}

	// test 0 length Iterable
	for _ = range GroupBy(IntArray([]int{}), &intkey{}).Iter() {
		t.Fatal("iterator should be empty")
	}

	// test case with only uniques
	var out vector.Vector
	for x := range GroupBy(elevenToTwenty, intkey{}).Iter() {
		out.Push(x.(Group).Key)
	}
	assertArraysAreEqual(t, out.Data(), elevenToTwenty)
}
Example #4
0
func Respond(query types.DNSquery) (result types.DNSresponse) {
	result.Responsecode = types.SERVFAIL
	qname := strings.ToLower(query.Qname)
	var asection, nssection vector.Vector
	if query.Qclass == types.IN {
		if as112Domain.MatchString(qname) {
			result.Responsecode = types.NOERROR
			if types.QMatches(query.Qtype, types.NS) {
				nsRecords(query.Qname, &asection)
			}
			if types.QMatches(query.Qtype, types.SOA) {
				asection.Push(soaRecord(query.Qname, as112soa))
			}
		}
		matches := as112SubDomain.MatchStrings(qname)
		if len(matches) > 0 {
			result.Responsecode = types.NXDOMAIN
			nssection.Push(soaRecord(matches[1], as112soa))
		}
		if qname == "hostname.as112.net" {
			result.Responsecode = types.NOERROR
			if types.QMatches(query.Qtype, types.TXT) {
				for i := 0; i < len(hostnameAnswers); i++ {
					asection.Push(types.RR{
						Name:  query.Qname,
						TTL:   defaultTTL,
						Type:  types.TXT,
						Class: types.IN,
						Data:  types.ToTXT(hostnameAnswers[i]),
					})
				}
			}
			if types.QMatches(query.Qtype, types.NS) {
				nsRecords(query.Qname, &asection)
			}
			if types.QMatches(query.Qtype, types.SOA) {
				asection.Push(soaRecord(query.Qname, hostnamesoa))
			}
		}
	}
	data := asection.Data()
	result.Asection = make([]types.RR, len(data))
	for i := 0; i < len(data); i++ {
		result.Asection[i] = data[i].(types.RR)
	}
	data = nssection.Data()
	result.Nssection = make([]types.RR, len(data))
	for i := 0; i < len(data); i++ {
		result.Nssection[i] = data[i].(types.RR)
	}
	return
}
Example #5
0
File: peg.go Project: ypb/bwl
func (self *quantifiedExpr) Match(m Position) (Position, interface{}) {
	var item interface{}
	cur := m
	res := new(vector.Vector)
	// guaranteed minimum
	for i := 0; i < self.min; i++ {
		cur, item = self.e.Match(cur)
		if cur.Failed() {
			return cur, nil
		}
		res.Push(item)
	}
	last := cur
	// optional (up to a maximum)
	for i := self.min; self.max == -1 || i < self.max; i++ {
		cur, item = self.e.Match(last)
		if cur.Failed() {
			return last, res.Data()
		}
		res.Push(item)
		last = cur
	}
	return cur, res.Data()
}