// MForeignKey ...
func (cm AsStandard) MForeignKey() *metadata.MForeignKey {
	mfk := metadata.MForeignKey{}
	for _, fk := range cm.Elements[metadata.MIForeignKey.Name] {
		metadata.FieldTransfer(fk.Attr).To(&mfk)
		for _, entry := range fk.Entries() {
			tmp := metadata.ForeignKey{}
			entry.SetFields(&tmp)
			mfk.ForeignKey = append(mfk.ForeignKey, tmp)
		}
	}
	return &mfk
}
// MEditMask ...
func (cm AsStandard) MEditMask(resource string) *metadata.MEditMask {
	mem := metadata.MEditMask{}
	for _, cd := range cm.Elements[metadata.MIEditMask.Name] {
		if cd.Attr["Resource"] != resource {
			continue
		}
		metadata.FieldTransfer(cd.Attr).To(&mem)
		for _, entry := range cd.Entries() {
			tmp := metadata.EditMask{}
			entry.SetFields(&tmp)
			mem.EditMask = append(mem.EditMask, tmp)
		}
	}
	return &mem
}
// MFilter ...
func (cm AsStandard) MFilter() *metadata.MFilter {
	mf := metadata.MFilter{}
	mi := metadata.MIFilter
	for _, cd := range cm.Elements[mi.Name] {
		metadata.FieldTransfer(cd.Attr).To(&mf)
		for _, entry := range cd.Entries() {
			tmp := metadata.Filter{}
			entry.SetFields(&tmp)
			id := mi.ID(tmp)
			tmp.MFilterType = cm.MFilterType(id)
			mf.Filter = append(mf.Filter, tmp)
		}
	}
	return &mf
}
// MUpdateHelp ...
func (cm AsStandard) MUpdateHelp(resource string) *metadata.MUpdateHelp {
	muh := metadata.MUpdateHelp{}
	for _, cd := range cm.Elements[metadata.MIUpdateHelp.Name] {
		if cd.Attr["Resource"] != resource {
			continue
		}
		metadata.FieldTransfer(cd.Attr).To(&muh)
		for _, entry := range cd.Entries() {
			tmp := metadata.UpdateHelp{}
			entry.SetFields(&tmp)
			muh.UpdateHelp = append(muh.UpdateHelp, tmp)
		}
	}
	return &muh
}
// MSearchHelp ...
func (cm AsStandard) MSearchHelp(resource string) *metadata.MSearchHelp {
	msh := metadata.MSearchHelp{}
	mi := metadata.MISearchHelp
	for _, cd := range cm.Elements[mi.Name] {
		if cd.Attr["Resource"] != resource {
			continue
		}
		metadata.FieldTransfer(cd.Attr).To(&msh)
		for _, entry := range cd.Entries() {
			tmp := metadata.SearchHelp{}
			entry.SetFields(&tmp)
			msh.SearchHelp = append(msh.SearchHelp, tmp)
		}
	}
	return &msh
}
// SetValidationExpressions ...
func (cm AsStandard) MValidationExpression(resource string) *metadata.MValidationExpression {
	mve := metadata.MValidationExpression{}
	mi := metadata.MIValidationExpression
	for _, cd := range cm.Elements[mi.Name] {
		if cd.Attr["Resource"] != resource {
			continue
		}
		metadata.FieldTransfer(cd.Attr).To(&mve)
		for _, entry := range cd.Entries() {
			tmp := metadata.ValidationExpression{}
			entry.SetFields(&tmp)
			mve.ValidationExpression = append(mve.ValidationExpression, tmp)
		}
	}
	return &mve
}
// MObject ...
func (cm AsStandard) MObject(resource string) *metadata.MObject {
	mo := metadata.MObject{}
	mi := metadata.MIObject
	for _, cd := range cm.Elements[mi.Name] {
		if cd.Attr["Resource"] != resource {
			continue
		}
		metadata.FieldTransfer(cd.Attr).To(&mo)
		for _, entry := range cd.Entries() {
			tmp := metadata.Object{}
			entry.SetFields(&tmp)
			mo.Object = append(mo.Object, tmp)
		}
	}
	return &mo
}
// MFilterType ...
func (cm AsStandard) MFilterType(filter string) *metadata.MFilterType {
	mft := metadata.MFilterType{}
	mi := metadata.MIFilterType
	for _, cd := range cm.Elements[mi.Name] {
		if cd.Attr["Filter"] != filter {
			continue
		}
		metadata.FieldTransfer(cd.Attr).To(&mft)
		for _, entry := range cd.Entries() {
			tmp := metadata.FilterType{}
			entry.SetFields(&tmp)
			mft.FilterType = append(mft.FilterType, tmp)
		}
	}
	return &mft
}
// MValidationExternal ...
func (cm AsStandard) MValidationExternal(resource string) *metadata.MValidationExternal {
	mve := metadata.MValidationExternal{}
	mi := metadata.MIValidationExternal
	for _, cd := range cm.Elements[mi.Name] {
		if cd.Attr["Resource"] != resource {
			continue
		}
		metadata.FieldTransfer(cd.Attr).To(&mve)
		for _, entry := range cd.Entries() {
			tmp := metadata.ValidationExternal{}
			entry.SetFields(&tmp)
			id := mi.ID(&tmp)
			tmp.MValidationExternalType = cm.MValidationExternalType(resource, id)
			mve.ValidationExternal = append(mve.ValidationExternal, tmp)
		}
	}
	return &mve
}
// MLookup ...
func (cm AsStandard) MLookup(resource string) *metadata.MLookup {
	ml := metadata.MLookup{}
	mi := metadata.MILookup
	for _, cd := range cm.Elements[mi.Name] {
		if cd.Attr["Resource"] != resource {
			continue
		}
		metadata.FieldTransfer(cd.Attr).To(&ml)
		for _, entry := range cd.Entries() {
			tmp := metadata.Lookup{}
			entry.SetFields(&tmp)
			id := mi.ID(&tmp)
			tmp.MLookupType = cm.MLookupType(resource, id)
			ml.Lookup = append(ml.Lookup, tmp)
		}
	}
	return &ml
}
// MColumnGroupSet ...
func (cm AsStandard) MColumnGroupSet(resource, class string) *metadata.MColumnGroupSet {
	mcgs := metadata.MColumnGroupSet{}
	for _, cd := range cm.Elements[metadata.MIColumnGroupSet.Name] {
		if cd.Attr["Resource"] != resource {
			continue
		}
		if cd.Attr["Class"] != class {
			continue
		}
		metadata.FieldTransfer(cd.Attr).To(&mcgs)
		for _, entry := range cd.Entries() {
			tmp := metadata.ColumnGroupSet{}
			entry.SetFields(&tmp)
			mcgs.ColumnGroupSet = append(mcgs.ColumnGroupSet, tmp)
		}
	}
	return &mcgs
}
// MTable ...
func (cm AsStandard) MTable(resource, class string) *metadata.MTable {
	mt := metadata.MTable{}
	mi := metadata.MITable
	for _, cd := range cm.Elements[mi.Name] {
		if cd.Attr["Resource"] != resource {
			continue
		}
		if cd.Attr["Class"] != class {
			continue
		}
		metadata.FieldTransfer(cd.Attr).To(&mt)
		for _, entry := range cd.Entries() {
			tmp := metadata.Field{}
			entry.SetFields(&tmp)
			mt.Field = append(mt.Field, tmp)
		}
	}
	return &mt
}
// MValidationExternalType ...
func (cm AsStandard) MValidationExternalType(resource, validationExternal string) *metadata.MValidationExternalType {
	mvet := metadata.MValidationExternalType{}
	mi := metadata.MIValidationExternalType
	for _, cd := range cm.Elements[mi.Name] {
		if cd.Attr["Resource"] != resource {
			continue
		}
		if cd.Attr["ValidationExternal"] != validationExternal {
			continue
		}
		metadata.FieldTransfer(cd.Attr).To(&mvet)
		for _, entry := range cd.Entries() {
			tmp := metadata.ValidationExternalType{}
			entry.SetFields(&tmp)
			mvet.ValidationExternalType = append(mvet.ValidationExternalType, tmp)
		}
	}
	return &mvet
}
// MLookupType ...
func (cm AsStandard) MLookupType(resource, lookup string) *metadata.MLookupType {
	mlt := metadata.MLookupType{}
	mi := metadata.MILookupType
	for _, cd := range cm.Elements[mi.Name] {
		if cd.Attr["Resource"] != resource {
			continue
		}
		if cd.Attr["Lookup"] != lookup {
			continue
		}
		metadata.FieldTransfer(cd.Attr).To(&mlt)
		for _, entry := range cd.Entries() {
			tmp := metadata.LookupType{}
			entry.SetFields(&tmp)
			mlt.LookupType = append(mlt.LookupType, tmp)
		}
	}
	return &mlt
}
// MClass ...
func (cm AsStandard) MClass(resource string) *metadata.MClass {
	mc := metadata.MClass{}
	mi := metadata.MIClass
	for _, cd := range cm.Elements[mi.Name] {
		if cd.Attr["Resource"] != resource {
			continue
		}
		metadata.FieldTransfer(cd.Attr).To(&mc)
		for _, entry := range cd.Entries() {
			tmp := metadata.Class{}
			entry.SetFields(&tmp)
			id := mi.ID(&tmp)
			tmp.MTable = cm.MTable(resource, id)
			tmp.MUpdate = cm.MUpdate(resource, id)
			tmp.MColumnGroupSet = cm.MColumnGroupSet(resource, id)
			tmp.MColumnGroup = cm.MColumnGroup(resource, id)
			mc.Class = append(mc.Class, tmp)
		}
	}
	return &mc
}
// MUpdate ...
func (cm AsStandard) MUpdate(resource, class string) *metadata.MUpdate {
	mu := metadata.MUpdate{}
	mi := metadata.MIUpdate
	for _, cd := range cm.Elements[mi.Name] {
		if cd.Attr["Resource"] != resource {
			continue
		}
		if cd.Attr["Class"] != class {
			continue
		}
		metadata.FieldTransfer(cd.Attr).To(&mu)
		for _, entry := range cd.Entries() {
			tmp := metadata.Update{}
			entry.SetFields(&tmp)
			id := mi.ID(&tmp)
			tmp.MUpdateType = cm.MUpdateType(resource, class, id)
			mu.Update = append(mu.Update, tmp)
		}
	}
	return &mu
}
// MColumnGroupNormalization ...
func (cm AsStandard) MColumnGroupNormalization(resource, class, cg string) *metadata.MColumnGroupNormalization {
	mcgn := metadata.MColumnGroupNormalization{}
	for _, cd := range cm.Elements[metadata.MIColumnGroupNormalization.Name] {
		if cd.Attr["Resource"] != resource {
			continue
		}
		if cd.Attr["Class"] != class {
			continue
		}
		if cd.Attr["ColumnGroup"] != cg {
			continue
		}
		metadata.FieldTransfer(cd.Attr).To(&mcgn)
		for _, entry := range cd.Entries() {
			tmp := metadata.ColumnGroupNormalization{}
			entry.SetFields(&tmp)
			mcgn.ColumnGroupNormalization = append(mcgn.ColumnGroupNormalization, tmp)
		}
	}
	return &mcgn
}
// MColumnGroupControl ...
func (cm AsStandard) MColumnGroupControl(resource, class, cg string) *metadata.MColumnGroupControl {
	mcgc := metadata.MColumnGroupControl{}
	mi := metadata.MIColumnGroupControl
	for _, cd := range cm.Elements[mi.Name] {
		if cd.Attr["Resource"] != resource {
			continue
		}
		if cd.Attr["Class"] != class {
			continue
		}
		if cd.Attr["ColumnGroup"] != cg {
			continue
		}
		metadata.FieldTransfer(cd.Attr).To(&mcgc)
		for _, entry := range cd.Entries() {
			tmp := metadata.ColumnGroupControl{}
			entry.SetFields(&tmp)
			mcgc.ColumnGroupControl = append(mcgc.ColumnGroupControl, tmp)
		}
	}
	return &mcgc
}
// MResources ...
func (cm AsStandard) MResource() *metadata.MResource {
	mr := metadata.MResource{}
	mi := metadata.MIResource
	for _, cd := range cm.Elements[mi.Name] {
		metadata.FieldTransfer(cd.Attr).To(&mr)
		for _, entry := range cd.Entries() {
			tmp := metadata.Resource{}
			entry.SetFields(&tmp)
			id := mi.ID(&tmp)
			tmp.MClass = cm.MClass(id)
			tmp.MObject = cm.MObject(id)
			tmp.MLookup = cm.MLookup(id)
			tmp.MSearchHelp = cm.MSearchHelp(id)
			tmp.MEditMask = cm.MEditMask(id)
			tmp.MUpdateHelp = cm.MUpdateHelp(id)
			tmp.MValidationExpression = cm.MValidationExpression(id)
			tmp.MValidationExternal = cm.MValidationExternal(id)
			tmp.MValidationLookup = cm.MValidationLookup(id)
			mr.Resource = append(mr.Resource, tmp)
		}
	}
	return &mr
}
// ColumnGroup ...
func (cm AsStandard) MColumnGroup(resource, class string) *metadata.MColumnGroup {
	mcg := metadata.MColumnGroup{}
	mi := metadata.MIColumnGroup
	for _, cd := range cm.Elements[mi.Name] {
		if cd.Attr["Resource"] != resource {
			continue
		}
		if cd.Attr["Class"] != class {
			continue
		}
		metadata.FieldTransfer(cd.Attr).To(&mcg)
		for _, entry := range cd.Entries() {
			tmp := metadata.ColumnGroup{}
			entry.SetFields(&tmp)
			id := mi.ID(&tmp)
			tmp.MColumnGroupControl = cm.MColumnGroupControl(resource, class, id)
			tmp.MColumnGroupTable = cm.MColumnGroupTable(resource, class, id)
			tmp.MColumnGroupNormalization = cm.MColumnGroupNormalization(resource, class, id)
			mcg.ColumnGroup = append(mcg.ColumnGroup, tmp)
		}
	}
	return &mcg
}