Added Filter, FilterRegexp and FilterPrefix

properties.go

diff --git a/properties.go b/properties.go
index a5aaa21..e9386fb 100644
--- a/properties.go
+++ b/properties.go
@@ -12,6 +12,7 @@
 	"io"
 	"log"
 	"os"
+	"regexp"
 	"strconv"
 	"strings"
 	"time"
@@ -319,6 +320,41 @@
 
 // ----------------------------------------------------------------------------
 
+// Filter returns a new properties object which contains all properties
+// for which the key matches the pattern.
+func (p *Properties) Filter(pattern string) (*Properties, error) {
+	re, err := regexp.Compile(pattern)
+	if err != nil {
+		return nil, err
+	}
+
+	return p.FilterRegexp(re), nil
+}
+
+// FilterRegexp returns a new properties object which contains all properties
+// for which the key matches the regular expression.
+func (p *Properties) FilterRegexp(re *regexp.Regexp) *Properties {
+	pp := NewProperties()
+	for k, v := range p.m {
+		if re.MatchString(k) {
+			pp.Set(k, v)
+		}
+	}
+	return pp
+}
+
+// FilterPrefix returns a new properties object which contains all properties
+// for which the key starts with the prefix.
+func (p *Properties) FilterPrefix(prefix string) *Properties {
+	pp := NewProperties()
+	for k, v := range p.m {
+		if strings.HasPrefix(k, prefix) {
+			pp.Set(k, v)
+		}
+	}
+	return pp
+}
+
 // Len returns the number of keys.
 func (p *Properties) Len() int {
 	return len(p.m)

properties_test.go

diff --git a/properties_test.go b/properties_test.go
index ef5ce2c..ba5d6be 100644
--- a/properties_test.go
+++ b/properties_test.go
@@ -299,6 +299,53 @@
 
 // ----------------------------------------------------------------------------
 
+type filterTest struct {
+	input   string
+	pattern string
+	keys    []string
+	err     string
+}
+
+var filterTests = []*filterTest{
+	&filterTest{"", "", []string{}, ""},
+	&filterTest{"", "abc", []string{}, ""},
+	&filterTest{"key=value", "", []string{"key"}, ""},
+	&filterTest{"key=value", "key=", []string{}, ""},
+	&filterTest{"key=value\nfoo=bar", "", []string{"foo", "key"}, ""},
+	&filterTest{"key=value\nfoo=bar", "f", []string{"foo"}, ""},
+	&filterTest{"key=value\nfoo=bar", "fo", []string{"foo"}, ""},
+	&filterTest{"key=value\nfoo=bar", "foo", []string{"foo"}, ""},
+	&filterTest{"key=value\nfoo=bar", "fooo", []string{}, ""},
+	&filterTest{"key=value\nkey2=value2\nfoo=bar", "ey", []string{"key", "key2"}, ""},
+	&filterTest{"key=value\nkey2=value2\nfoo=bar", "key", []string{"key", "key2"}, ""},
+	&filterTest{"key=value\nkey2=value2\nfoo=bar", "^key", []string{"key", "key2"}, ""},
+	&filterTest{"key=value\nkey2=value2\nfoo=bar", "^(key|foo)", []string{"foo", "key", "key2"}, ""},
+	&filterTest{"key=value\nkey2=value2\nfoo=bar", "[ abc", nil, "error parsing regexp.*"},
+}
+
+// ----------------------------------------------------------------------------
+
+type filterPrefixTest struct {
+	input  string
+	prefix string
+	keys   []string
+}
+
+var filterPrefixTests = []*filterPrefixTest{
+	&filterPrefixTest{"", "", []string{}},
+	&filterPrefixTest{"", "abc", []string{}},
+	&filterPrefixTest{"key=value", "", []string{"key"}},
+	&filterPrefixTest{"key=value", "key=", []string{}},
+	&filterPrefixTest{"key=value\nfoo=bar", "", []string{"foo", "key"}},
+	&filterPrefixTest{"key=value\nfoo=bar", "f", []string{"foo"}},
+	&filterPrefixTest{"key=value\nfoo=bar", "fo", []string{"foo"}},
+	&filterPrefixTest{"key=value\nfoo=bar", "foo", []string{"foo"}},
+	&filterPrefixTest{"key=value\nfoo=bar", "fooo", []string{}},
+	&filterPrefixTest{"key=value\nkey2=value2\nfoo=bar", "key", []string{"key", "key2"}},
+}
+
+// ----------------------------------------------------------------------------
+
 // TestBasic tests basic single key/value combinations with all possible
 // whitespace, delimiter and newline permutations.
 func (l *TestSuite) TestBasic(c *C) {
@@ -470,6 +517,44 @@
 	c.Assert(func() { p.MustGetString("invalid") }, PanicMatches, "unknown property: invalid")
 }
 
+func (l *TestSuite) TestFilter(c *C) {
+	for _, test := range filterTests {
+		p, err := parse(test.input)
+		c.Assert(err, IsNil)
+		pp, err := p.Filter(test.pattern)
+		if err != nil {
+			c.Assert(err, ErrorMatches, test.err)
+			continue
+		}
+		c.Assert(pp, NotNil)
+		c.Assert(pp.Len(), Equals, len(test.keys))
+		for _, key := range test.keys {
+			v1, ok1 := p.Get(key)
+			v2, ok2 := pp.Get(key)
+			c.Assert(ok1, Equals, true)
+			c.Assert(ok2, Equals, true)
+			c.Assert(v1, Equals, v2)
+		}
+	}
+}
+
+func (l *TestSuite) TestFilterPrefix(c *C) {
+	for _, test := range filterPrefixTests {
+		p, err := parse(test.input)
+		c.Assert(err, IsNil)
+		pp := p.FilterPrefix(test.prefix)
+		c.Assert(pp, NotNil)
+		c.Assert(pp.Len(), Equals, len(test.keys))
+		for _, key := range test.keys {
+			v1, ok1 := p.Get(key)
+			v2, ok2 := pp.Get(key)
+			c.Assert(ok1, Equals, true)
+			c.Assert(ok2, Equals, true)
+			c.Assert(v1, Equals, v2)
+		}
+	}
+}
+
 func (l *TestSuite) TestKeys(c *C) {
 	for _, test := range keysTests {
 		p, err := parse(test.input)