Generic function to store Go Encoded Data

I need to write a generic function which can store objects as gobjects.

func hash_store(data map[string]string) {
  //initialize a *bytes.Buffer
  m := new(bytes.Buffer) 
  //the *bytes.Buffer satisfies the io.Writer interface and can
  //be used in gob.NewEncoder() 
  enc := gob.NewEncoder(m)
  //gob.Encoder has method Encode that accepts data items as parameter
  enc.Encode(data)
  //the bytes.Buffer type has method Bytes() that returns type []byte, 
  //and can be used as a parameter in ioutil.WriteFile() 
  err := ioutil.WriteFile("dep_data", m.Bytes(), 0600) 
  if err != nil {
          panic(err)
  }
  fmt.Printf("just saved all depinfo with %v\n", data)

  n,err := ioutil.ReadFile("dep_data")
        if err != nil {
                fmt.Printf("cannot read file")
                panic(err)
        } 
        //create a bytes.Buffer type with n, type []byte
        p := bytes.NewBuffer(n) 
        //bytes.Buffer satisfies the interface for io.Writer and can be used
        //in gob.NewDecoder() 
        dec := gob.NewDecoder(p)
        //make a map reference type that we'll populate with the decoded gob 
        //e := make(map[int]string)
         e := make(map[string]string)
        //we must decode into a pointer, so we'll take the address of e 
        err = dec.Decode(&e)
        if err != nil {
                fmt.Printf("cannot decode")
                panic(err)
        }

        fmt.Println("after reading dep_data printing ",e)
}

In this function I know the data type to be stored in map[string]string . But I need to write a generic function where I don't know data type and still store it as a gobject in a file.

Change your concrete type (map[string]string) to the empty interface type (interface{}).
See this related question why this works.

Encoding:

func store(data interface{}) {
  m := new(bytes.Buffer) 
  enc := gob.NewEncoder(m)

  err := enc.Encode(data)
  if err != nil { panic(err) }

  err = ioutil.WriteFile("dep_data", m.Bytes(), 0600) 
  if err != nil { panic(err) }
}

Decoding:

func load(e interface{}) {
	n,err := ioutil.ReadFile("dep_data")
	if err != nil { panic(err) } 

	p := bytes.NewBuffer(n) 
	dec := gob.NewDecoder(p)

	err = dec.Decode(e)
	if err != nil { panic(err) }
}

The value you put in load must be a pointer of the type you stored in the file using gob.

Example for map[string]string:

org := map[string]string{"foo": "bar"}
store(org)

var loadedMap map[string]string
load(&loadedMap)

fmt.Println(loadedMap["foo"]) // bar

When you encode the data, give the Encoder a *interface{}, then you can decoded with a *interface{}

var to_enc interface{} = ...;
god.NewEncoder(...).Encode(&to_enc);
...
var to_dec interface{}
god.NewDecoder(...).Decode(&to_dec);