value_context.go: ValueContext now embeds value processing

The upshot of this is that generating a list of type-correct slices or a
string from a tag's value is now stupidly easy.

- Broke parsing into an independent type (parser.go:Parser).

- Moved primary value-processing logic to `ValueContext` so that it
  coexists with the actual data (though as much basic functionality as
  possible is implemented independently and reused here). This
  eliminates extremely ridiculously obtuse usage procedure.

- Deprecated almost all existing TagType functionality (in order to
  distance us from this now-legacy usage pattern). Existing
  functionality maintained for now. We'll drop it when we do the next
  release major.

- `ValueContext` is now passed by reference.

Author: dsoprea

exif-read-tool/main.go

@@ -117,7 +117,7 @@ func main() {
 				valueString = fmt.Sprintf("%v", value)
 			}
 		} else {
-			valueString, err = tagType.ResolveAsString(valueContext, true)
+			valueString, err = valueContext.FormatFirst()
 			log.PanicIf(err)
 
 			value = valueString

exif_test.go

@@ -90,7 +90,7 @@ func TestVisit(t *testing.T) {
 				valueString = fmt.Sprintf("%v", value)
 			}
 		} else {
-			valueString, err = tagType.ResolveAsString(valueContext, true)
+			valueString, err = valueContext.FormatFirst()
 			log.PanicIf(err)
 		}
 

ifd_builder.go

@@ -129,11 +129,9 @@ func (bt *BuilderTag) String() string {
 	var valueString string
 
 	if bt.value.IsBytes() == true {
-		tt := NewTagType(bt.typeId, bt.byteOrder)
-
 		var err error
 
-		valueString, err = tt.Format(bt.value.Bytes(), false)
+		valueString, err = Format(bt.value.Bytes(), bt.typeId, false, bt.byteOrder)
 		log.PanicIf(err)
 	} else {
 		valueString = fmt.Sprintf("%v", bt.value)

ifd_enumerate.go

@@ -294,20 +294,59 @@ func (ie *IfdEnumerate) resolveTagValue(ite *IfdTagEntry) (valueBytes []byte, is
 	return valueBytes, false, nil
 }
 
+// RawTagVisitorPtr is an optional callback that can get hit for every tag we parse
+// through. `addressableData` is the byte array startign after the EXIF header
+// (where the offsets of all IFDs and values are calculated from).
+//
+// This was reimplemented as an interface to allow for simpler change management
+// in the future.
+type RawTagWalk interface {
+	Visit(fqIfdPath string, ifdIndex int, tagId uint16, tagType TagType, valueContext *ValueContext) (err error)
+}
+
+type RawTagWalkLegacyWrapper struct {
+	legacyVisitor RawTagVisitor
+}
+
+func (rtwlw RawTagWalkLegacyWrapper) Visit(fqIfdPath string, ifdIndex int, tagId uint16, tagType TagType, valueContext *ValueContext) (err error) {
+	return rtwlw.legacyVisitor(fqIfdPath, ifdIndex, tagId, tagType, *valueContext)
+}
+
 // RawTagVisitor is an optional callback that can get hit for every tag we parse
 // through. `addressableData` is the byte array startign after the EXIF header
 // (where the offsets of all IFDs and values are calculated from).
+//
+// DEPRECATED(dustin): Use a RawTagWalk instead.
 type RawTagVisitor func(fqIfdPath string, ifdIndex int, tagId uint16, tagType TagType, valueContext ValueContext) (err error)
 
 // ParseIfd decodes the IFD block that we're currently sitting on the first
 // byte of.
-func (ie *IfdEnumerate) ParseIfd(fqIfdPath string, ifdIndex int, ite *IfdTagEnumerator, visitor RawTagVisitor, doDescend bool, resolveValues bool) (nextIfdOffset uint32, entries []*IfdTagEntry, thumbnailData []byte, err error) {
+func (ie *IfdEnumerate) ParseIfd(fqIfdPath string, ifdIndex int, ite *IfdTagEnumerator, visitor interface{}, doDescend bool, resolveValues bool) (nextIfdOffset uint32, entries []*IfdTagEntry, thumbnailData []byte, err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
+	var visitorWrapper RawTagWalk
+
+	if visitor != nil {
+		var ok bool
+
+		visitorWrapper, ok = visitor.(RawTagWalk)
+		if ok == false {
+			// Legacy usage.
+
+			// `ok` can be `true` but `legacyVisitor` can still be `nil` (when
+			// passed as nil).
+			if legacyVisitor, ok := visitor.(RawTagVisitor); ok == true && legacyVisitor != nil {
+				visitorWrapper = RawTagWalkLegacyWrapper{
+					legacyVisitor: legacyVisitor,
+				}
+			}
+		}
+	}
+
 	tagCount, _, err := ite.getUint16()
 	log.PanicIf(err)
 
@@ -338,7 +377,7 @@ func (ie *IfdEnumerate) ParseIfd(fqIfdPath string, ifdIndex int, ite *IfdTagEnum
 			continue
 		}
 
-		if visitor != nil {
+		if visitorWrapper != nil {
 			tt := NewTagType(tag.TagType, ie.byteOrder)
 
 			vc :=
@@ -350,7 +389,7 @@ func (ie *IfdEnumerate) ParseIfd(fqIfdPath string, ifdIndex int, ite *IfdTagEnum
 					tag.TagType,
 					ie.byteOrder)
 
-			err := visitor(fqIfdPath, ifdIndex, tag.TagId, tt, vc)
+			err := visitorWrapper.Visit(fqIfdPath, ifdIndex, tag.TagId, tt, vc)
 			log.PanicIf(err)
 		}
 
@@ -412,7 +451,7 @@ func (ie *IfdEnumerate) parseThumbnail(offsetIte, lengthIte *IfdTagEntry) (thumb
 }
 
 // Scan enumerates the different EXIF's IFD blocks.
-func (ie *IfdEnumerate) scan(fqIfdName string, ifdOffset uint32, visitor RawTagVisitor, resolveValues bool) (err error) {
+func (ie *IfdEnumerate) scan(fqIfdName string, ifdOffset uint32, visitor interface{}, resolveValues bool) (err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))

ifd_tag_entry.go

@@ -70,9 +70,7 @@ func (ite IfdTagEntry) ValueString(addressableData []byte, byteOrder binary.Byte
 
 		value = fmt.Sprintf("%v", valueRaw)
 	} else {
-		tt := NewTagType(ite.TagType, byteOrder)
-
-		value, err = tt.ResolveAsString(vc, false)
+		value, err = vc.Format()
 		log.PanicIf(err)
 	}
 

parser.go

@@ -0,0 +1,190 @@
+package exif
+
+import (
+	"bytes"
+
+	"encoding/binary"
+
+	"github.com/dsoprea/go-logging"
+)
+
+type Parser struct {
+}
+
+func (p *Parser) ParseBytes(data []byte, unitCount uint32) (value []uint8, err error) {
+	defer func() {
+		if state := recover(); state != nil {
+			err = log.Wrap(state.(error))
+		}
+	}()
+
+	count := int(unitCount)
+
+	if len(data) < (TypeByte.Size() * count) {
+		log.Panic(ErrNotEnoughData)
+	}
+
+	value = []uint8(data[:count])
+
+	return value, nil
+}
+
+// ParseAscii returns a string and auto-strips the trailing NUL character.
+func (p *Parser) ParseAscii(data []byte, unitCount uint32) (value string, err error) {
+	defer func() {
+		if state := recover(); state != nil {
+			err = log.Wrap(state.(error))
+		}
+	}()
+
+	count := int(unitCount)
+
+	if len(data) < (TypeAscii.Size() * count) {
+		log.Panic(ErrNotEnoughData)
+	}
+
+	if len(data) == 0 || data[count-1] != 0 {
+		s := string(data[:count])
+		typeLogger.Warningf(nil, "ascii not terminated with nul as expected: [%v]", s)
+
+		return s, nil
+	} else {
+		// Auto-strip the NUL from the end. It serves no purpose outside of
+		// encoding semantics.
+
+		return string(data[:count-1]), nil
+	}
+}
+
+// ParseAsciiNoNul returns a string without any consideration for a trailing NUL
+// character.
+func (p *Parser) ParseAsciiNoNul(data []byte, unitCount uint32) (value string, err error) {
+	defer func() {
+		if state := recover(); state != nil {
+			err = log.Wrap(state.(error))
+		}
+	}()
+
+	count := int(unitCount)
+
+	if len(data) < (TypeAscii.Size() * count) {
+		log.Panic(ErrNotEnoughData)
+	}
+
+	return string(data[:count]), nil
+}
+
+func (p *Parser) ParseShorts(data []byte, unitCount uint32, byteOrder binary.ByteOrder) (value []uint16, err error) {
+	defer func() {
+		if state := recover(); state != nil {
+			err = log.Wrap(state.(error))
+		}
+	}()
+
+	count := int(unitCount)
+
+	if len(data) < (TypeShort.Size() * count) {
+		log.Panic(ErrNotEnoughData)
+	}
+
+	value = make([]uint16, count)
+	for i := 0; i < count; i++ {
+		value[i] = byteOrder.Uint16(data[i*2:])
+	}
+
+	return value, nil
+}
+
+func (p *Parser) ParseLongs(data []byte, unitCount uint32, byteOrder binary.ByteOrder) (value []uint32, err error) {
+	defer func() {
+		if state := recover(); state != nil {
+			err = log.Wrap(state.(error))
+		}
+	}()
+
+	count := int(unitCount)
+
+	if len(data) < (TypeLong.Size() * count) {
+		log.Panic(ErrNotEnoughData)
+	}
+
+	value = make([]uint32, count)
+	for i := 0; i < count; i++ {
+		value[i] = byteOrder.Uint32(data[i*4:])
+	}
+
+	return value, nil
+}
+
+func (p *Parser) ParseRationals(data []byte, unitCount uint32, byteOrder binary.ByteOrder) (value []Rational, err error) {
+	defer func() {
+		if state := recover(); state != nil {
+			err = log.Wrap(state.(error))
+		}
+	}()
+
+	count := int(unitCount)
+
+	if len(data) < (TypeRational.Size() * count) {
+		log.Panic(ErrNotEnoughData)
+	}
+
+	value = make([]Rational, count)
+	for i := 0; i < count; i++ {
+		value[i].Numerator = byteOrder.Uint32(data[i*8:])
+		value[i].Denominator = byteOrder.Uint32(data[i*8+4:])
+	}
+
+	return value, nil
+}
+
+func (p *Parser) ParseSignedLongs(data []byte, unitCount uint32, byteOrder binary.ByteOrder) (value []int32, err error) {
+	defer func() {
+		if state := recover(); state != nil {
+			err = log.Wrap(state.(error))
+		}
+	}()
+
+	count := int(unitCount)
+
+	if len(data) < (TypeSignedLong.Size() * count) {
+		log.Panic(ErrNotEnoughData)
+	}
+
+	b := bytes.NewBuffer(data)
+
+	value = make([]int32, count)
+	for i := 0; i < count; i++ {
+		err := binary.Read(b, byteOrder, &value[i])
+		log.PanicIf(err)
+	}
+
+	return value, nil
+}
+
+func (p *Parser) ParseSignedRationals(data []byte, unitCount uint32, byteOrder binary.ByteOrder) (value []SignedRational, err error) {
+	defer func() {
+		if state := recover(); state != nil {
+			err = log.Wrap(state.(error))
+		}
+	}()
+
+	count := int(unitCount)
+
+	if len(data) < (TypeSignedRational.Size() * count) {
+		log.Panic(ErrNotEnoughData)
+	}
+
+	b := bytes.NewBuffer(data)
+
+	value = make([]SignedRational, count)
+	for i := 0; i < count; i++ {
+		err = binary.Read(b, byteOrder, &value[i].Numerator)
+		log.PanicIf(err)
+
+		err = binary.Read(b, byteOrder, &value[i].Denominator)
+		log.PanicIf(err)
+	}
+
+	return value, nil
+}