func init() { gob.RegisterName("perm.Permission", Permission{}) gob.RegisterName("perm.PermissionSet", PermissionSet{}) gob.RegisterName("perm.Implication", Implication{}) gob.RegisterName("perm.ImplicationSet", ImplicationSet{}) gob.RegisterName("perm.Condition", Condition{}) }
func init() { // implements error gob.RegisterName("*udpapi.APIError", &APIError{}) // implements APIReply gob.RegisterName("*udpapi.errorWrapper", &errorWrapper{}) // implements APIReply gob.RegisterName("*udpapi.genericReply", &genericReply{}) }
func init() { gob.RegisterName("monsti.NodeContextArgs", NodeContextArgs{}) gob.RegisterName("monsti.NodeContextRet", NodeContextRet{}) gob.RegisterName("monsti.RenderNodeArgs", RenderNodeArgs{}) gob.RegisterName("monsti.RenderNodeRet", RenderNodeRet{}) gob.Register(new(template.HTML)) gob.Register(new(htmlwidgets.RenderData)) }
func init() { // register oauthmw stores for use by gob.encode/decode (ie various binary sessionmw.Store types) gob.RegisterName("knq.oauthmw.Store", Store{}) gob.RegisterName("knq.oauthmw.StoreState", StoreState{}) // register oauthmw for use with jsonstore //jsonstore.RegisterSchema("knq.oauthmw.Store", Store{}) //jsonstore.RegisterSchema("knq.oauthmw.StoreState", StoreState{}) }
func init() { // To make it possible to save the inventory, all object types have to be registered with gob. // Use strings of one character to save bandwidth. // If the letter for a type is changed, it will be lost for all inventories using the type. gob.RegisterName("P", &Potion{}) gob.RegisterName("W", &Weapon{}) gob.RegisterName("A", &Armor{}) gob.RegisterName("H", &Helmet{}) gob.RegisterName("S", &Scroll{}) }
func init() { gob.RegisterName("conf_value_string", *(&ctypes.ConfigValueStr{})) gob.RegisterName("conf_value_int", *(&ctypes.ConfigValueInt{})) gob.RegisterName("conf_value_float", *(&ctypes.ConfigValueFloat{})) gob.RegisterName("conf_value_bool", *(&ctypes.ConfigValueBool{})) gob.RegisterName("conf_policy_node", cpolicy.NewPolicyNode()) gob.RegisterName("conf_data_node", &cdata.ConfigDataNode{}) gob.RegisterName("conf_policy_string", &cpolicy.StringRule{}) gob.RegisterName("conf_policy_int", &cpolicy.IntRule{}) gob.RegisterName("conf_policy_float", &cpolicy.FloatRule{}) gob.RegisterName("conf_policy_bool", &cpolicy.BoolRule{}) }
func init() { gob.RegisterName("AE", new(raft.AppendEntries)) gob.RegisterName("AP", new(raft.AppendReply)) gob.RegisterName("CE", new(raft.ClientEntry)) gob.RegisterName("VQ", new(raft.VoteRequest)) gob.RegisterName("VP", new(raft.VoteReply)) gob.RegisterName("SR", new(store.ReqRead)) gob.RegisterName("SW", new(store.ReqWrite)) gob.RegisterName("SC", new(store.ReqCaS)) gob.RegisterName("SD", new(store.ReqDelete)) }
// Registers a new type of component with a factory to make it, it is expected to be called during initialization // Name must be unique, component_data must be func RegisterComponentType(name string, component_factory func() Component, data Data) (registered_type Type) { // Not to be called after finalizing registration if registration_finalized { panic("component.RegisterComponentType called after component.FinalizeRegistration") } if component_factory == nil { panic("component_factory is nil") } if data == nil { panic("data is nil") } // See if this was already registered if _, ok := name_to_registered_type_map[name]; ok { panic(name + " was already Registered.") } // Return a new Type, but we can't give it a real value until FinalizeRegistration is called registered_type = Type(new(int)) *registered_type = -1 // Store the name, type, and factory_data name_to_registered_type_map[name] = registered_type registered_type_name_list = append(registered_type_name_list, name) temp_component_factories[name] = factory_data{component_factory: component_factory, data: data} // Reserve some space registered_initialize_types.AddNewRegistrationID() registered_destroy_types.AddNewRegistrationID() gob.RegisterName(name, data.(interface{})) return }
func init() { var err error MyNode.Host, err = os.Hostname() if err != nil { panic(err) } gob.RegisterName("NodeInfo", NodeInfo{}) }
func init() { gob.RegisterName("AE", new(raft.AppendEntries)) gob.RegisterName("AP", new(raft.AppendReply)) gob.RegisterName("CE", new(raft.ClientEntry)) gob.RegisterName("VQ", new(raft.VoteRequest)) gob.RegisterName("VP", new(raft.VoteReply)) gob.RegisterName("MR", new(MachnRead)) gob.RegisterName("MU", new(MachnUpdate)) }
// 注册 Type func (self *typeContainer) RegisterType(typ reflect.Type) { realType := FromPtrType(typ) realTypeHashCode := GetTypeInfo(realType).HashCode().String() if self.mapper[realTypeHashCode] == nil { self.mapper[realTypeHashCode] = realType gob.RegisterName(realTypeHashCode, reflect.New(realType).Interface()) switch realType.Kind() { case reflect.Array, reflect.Slice: self.RegisterType(realType.Elem()) } } }
// EmitSignal emits the named signal with given arguments and return // value. func (s *MonstiClient) EmitSignal(name string, args interface{}, retarg interface{}) error { if s.Error != nil { return s.Error } gob.RegisterName(name+"Ret", reflect.Zero( reflect.TypeOf(retarg).Elem().Elem()).Interface()) gob.RegisterName(name+"Args", args) var args_ struct { Name string Args []byte } buffer := &bytes.Buffer{} enc := gob.NewEncoder(buffer) err := enc.Encode(argWrap{args}) if err != nil { return fmt.Errorf("service: Could not encode signal argumens: %v", err) } args_.Name = name args_.Args = buffer.Bytes() var ret [][]byte err = s.RPCClient.Call("Monsti.EmitSignal", args_, &ret) if err != nil { return fmt.Errorf("service: Monsti.EmitSignal error: %v", err) } reflect.ValueOf(retarg).Elem().Set(reflect.MakeSlice( reflect.TypeOf(retarg).Elem(), len(ret), len(ret))) for i, answer := range ret { buffer = bytes.NewBuffer(answer) dec := gob.NewDecoder(buffer) var ret_ argWrap err = dec.Decode(&ret_) if err != nil { return fmt.Errorf("service: Could not decode signal return value: %v", err) } reflect.ValueOf(retarg).Elem().Index(i).Set(reflect.ValueOf(ret_.Wrap)) } return nil }
func register(e interface{}, t reflect.Type) { registerLock.Lock() defer registerLock.Unlock() defer func() { recover() // The only panic that we can get is from trying to register a base type. registered[t] = struct{}{} // Remember for next time. }() if _, exists := registered[t]; !exists { registered[t] = struct{}{} gob.RegisterName(fmt.Sprintf("ℳ%d", nextID), e) nextID++ } }
func init() { var err error mongo_server := os.Getenv("OPENSHIFT_MONGODB_DB_URL") if mongo_server == "" { db_session, err = mgo.Dial("localhost") } else { db_session, err = mgo.Dial(mongo_server + MONGO_DB_NAME) } if err != nil { log.Print("db connection: ", err) } // register bson's ObjectId with the gob for cookie encoding gob.Register(bson.ObjectId("")) gob.RegisterName("app/models.Flash", &Flash{"", ""}) gob.RegisterName("app/models.Filter", &Filter{}) database = db_session.DB("").Name Router = pat.New() //create an index for the email field on the users collection if err := db_session.DB(database).C("users").EnsureIndex(mgo.Index{ Key: []string{"email"}, Unique: true, }); err != nil { log.Print("context: ", err) } if err := db_session.DB(database).C("users").EnsureIndexKey("location"); err != nil { log.Print("context: ", err) } if err := db_session.DB(database).C("users").EnsureIndexKey("country"); err != nil { log.Print("context: ", err) } store = sessions.NewCookieStore([]byte("508a664e65427d3f91000001")) if sentry, err = raven.NewClient(SENTRY_DSN); err != nil { log.Print("could not connect to sentry: ", err) } loadTranslations() }
func (webApp *webApplication) init() { database, err := sql.Open("mysql", "root:pawpisfsu@/rielpoker") if err != nil { panic(err) } gob.RegisterName("user", &users.User{}) webApp.db = database webApp.store = sessions.NewCookieStore([]byte("something-very-secret")) webApp.templ = template.Must(template.ParseGlob("/home/leebc/go/src/github.com/rp/src/poker2/views/templates/*")).Funcs( template.FuncMap{ "eq": func(x, b bool) bool { return x == b }, }) }
func TestSerializeDecoder(t *testing.T) { println("serialize decoder test start") loc := MediaLocator{Filename: "../../../target/dependency/fixtures/testfile.flv"} source := DataSource{Locator: loc} result := source.Connect() if result != nil { t.Fatalf("cold not open file : %s", loc.Filename) } plex := NewDemultiplexer(&source) //tracks:=plex.GetTracks() tracks := plex.GetTracks() for i := 0; i < len(tracks); i++ { dec := tracks[i].GetDecoder() //dec.Open() params := dec.GetParameters() dec2 := Decoder{} for k, v := range params { dec2.SetParameter(k, v) } dec2.Open() gob.RegisterName("NewTypeObject", Packet{}) b := new(bytes.Buffer) enc := gob.NewEncoder(b) err := enc.Encode(dec) if err != nil { fmt.Printf("%s\n", err) //return err break } bdec := gob.NewDecoder(b) err = bdec.Decode(dec) if err != nil { fmt.Printf("%s\n", err) break //return err } } println("serialize decoder test finished") }
/* Register all types */ func init() { gob.RegisterName("service.HelloMsg", HelloMsg{}) gob.RegisterName("service.AuthenticateMsg", AuthenticateMsg{}) gob.RegisterName("service.AuthenticationFailedMsg", AuthenticationFailedMsg{}) gob.RegisterName("service.AuthenticationSucceededMsg", AuthenticationSucceededMsg{}) gob.RegisterName("service.ConnectDeviceApprovedMsg", ConnectDeviceApprovedMsg{}) gob.RegisterName("service.ConnectDeviceDeclinedMsg", ConnectDeviceDeclinedMsg{}) gob.RegisterName("service.ConnectDeviceMsg", ConnectDeviceMsg{}) gob.RegisterName("service.DisconnectDeviceMsg", DisconnectDeviceMsg{}) gob.RegisterName("service.GetRFAddrMsg", GetRFAddrMsg{}) gob.RegisterName("service.GetTimeMsg", GetTimeMsg{}) gob.RegisterName("service.GetTypeMsg", GetTypeMsg{}) gob.RegisterName("service.HelloMsg", HelloMsg{}) gob.RegisterName("service.JoinRequestApprovedMsg", JoinRequestApprovedMsg{}) gob.RegisterName("service.JoinRequestDeclinedMsg", JoinRequestDeclinedMsg{}) gob.RegisterName("service.JoinRequestMsg", JoinRequestMsg{}) gob.RegisterName("service.JoinRequestPendingMsg", JoinRequestPendingMsg{}) gob.RegisterName("service.MoveDeviceMsg", MoveDeviceMsg{}) gob.RegisterName("service.NoTypeMsg", NoTypeMsg{}) gob.RegisterName("service.RFAddrMsg", RFAddrMsg{}) gob.RegisterName("service.RawSensorData", RawSensorData{}) gob.RegisterName("service.SensorDataMsg", SensorDataMsg{}) gob.RegisterName("service.SensorDataSyncedMsg", SensorDataSyncedMsg{}) gob.RegisterName("service.ServerMessage", ServerMessage{}) gob.RegisterName("service.TimeMsg", TimeMsg{}) gob.RegisterName("service.TypeMsg", TypeMsg{}) }
func init() { // implements APIReply gob.RegisterName("*udpapi.UptimeReply", &UptimeReply{}) // implements APIReply gob.RegisterName("*udpapi.PingReply", &PingReply{}) }
func init() { gob.RegisterName("NameServiceAddInodeRequest", &NameServiceAddInodeRequest{}) }
func init() { // Register the types we'll need when we add them to our auth // cookies. gob.RegisterName("main.User", &User{}) }
func init() { gob.RegisterName("main.CrawlingEntry", CrawlingEntry{}) }
func init() { var dist *Distribution gob.RegisterName("*scotty.messages.Distribution", dist) }
func init() { gob.RegisterName("monsti.NodeContextArgs", NodeContextArgs{}) gob.RegisterName("monsti.NodeContextRet", NodeContextRet{}) }
func init() { gob.RegisterName("flow", FlowState{}) }
func init() { gob.RegisterName("LogEntry", LogEntry{}) }
func init() { gob.RegisterName("Proposal", Proposal{}) }
func init() { gob.RegisterName("knq.kv.testData", testData{}) }
func RegisterName(name string, value interface{}) { gob.RegisterName(name, value) }
func init() { gob.RegisterName("monsti.NodeContextArgs", NodeContextArgs{}) gob.RegisterName("monsti.NodeContextRet", map[string]string{}) }
func init() { ino := Inode{} gob.RegisterName("Inode", &ino) gob.RegisterName("Block", Block{}) }