Golang InitPackage Examples

Example #1

File: generated.go Project: kego/ke

func init() {
	pkg := jsonctx.InitPackage("kego.io/demo/common/words")
	pkg.SetHash(11971197020902887977)
	pkg.Init(
		"localizer",
		func() interface{} { return (*Localizer)(nil) },
		nil,
		func() interface{} { return new(LocalizerRule) },
		func() reflect.Type { return reflect.TypeOf((*Localizer)(nil)).Elem() },
	)

	pkg.Init(
		"simple",
		func() interface{} { return new(Simple) },
		nil,
		func() interface{} { return new(SimpleRule) },
		func() reflect.Type { return reflect.TypeOf((*SimpleInterface)(nil)).Elem() },
	)

	pkg.Init(
		"translation",
		func() interface{} { return new(Translation) },
		nil,
		func() interface{} { return new(TranslationRule) },
		func() reflect.Type { return reflect.TypeOf((*TranslationInterface)(nil)).Elem() },
	)

}

Example #2

File: generated.go Project: kego/ke

func init() {
	pkg := jsonctx.InitPackage("kego.io/tests/data/alias")
	pkg.SetHash(3681006963164671295)
	pkg.Init("alms",
		func() interface{} { return new(Alms) },
		func(in interface{}) interface{} { return *in.(*Alms) },
		func() interface{} { return new(AlmsRule) },
		func() reflect.Type { return reflect.TypeOf((*AlmsInterface)(nil)).Elem() },
	)

	pkg.Init("main",
		func() interface{} { return new(Main) },
		nil,
		func() interface{} { return new(MainRule) },
		func() reflect.Type { return reflect.TypeOf((*MainInterface)(nil)).Elem() },
	)

	pkg.Init("simple",
		func() interface{} { return new(Simple) },
		nil,
		func() interface{} { return new(SimpleRule) },
		func() reflect.Type { return reflect.TypeOf((*SimpleInterface)(nil)).Elem() },
	)

}

Example #3

File: generated.go Project: kego/ke

func init() {
	pkg := jsonctx.InitPackage("kego.io/demo/demo5/translation")
	pkg.SetHash(13251613636822643043)
	pkg.Init(
		"localized",
		func() interface{} { return (*Localized)(nil) },
		nil,
		func() interface{} { return new(LocalizedRule) },
		func() reflect.Type { return reflect.TypeOf((*Localized)(nil)).Elem() },
	)

	pkg.Init(
		"simple",
		func() interface{} { return new(Simple) },
		nil,
		func() interface{} { return new(SimpleRule) },
		func() reflect.Type { return reflect.TypeOf((*SimpleInterface)(nil)).Elem() },
	)

	pkg.Init(
		"smartling",
		func() interface{} { return new(Smartling) },
		nil,
		func() interface{} { return new(SmartlingRule) },
		func() reflect.Type { return reflect.TypeOf((*SmartlingInterface)(nil)).Elem() },
	)

}

Example #4

File: generated.go Project: kego/ke

func init() {
	pkg := jsonctx.InitPackage("kego.io/demo/common/images")
	pkg.SetHash(7237742861799384387)
	pkg.Init(
		"icon",
		func() interface{} { return new(Icon) },
		nil,
		func() interface{} { return new(IconRule) },
		func() reflect.Type { return reflect.TypeOf((*IconInterface)(nil)).Elem() },
	)

	pkg.Init(
		"image",
		func() interface{} { return (*Image)(nil) },
		nil,
		func() interface{} { return new(ImageRule) },
		func() reflect.Type { return reflect.TypeOf((*Image)(nil)).Elem() },
	)

	pkg.Init(
		"photo",
		func() interface{} { return new(Photo) },
		nil,
		func() interface{} { return new(PhotoRule) },
		func() reflect.Type { return reflect.TypeOf((*PhotoInterface)(nil)).Elem() },
	)

}

Example #5

File: generated.go Project: kego/ke

func init() {
	pkg := jsonctx.InitPackage("kego.io/demo/demo8")
	pkg.SetHash(8344646746139445788)
	pkg.Init(
		"page",
		func() interface{} { return new(Page) },
		nil,
		func() interface{} { return new(PageRule) },
		func() reflect.Type { return reflect.TypeOf((*PageInterface)(nil)).Elem() },
	)

}

Example #6

File: generated.go Project: kego/ke

func init() {
	pkg := jsonctx.InitPackage("kego.io/demo/common/units")
	pkg.SetHash(10988868301072060435)
	pkg.Init(
		"rectangle",
		func() interface{} { return new(Rectangle) },
		nil,
		func() interface{} { return new(RectangleRule) },
		func() reflect.Type { return reflect.TypeOf((*RectangleInterface)(nil)).Elem() },
	)

}

Example #7

File: generated.go Project: kego/ke

func init() {
	pkg := jsonctx.InitPackage("kego.io/demo/demo1")
	pkg.SetHash(10713598547770441995)
	pkg.Init(
		"page",
		func() interface{} { return new(Page) },
		nil,
		func() interface{} { return new(PageRule) },
		func() reflect.Type { return reflect.TypeOf((*PageInterface)(nil)).Elem() },
	)

}

Example #8

File: generated.go Project: kego/ke

func init() {
	pkg := jsonctx.InitPackage("kego.io/demo/demo2")
	pkg.SetHash(5277376379671719742)
	pkg.Init(
		"page",
		func() interface{} { return new(Page) },
		nil,
		func() interface{} { return new(PageRule) },
		func() reflect.Type { return reflect.TypeOf((*PageInterface)(nil)).Elem() },
	)

}

Example #9

File: generated.go Project: kego/ke

func init() {
	pkg := jsonctx.InitPackage("kego.io/demo/demo4")
	pkg.SetHash(15041727781809772107)
	pkg.Init(
		"page",
		func() interface{} { return new(Page) },
		nil,
		func() interface{} { return new(PageRule) },
		func() reflect.Type { return reflect.TypeOf((*PageInterface)(nil)).Elem() },
	)

}

Example #10

File: generated.go Project: kego/ke

func init() {
	pkg := jsonctx.InitPackage("kego.io/demo/demo7")
	pkg.SetHash(16224128938049598805)
	pkg.Init(
		"page",
		func() interface{} { return new(Page) },
		nil,
		func() interface{} { return new(PageRule) },
		func() reflect.Type { return reflect.TypeOf((*PageInterface)(nil)).Elem() },
	)

}

Example #11

File: generated.go Project: kego/ke

func init() {
	pkg := jsonctx.InitPackage("kego.io/demo/demo3/images")
	pkg.SetHash(16432779313430741732)
	pkg.Init(
		"photo",
		func() interface{} { return new(Photo) },
		nil,
		func() interface{} { return new(PhotoRule) },
		func() reflect.Type { return reflect.TypeOf((*PhotoInterface)(nil)).Elem() },
	)

}

Example #12

File: generated.go Project: kego/ke

func init() {
	pkg := jsonctx.InitPackage("kego.io/demo/demo9")
	pkg.SetHash(3818513847626526840)
	pkg.Init(
		"person",
		func() interface{} { return new(Person) },
		nil,
		func() interface{} { return new(PersonRule) },
		func() reflect.Type { return reflect.TypeOf((*PersonInterface)(nil)).Elem() },
	)

}

Example #13

File: generated.go Project: kego/ke

func init() {
	pkg := jsonctx.InitPackage("kego.io/demo/demo2/images")
	pkg.SetHash(17974458391396798528)
	pkg.Init(
		"photo",
		func() interface{} { return new(Photo) },
		nil,
		func() interface{} { return new(PhotoRule) },
		func() reflect.Type { return reflect.TypeOf((*PhotoInterface)(nil)).Elem() },
	)

}

Example #14

File: generated.go Project: kego/ke

func init() {
	pkg := jsonctx.InitPackage("kego.io/demo/demo7/images")
	pkg.SetHash(14109639835138036999)
	pkg.Init(
		"photo",
		func() interface{} { return new(Photo) },
		nil,
		func() interface{} { return new(PhotoRule) },
		func() reflect.Type { return reflect.TypeOf((*PhotoInterface)(nil)).Elem() },
	)

}

Example #15

File: generated.go Project: kego/ke

func init() {
	pkg := jsonctx.InitPackage("kego.io/process/validate/tests")
	pkg.SetHash(17573435268142783549)
	pkg.Init(
		"a",
		func() interface{} { return new(A) },
		nil,
		func() interface{} { return new(ARule) },
		func() reflect.Type { return reflect.TypeOf((*AInterface)(nil)).Elem() },
	)

	pkg.Init(
		"b",
		func() interface{} { return new(B) },
		nil,
		func() interface{} { return new(BRule) },
		func() reflect.Type { return reflect.TypeOf((*BInterface)(nil)).Elem() },
	)

	pkg.Init(
		"c",
		func() interface{} { return (*C)(nil) },
		nil,
		func() interface{} { return new(CRule) },
		func() reflect.Type { return reflect.TypeOf((*C)(nil)).Elem() },
	)

	pkg.Init(
		"d",
		func() interface{} { return new(D) },
		nil,
		func() interface{} { return new(DRule) },
		func() reflect.Type { return reflect.TypeOf((*DInterface)(nil)).Elem() },
	)

	pkg.Init(
		"e",
		func() interface{} { return new(E) },
		nil,
		func() interface{} { return new(ERule) },
		func() reflect.Type { return reflect.TypeOf((*EInterface)(nil)).Elem() },
	)

	pkg.Init(
		"f",
		func() interface{} { return new(F) },
		nil,
		func() interface{} { return new(FRule) },
		func() reflect.Type { return reflect.TypeOf((*FInterface)(nil)).Elem() },
	)

}

Example #16

File: generated.go Project: kego/ke

func init() {
	pkg := jsonctx.InitPackage("kego.io/demo/site")
	pkg.SetHash(3726678967244446909)
	pkg.Init(
		"body",
		func() interface{} { return new(Body) },
		nil,
		func() interface{} { return new(BodyRule) },
		func() reflect.Type { return reflect.TypeOf((*BodyInterface)(nil)).Elem() },
	)

	pkg.Init(
		"columns",
		func() interface{} { return new(Columns) },
		nil,
		func() interface{} { return new(ColumnsRule) },
		func() reflect.Type { return reflect.TypeOf((*ColumnsInterface)(nil)).Elem() },
	)

	pkg.Init(
		"hero",
		func() interface{} { return new(Hero) },
		nil,
		func() interface{} { return new(HeroRule) },
		func() reflect.Type { return reflect.TypeOf((*HeroInterface)(nil)).Elem() },
	)

	pkg.Init(
		"page",
		func() interface{} { return new(Page) },
		nil,
		func() interface{} { return new(PageRule) },
		func() reflect.Type { return reflect.TypeOf((*PageInterface)(nil)).Elem() },
	)

	pkg.Init(
		"section",
		func() interface{} { return (*Section)(nil) },
		nil,
		func() interface{} { return new(SectionRule) },
		func() reflect.Type { return reflect.TypeOf((*Section)(nil)).Elem() },
	)

}

Example #17

File: generated.go Project: kego/ke

func init() {
	pkg := jsonctx.InitPackage("kego.io/demo/demo6")
	pkg.SetHash(7465480149826331644)
	pkg.Init(
		"page",
		func() interface{} { return new(Page) },
		nil,
		func() interface{} { return new(PageRule) },
		func() reflect.Type { return reflect.TypeOf((*PageInterface)(nil)).Elem() },
	)

	pkg.Init(
		"person",
		func() interface{} { return new(Person) },
		nil,
		func() interface{} { return new(PersonRule) },
		func() reflect.Type { return reflect.TypeOf((*PersonInterface)(nil)).Elem() },
	)

}

Example #18

File: bootstrap_helpers.go Project: kego/ke

func init() {
	jpkg := jsonctx.InitPackage("kego.io/json")
	jpkg.Init(
		"string",
		func() interface{} { return "" },
		nil,
		func() interface{} { return new(JsonStringRule) },
		nil,
	)
	jpkg.Init(
		"number",
		func() interface{} { return 0.0 },
		nil,
		func() interface{} { return new(JsonNumberRule) },
		nil,
	)
	jpkg.Init(
		"bool",
		func() interface{} { return false },
		nil,
		func() interface{} { return new(JsonBoolRule) },
		nil,
	)
}

Example #19

File: rule.go Project: kego/ke

func init() {
	jsonctx.InitDummy(reflect.TypeOf((*RuleInterface)(nil)).Elem(), reflect.TypeOf(&DummyRule{}))

	pkg := jsonctx.InitPackage("kego.io/system")
	pkg.Dummy("rule", func() interface{} { return new(DummyRule) })
}