gtsocial-umbx

string.go (6029B)

---

 package mp4
 
 import (
 	"bytes"
 	"fmt"
 	"io"
 	"reflect"
 	"strconv"
 
 	"github.com/abema/go-mp4/util"
 )
 
 type stringifier struct {
 	buf    *bytes.Buffer
 	src    IImmutableBox
 	indent string
 	ctx    Context
 }
 
 func Stringify(src IImmutableBox, ctx Context) (string, error) {
 	return StringifyWithIndent(src, "", ctx)
 }
 
 func StringifyWithIndent(src IImmutableBox, indent string, ctx Context) (string, error) {
 	boxDef := src.GetType().getBoxDef(ctx)
 	if boxDef == nil {
 		return "", ErrBoxInfoNotFound
 	}
 
 	v := reflect.ValueOf(src).Elem()
 
 	m := &stringifier{
 		buf:    bytes.NewBuffer(nil),
 		src:    src,
 		indent: indent,
 		ctx:    ctx,
 	}
 
 	err := m.stringifyStruct(v, boxDef.fields, 0, true)
 	if err != nil {
 		return "", err
 	}
 
 	return m.buf.String(), nil
 }
 
 func (m *stringifier) stringify(v reflect.Value, fi *fieldInstance, depth int) error {
 	switch v.Type().Kind() {
 	case reflect.Ptr:
 		return m.stringifyPtr(v, fi, depth)
 	case reflect.Struct:
 		return m.stringifyStruct(v, fi.children, depth, fi.is(fieldExtend))
 	case reflect.Array:
 		return m.stringifyArray(v, fi, depth)
 	case reflect.Slice:
 		return m.stringifySlice(v, fi, depth)
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		return m.stringifyInt(v, fi, depth)
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
 		return m.stringifyUint(v, fi, depth)
 	case reflect.Bool:
 		return m.stringifyBool(v, depth)
 	case reflect.String:
 		return m.stringifyString(v, depth)
 	default:
 		return fmt.Errorf("unsupported type: %s", v.Type().Kind())
 	}
 }
 
 func (m *stringifier) stringifyPtr(v reflect.Value, fi *fieldInstance, depth int) error {
 	return m.stringify(v.Elem(), fi, depth)
 }
 
 func (m *stringifier) stringifyStruct(v reflect.Value, fs []*field, depth int, extended bool) error {
 	if !extended {
 		m.buf.WriteString("{")
 		if m.indent != "" {
 			m.buf.WriteString("\n")
 		}
 		depth++
 	}
 
 	for _, f := range fs {
 		fi := resolveFieldInstance(f, m.src, v, m.ctx)
 
 		if !isTargetField(m.src, fi, m.ctx) {
 			continue
 		}
 
 		if f.cnst != "" || f.is(fieldHidden) {
 			continue
 		}
 
 		if !f.is(fieldExtend) {
 			if m.indent != "" {
 				writeIndent(m.buf, m.indent, depth+1)
 			} else if m.buf.Len() != 0 && m.buf.Bytes()[m.buf.Len()-1] != '{' {
 				m.buf.WriteString(" ")
 			}
 			m.buf.WriteString(f.name)
 			m.buf.WriteString("=")
 		}
 
 		str, ok := fi.cfo.StringifyField(f.name, m.indent, depth+1, m.ctx)
 		if ok {
 			m.buf.WriteString(str)
 			if !f.is(fieldExtend) && m.indent != "" {
 				m.buf.WriteString("\n")
 			}
 			continue
 		}
 
 		if f.name == "Version" {
 			m.buf.WriteString(strconv.Itoa(int(m.src.GetVersion())))
 		} else if f.name == "Flags" {
 			fmt.Fprintf(m.buf, "0x%06x", m.src.GetFlags())
 		} else {
 			err := m.stringify(v.FieldByName(f.name), fi, depth)
 			if err != nil {
 				return err
 			}
 		}
 
 		if !f.is(fieldExtend) && m.indent != "" {
 			m.buf.WriteString("\n")
 		}
 	}
 
 	if !extended {
 		if m.indent != "" {
 			writeIndent(m.buf, m.indent, depth)
 		}
 		m.buf.WriteString("}")
 	}
 
 	return nil
 }
 
 func (m *stringifier) stringifyArray(v reflect.Value, fi *fieldInstance, depth int) error {
 	begin, sep, end := "[", ", ", "]"
 	if fi.is(fieldString) || fi.is(fieldISO639_2) {
 		begin, sep, end = "\"", "", "\""
 	} else if fi.is(fieldUUID) {
 		begin, sep, end = "", "", ""
 	}
 
 	m.buf.WriteString(begin)
 
 	m2 := *m
 	if fi.is(fieldString) {
 		m2.buf = bytes.NewBuffer(nil)
 	}
 	size := v.Type().Size()
 	for i := 0; i < int(size)/int(v.Type().Elem().Size()); i++ {
 		if i != 0 {
 			m2.buf.WriteString(sep)
 		}
 
 		if err := m2.stringify(v.Index(i), fi, depth+1); err != nil {
 			return err
 		}
 
 		if fi.is(fieldUUID) && (i == 3 || i == 5 || i == 7 || i == 9) {
 			m.buf.WriteString("-")
 		}
 	}
 	if fi.is(fieldString) {
 		m.buf.WriteString(util.EscapeUnprintables(m2.buf.String()))
 	}
 
 	m.buf.WriteString(end)
 
 	return nil
 }
 
 func (m *stringifier) stringifySlice(v reflect.Value, fi *fieldInstance, depth int) error {
 	begin, sep, end := "[", ", ", "]"
 	if fi.is(fieldString) || fi.is(fieldISO639_2) {
 		begin, sep, end = "\"", "", "\""
 	}
 
 	m.buf.WriteString(begin)
 
 	m2 := *m
 	if fi.is(fieldString) {
 		m2.buf = bytes.NewBuffer(nil)
 	}
 	for i := 0; i < v.Len(); i++ {
 		if fi.length != LengthUnlimited && uint(i) >= fi.length {
 			break
 		}
 
 		if i != 0 {
 			m2.buf.WriteString(sep)
 		}
 
 		if err := m2.stringify(v.Index(i), fi, depth+1); err != nil {
 			return err
 		}
 	}
 	if fi.is(fieldString) {
 		m.buf.WriteString(util.EscapeUnprintables(m2.buf.String()))
 	}
 
 	m.buf.WriteString(end)
 
 	return nil
 }
 
 func (m *stringifier) stringifyInt(v reflect.Value, fi *fieldInstance, depth int) error {
 	if fi.is(fieldHex) {
 		val := v.Int()
 		if val >= 0 {
 			m.buf.WriteString("0x")
 			m.buf.WriteString(strconv.FormatInt(val, 16))
 		} else {
 			m.buf.WriteString("-0x")
 			m.buf.WriteString(strconv.FormatInt(-val, 16))
 		}
 	} else {
 		m.buf.WriteString(strconv.FormatInt(v.Int(), 10))
 	}
 	return nil
 }
 
 func (m *stringifier) stringifyUint(v reflect.Value, fi *fieldInstance, depth int) error {
 	if fi.is(fieldISO639_2) {
 		m.buf.WriteString(string([]byte{byte(v.Uint() + 0x60)}))
 	} else if fi.is(fieldUUID) {
 		fmt.Fprintf(m.buf, "%02x", v.Uint())
 	} else if fi.is(fieldString) {
 		m.buf.WriteString(string([]byte{byte(v.Uint())}))
 	} else if fi.is(fieldHex) || (!fi.is(fieldDec) && v.Type().Kind() == reflect.Uint8) || v.Type().Kind() == reflect.Uintptr {
 		m.buf.WriteString("0x")
 		m.buf.WriteString(strconv.FormatUint(v.Uint(), 16))
 	} else {
 		m.buf.WriteString(strconv.FormatUint(v.Uint(), 10))
 	}
 
 	return nil
 }
 
 func (m *stringifier) stringifyBool(v reflect.Value, depth int) error {
 	m.buf.WriteString(strconv.FormatBool(v.Bool()))
 
 	return nil
 }
 
 func (m *stringifier) stringifyString(v reflect.Value, depth int) error {
 	m.buf.WriteString("\"")
 	m.buf.WriteString(util.EscapeUnprintables(v.String()))
 	m.buf.WriteString("\"")
 
 	return nil
 }
 
 func writeIndent(w io.Writer, indent string, depth int) {
 	for i := 0; i < depth; i++ {
 		io.WriteString(w, indent)
 	}
 }