go-hep.org/x/hep@v0.38.1/groot/cmd/root-gen-streamer/main.go (about)

     1  // Copyright ©2018 The go-hep Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Command root-gen-streamer generates a StreamerInfo for ROOT and user types.
     6  package main // import "go-hep.org/x/hep/groot/cmd/root-gen-streamer"
     7  
     8  import (
     9  	"bytes"
    10  	"flag"
    11  	"fmt"
    12  	"io"
    13  	"log"
    14  	"os"
    15  	"strings"
    16  
    17  	"go-hep.org/x/hep/groot/rdict"
    18  )
    19  
    20  var (
    21  	typeNames = flag.String("t", "", "comma-separated list of type names")
    22  	pkgPath   = flag.String("p", "", "package import path")
    23  	output    = flag.String("o", "", "output file name")
    24  	verbose   = flag.Bool("v", false, "enable verbose mode")
    25  )
    26  
    27  func main() {
    28  	log.SetPrefix("root-gen-streamer: ")
    29  	log.SetFlags(0)
    30  
    31  	flag.Usage = func() {
    32  		fmt.Fprintf(
    33  			os.Stderr,
    34  			`Usage: root-gen-streamer [options]
    35  
    36  ex:
    37   $> root-gen-streamer -p image -t Point -o streamers_gen.go
    38   $> root-gen-streamer -p go-hep.org/x/hep/hbook -t Dist0D,Dist1D,Dist2D -o foo_streamer_gen.go
    39  
    40  options:
    41  `,
    42  		)
    43  		flag.PrintDefaults()
    44  	}
    45  
    46  	flag.Parse()
    47  
    48  	if *typeNames == "" {
    49  		flag.Usage()
    50  		os.Exit(2)
    51  	}
    52  
    53  	types := strings.Split(*typeNames, ",")
    54  
    55  	var (
    56  		err error
    57  		out io.WriteCloser
    58  		buf = new(bytes.Buffer)
    59  	)
    60  
    61  	err = generate(buf, *pkgPath, types)
    62  	if err != nil {
    63  		log.Fatal(err)
    64  	}
    65  
    66  	switch *output {
    67  	case "":
    68  		out = os.Stdout
    69  	default:
    70  		out, err = os.Create(*output)
    71  		if err != nil {
    72  			log.Fatal(err)
    73  		}
    74  		defer out.Close()
    75  	}
    76  
    77  	_, err = io.Copy(out, buf)
    78  	if err != nil {
    79  		log.Fatal(err)
    80  	}
    81  
    82  	err = out.Close()
    83  	if err != nil {
    84  		log.Fatal(err)
    85  	}
    86  }
    87  
    88  func generate(w io.Writer, pkg string, types []string) error {
    89  	g, err := rdict.NewGenStreamer(pkg, *verbose)
    90  	if err != nil {
    91  		return err
    92  	}
    93  
    94  	for _, t := range types {
    95  		err := g.Generate(t)
    96  		if err != nil {
    97  			log.Fatal(err)
    98  		}
    99  	}
   100  
   101  	buf, err := g.Format()
   102  	if err != nil {
   103  		return err
   104  	}
   105  
   106  	_, err = w.Write(buf)
   107  	if err != nil {
   108  		return err
   109  	}
   110  
   111  	return nil
   112  }