type.go: Deinegrated `ErrUnhandledUnknownTypedTag`

Not actually used anywhere.

README.md

@@ -186,13 +186,9 @@ visitor := func(fqIfdPath string, ifdIndex int, tagId uint16, tagType exif.TagTy
     valueString := ""
     if tagType.Type() == exif.TypeUndefined {
         value, err := exif.UndefinedValue(ifdPath, tagId, valueContext, tagType.ByteOrder())
-        if log.Is(err, exif.ErrUnhandledUnknownTypedTag) {
-            valueString = "!UNDEFINED!"
-        } else if err != nil {
-            panic(err)
-        } else {
-            valueString = fmt.Sprintf("%v", value)
-        }
+        log.PanicIf(err)
+
+        valueString = fmt.Sprintf("%v", value)
     } else {
         valueString, err = tagType.ResolveAsString(valueContext, true)
         if err != nil {

exif-read-tool/main.go

@@ -109,13 +109,9 @@ func main() {
 		if tagType.Type() == exif.TypeUndefined {
 			var err error
 			value, err = valueContext.Undefined()
-			if log.Is(err, exif.ErrUnhandledUnknownTypedTag) {
-				value = nil
-			} else if err != nil {
-				log.Panic(err)
-			} else {
-				valueString = fmt.Sprintf("%v", value)
-			}
+			log.PanicIf(err)
+
+			valueString = fmt.Sprintf("%v", value)
 		} else {
 			valueString, err = valueContext.FormatFirst()
 			log.PanicIf(err)

exif_test.go

@@ -82,13 +82,9 @@ func TestVisit(t *testing.T) {
 		valueString := ""
 		if tagType.Type() == TypeUndefined {
 			value, err := valueContext.Undefined()
-			if log.Is(err, ErrUnhandledUnknownTypedTag) {
-				valueString = "!UNDEFINED!"
-			} else if err != nil {
-				log.Panic(err)
-			} else {
-				valueString = fmt.Sprintf("%v", value)
-			}
+			log.PanicIf(err)
+
+			valueString = fmt.Sprintf("%v", value)
 		} else {
 			valueString, err = valueContext.FormatFirst()
 			log.PanicIf(err)

ifd_builder.go

@@ -1135,14 +1135,9 @@ func (ib *IfdBuilder) AddTagsFromExisting(ifd *Ifd, itevr *IfdTagEntryValueResol
 
 				// TODO(dustin): !! Not correct. If we're adding from existing and it's an unknown-type tag that we can't parse, we're just going to be seting the placeholder even though there's nothing stopping us from just taking the raw bytes (other than some design decisions that we'd have to make in order to do this).
 
+				// TODO(dustin): !! This probably isn't correct. This will only work if the type is a one-byte type (e.g. ascii, bytes). Otherwise, we'll be reading the wrong number of bytes.
 				valueBytes, err := itevr.ValueBytes(ite)
-				if err != nil {
-					if log.Is(err, ErrUnhandledUnknownTypedTag) == true {
-						valueBytes = []byte(UnparseableUnknownTagValuePlaceholder)
-					} else {
-						log.Panic(err)
-					}
-				}
+				log.PanicIf(err)
 
 				value = NewIfdBuilderTagValueFromBytes(valueBytes)
 			}

ifd_enumerate.go

@@ -240,31 +240,24 @@ func (ie *IfdEnumerate) resolveTagValue(ite *IfdTagEntry) (valueBytes []byte, is
 		valueContext := ie.GetValueContext(ite)
 
 		value, err := valueContext.Undefined()
-		if err != nil {
-			if log.Is(err, ErrUnhandledUnknownTypedTag) == true {
-				valueBytes = []byte(UnparseableUnknownTagValuePlaceholder)
-				return valueBytes, true, nil
-			} else {
-				log.Panic(err)
-			}
-		} else {
-			switch value.(type) {
-			case []byte:
-				return value.([]byte), false, nil
-			case TagUnknownType_UnknownValue:
-				b := []byte(value.(TagUnknownType_UnknownValue))
-				return b, false, nil
-			case string:
-				return []byte(value.(string)), false, nil
-			case UnknownTagValue:
-				valueBytes, err := value.(UnknownTagValue).ValueBytes()
-				log.PanicIf(err)
+		log.PanicIf(err)
 
-				return valueBytes, false, nil
-			default:
-				// TODO(dustin): !! Finish translating the rest of the types (make reusable and replace into other similar implementations?)
-				log.Panicf("can not produce bytes for unknown-type tag (0x%04x) (1): [%s]", ite.TagId, reflect.TypeOf(value))
-			}
+		switch value.(type) {
+		case []byte:
+			return value.([]byte), false, nil
+		case TagUnknownType_UnknownValue:
+			b := []byte(value.(TagUnknownType_UnknownValue))
+			return b, false, nil
+		case string:
+			return []byte(value.(string)), false, nil
+		case UnknownTagValue:
+			valueBytes, err := value.(UnknownTagValue).ValueBytes()
+			log.PanicIf(err)
+
+			return valueBytes, false, nil
+		default:
+			// TODO(dustin): !! Finish translating the rest of the types (make reusable and replace into other similar implementations?)
+			log.Panicf("can not produce bytes for unknown-type tag (0x%04x) (1): [%s]", ite.TagId, reflect.TypeOf(value))
 		}
 	} else {
 		originalType := NewTagType(ite.TagType, ie.byteOrder)
@@ -716,13 +709,7 @@ func (ifd *Ifd) printTagTree(populateValues bool, index, level int, nextLink boo
 				var err error
 
 				value, err = ifd.TagValue(tag)
-				if err != nil {
-					if log.Is(err, ErrUnhandledUnknownTypedTag) == true {
-						value = UnparseableUnknownTagValuePlaceholder
-					} else {
-						log.Panic(err)
-					}
-				}
+				log.PanicIf(err)
 			}
 
 			fmt.Printf("%s - TAG: %s NAME=[%s] VALUE=[%v]\n", indent, tag, tagName, value)

tags_unknown.go

@@ -11,10 +11,6 @@ import (
 	"github.com/dsoprea/go-logging"
 )
 
-const (
-	UnparseableUnknownTagValuePlaceholder = "!UNKNOWN"
-)
-
 const (
 	TagUnknownType_9298_UserComment_Encoding_ASCII     = iota
 	TagUnknownType_9298_UserComment_Encoding_JIS       = iota
@@ -401,7 +397,4 @@ func UndefinedValue(ifdPath string, tagId uint16, valueContext interface{}, byte
 
 	tutuv := TagUnknownType_UnknownValue(valueBytes)
 	return tutuv, nil
-
-	// log.Panic(ErrUnhandledUnknownTypedTag)
-	// return nil, nil
 }

type.go

@@ -84,11 +84,6 @@ var (
     // ErrWrongType is used when we try to parse anything other than the
     // current type.
     ErrWrongType = errors.New("wrong type, can not parse")
-
-    // ErrUnhandledUnknownTag is used when we try to parse a tag that's
-    // recorded as an "unknown" type but not a documented tag (therefore
-    // leaving us not knowning how to read it).
-    ErrUnhandledUnknownTypedTag = errors.New("not a standard unknown-typed tag")
 )
 
 type Rational struct {

utility.go

@@ -182,18 +182,10 @@ func GetFlatExifData(exifData []byte) (exifTags []ExifTag, err error) {
             }
 
             value, err := ifd.TagValue(ite)
-            if err != nil {
-                if log.Is(err, ErrUnhandledUnknownTypedTag) == true {
-                    value = UnparseableUnknownTagValuePlaceholder
-                } else {
-                    log.Panic(err)
-                }
-            }
+            log.PanicIf(err)
 
             valueBytes, err := ifd.TagValueBytes(ite)
-            if err != nil && log.Is(err, ErrUnhandledUnknownTypedTag) == false {
-                log.Panic(err)
-            }
+            log.PanicIf(err)
 
             et := ExifTag{
                 IfdPath:      ifd.IfdPath,