From 4f2f9044e60d16b189cd13acf41089dd83c79c0e Mon Sep 17 00:00:00 2001 From: Dustin Oprea Date: Tue, 31 Dec 2019 07:38:25 -0500 Subject: [PATCH] type.go: Deinegrated `ErrUnhandledUnknownTypedTag` Not actually used anywhere. --- README.md | 10 +++------ exif-read-tool/main.go | 10 +++------ exif_test.go | 10 +++------ ifd_builder.go | 9 ++------ ifd_enumerate.go | 49 ++++++++++++++++-------------------------- tags_unknown.go | 7 ------ type.go | 5 ----- utility.go | 12 ++--------- 8 files changed, 31 insertions(+), 81 deletions(-) diff --git a/README.md b/README.md index f41529f..3547f8b 100644 --- a/README.md +++ b/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 { diff --git a/exif-read-tool/main.go b/exif-read-tool/main.go index ca513a2..074ca2d 100644 --- a/exif-read-tool/main.go +++ b/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) diff --git a/exif_test.go b/exif_test.go index 8d4c4fc..b4464a7 100644 --- a/exif_test.go +++ b/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) diff --git a/ifd_builder.go b/ifd_builder.go index 9589dad..ecb9589 100644 --- a/ifd_builder.go +++ b/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) } diff --git a/ifd_enumerate.go b/ifd_enumerate.go index 49044e3..21139b7 100644 --- a/ifd_enumerate.go +++ b/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) diff --git a/tags_unknown.go b/tags_unknown.go index b2036b6..df53813 100644 --- a/tags_unknown.go +++ b/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 } diff --git a/type.go b/type.go index 0d635b7..0782c6f 100644 --- a/type.go +++ b/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 { diff --git a/utility.go b/utility.go index 1df1162..677910f 100644 --- a/utility.go +++ b/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,