Implement to unmarshal PT duration

Author: miyukki

mpd/duration.go

@@ -4,6 +4,9 @@ package mpd
 
 import (
 	"encoding/xml"
+	"errors"
+	"strconv"
+	"strings"
 	"time"
 )
 
@@ -13,6 +16,15 @@ func (d Duration) MarshalXMLAttr(name xml.Name) (xml.Attr, error) {
 	return xml.Attr{name, d.String()}, nil
 }
 
+func (d *Duration) UnmarshalXMLAttr(attr xml.Attr) error {
+	dur, err := parseDuration(attr.Value)
+	if err != nil {
+		return err
+	}
+	*d = Duration(dur)
+	return nil
+}
+
 // String renders a Duration in XML Duration Data Type format
 func (d *Duration) String() string {
 	// Largest time is 2540400h10m10.000000000s
@@ -126,3 +138,95 @@ func fmtInt(buf []byte, v uint64) int {
 	}
 	return w
 }
+
+func parseDuration(str string) (time.Duration, error) {
+	if len(str) < 3 {
+		return 0, errors.New("input duration too short")
+	}
+
+	var minus bool
+	offset := 0
+	if str[offset] == '-' {
+		minus = true
+		offset++
+	}
+
+	if str[offset] != 'P' {
+		return 0, errors.New("input duration does not have a valid prefix")
+	}
+	offset++
+
+	base := time.Unix(0, 0)
+	t := base
+
+	var dateStr, timeStr string
+	if i := strings.IndexByte(str[offset:], 'T'); i != -1 {
+		dateStr = str[offset : offset+i]
+		timeStr = str[offset+i+1:]
+	} else {
+		dateStr = str[offset:]
+	}
+
+	if len(dateStr) > 0 {
+		var pos int
+		var err error
+		var years, months, days int
+		if i := strings.IndexByte(dateStr[pos:], 'Y'); i != -1 {
+			years, err = strconv.Atoi(dateStr[pos : pos+i])
+			if err != nil {
+				return 0, err
+			}
+			pos += i + 1
+		}
+
+		if i := strings.IndexByte(dateStr[pos:], 'M'); i != -1 {
+			months, err = strconv.Atoi(dateStr[pos : pos+i])
+			if err != nil {
+				return 0, err
+			}
+			pos += i + 1
+		}
+
+		if i := strings.IndexByte(dateStr[pos:], 'D'); i != -1 {
+			days, err = strconv.Atoi(dateStr[pos : pos+i])
+			if err != nil {
+				return 0, err
+			}
+		}
+		t = t.AddDate(years, months, days)
+	}
+
+	if len(timeStr) > 0 {
+		var pos int
+		var sum float64
+		if i := strings.IndexByte(timeStr[pos:], 'H'); i != -1 {
+			hours, err := strconv.ParseInt(timeStr[pos:pos+i], 10, 64)
+			if err != nil {
+				return 0, err
+			}
+			sum += float64(hours) * 3600
+			pos += i + 1
+		}
+		if i := strings.IndexByte(timeStr[pos:], 'M'); i != -1 {
+			minutes, err := strconv.ParseInt(timeStr[pos:pos+i], 10, 64)
+			if err != nil {
+				return 0, err
+			}
+			sum += float64(minutes) * 60
+			pos += i + 1
+		}
+		if i := strings.IndexByte(timeStr[pos:], 'S'); i != -1 {
+			seconds, err := strconv.ParseFloat(timeStr[pos:pos+i], 64)
+			if err != nil {
+				return 0, err
+			}
+			sum += seconds
+		}
+		t = t.Add(time.Duration(sum * float64(time.Second)))
+	}
+
+	if minus {
+		return -t.Sub(base), nil
+	}
+	return t.Sub(base), nil
+}

mpd/duration_test.go

@@ -20,3 +20,28 @@ func TestDuration(t *testing.T) {
 		assert.Equal(t, ex, dur.String())
 	}
 }
+
+func TestParseDuration(t *testing.T) {
+	in := map[string]float64{
+		"PT0S":                 0,
+		"PT1M":                 60,
+		"PT2H":                 7200,
+		"PT6M16S":              376,
+		"PT1.97S":              1.97,
+		"PT1H2M3.456S":         3723.456,
+		"P1YT2M3S":             (365*24*time.Hour + 2*time.Minute + 3*time.Second).Seconds(),
+		"P1Y2M3DT12H34M56.78S": (365*24*time.Hour + 59*24*time.Hour + 3*24*time.Hour + 12*time.Hour + 34*time.Minute + 56*time.Second + 780*time.Millisecond).Seconds(),
+		"P1DT2H":               (26 * time.Hour).Seconds(),
+		"P20M":                 (608 * 24 * time.Hour).Seconds(),
+		"PT20M":                (20 * time.Minute).Seconds(),
+		"P0Y20M0D":             (608 * 24 * time.Hour).Seconds(),
+		"P0Y":                  0,
+		"-P60D":                -(60 * 24 * time.Hour).Seconds(),
+		"PT1M30.5S":            (time.Minute + 30*time.Second + 500*time.Millisecond).Seconds(),
+	}
+	for ins, ex := range in {
+		act, err := parseDuration(ins)
+		assert.NoError(t, err, ins)
+		assert.Equal(t, ex, act.Seconds(), ins)
+	}
+}