nqm

var CompareFunctions = map[string]CompareDynamicRecord{
	"agent_name": func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		if r, hasNil := utils.CompareNil(left.Agent, right.Agent, direction); hasNil {
			return r
		}
		if r, hasNil := utils.CompareNil(left.Agent.Name, right.Agent.Name, direction); hasNil {
			return r
		}

		return utils.CompareString(*left.Agent.Name, *right.Agent.Name, direction)
	},
	"agent_hostname": func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		if r, hasNil := utils.CompareNil(left.Agent, right.Agent, direction); hasNil {
			return r
		}

		return utils.CompareString(left.Agent.Hostname, right.Agent.Hostname, direction)
	},
	"agent_ip_address": func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		if r, hasNil := utils.CompareNil(left.Agent, right.Agent, direction); hasNil {
			return r
		}

		leftIp, rightIp := net.ParseIP(left.Agent.IpAddress), net.ParseIP(right.Agent.IpAddress)
		return utils.CompareIpAddress(leftIp, rightIp, direction)
	},
	"agent_isp": func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		if r, hasNil := utils.CompareNil(left.Agent, right.Agent, direction); hasNil {
			return r
		}
		if r, hasNil := utils.CompareNil(left.Agent.Isp, right.Agent.Isp, direction); hasNil {
			return r
		}

		return utils.CompareString(left.Agent.Isp.Name, right.Agent.Isp.Name, direction)
	},
	"agent_province": func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		if r, hasNil := utils.CompareNil(left.Agent, right.Agent, direction); hasNil {
			return r
		}
		if r, hasNil := utils.CompareNil(left.Agent.Province, right.Agent.Province, direction); hasNil {
			return r
		}

		return utils.CompareString(left.Agent.Province.Name, right.Agent.Province.Name, direction)
	},
	"agent_city": func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		if r, hasNil := utils.CompareNil(left.Agent, right.Agent, direction); hasNil {
			return r
		}
		if r, hasNil := utils.CompareNil(left.Agent.City, right.Agent.City, direction); hasNil {
			return r
		}

		return utils.CompareString(left.Agent.City.Name, right.Agent.City.Name, direction)
	},
	"agent_name_tag": func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		if r, hasNil := utils.CompareNil(left.Agent, right.Agent, direction); hasNil {
			return r
		}
		if r, hasNil := utils.CompareNil(left.Agent.NameTag, right.Agent.NameTag, direction); hasNil {
			return r
		}

		return utils.CompareString(left.Agent.NameTag.Value, right.Agent.NameTag.Value, direction)
	},

	"target_name": func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		if r, hasNil := utils.CompareNil(left.Target, right.Target, direction); hasNil {
			return r
		}

		return utils.CompareString(left.Target.Name, right.Target.Name, direction)
	},
	"target_host": func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		if r, hasNil := utils.CompareNil(left.Target, right.Target, direction); hasNil {
			return r
		}

		leftIfIp, rightIfIp := net.ParseIP(left.Target.Host), net.ParseIP(right.Target.Host)
		if leftIfIp != nil && rightIfIp != nil {
			return utils.CompareIpAddress(leftIfIp, rightIfIp, direction)
		}

		return utils.CompareString(left.Target.Host, right.Target.Host, direction)
	},
	"target_isp": func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		if r, hasNil := utils.CompareNil(left.Target, right.Target, direction); hasNil {
			return r
		}
		if r, hasNil := utils.CompareNil(left.Target.Isp, right.Target.Isp, direction); hasNil {
			return r
		}

		return utils.CompareString(left.Target.Isp.Name, right.Target.Isp.Name, direction)
	},
	"target_province": func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		if r, hasNil := utils.CompareNil(left.Target, right.Target, direction); hasNil {
			return r
		}
		if r, hasNil := utils.CompareNil(left.Target.Province, right.Target.Province, direction); hasNil {
			return r
		}

		return utils.CompareString(left.Target.Province.Name, right.Target.Province.Name, direction)
	},
	"target_city": func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		if r, hasNil := utils.CompareNil(left.Target, right.Target, direction); hasNil {
			return r
		}
		if r, hasNil := utils.CompareNil(left.Target.City, right.Target.City, direction); hasNil {
			return r
		}

		return utils.CompareString(left.Target.City.Name, right.Target.City.Name, direction)
	},
	"target_name_tag": func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		if r, hasNil := utils.CompareNil(left.Target, right.Target, direction); hasNil {
			return r
		}
		if r, hasNil := utils.CompareNil(left.Target.NameTag, right.Target.NameTag, direction); hasNil {
			return r
		}

		return utils.CompareString(left.Target.NameTag.Value, right.Target.NameTag.Value, direction)
	},

	MetricMax: func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		return compareIntWithNoData(
			int64(left.Metrics.Metrics.Max),
			int64(right.Metrics.Metrics.Max),
			direction,
		)
	},
	MetricMin: func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		return compareIntWithNoData(
			int64(left.Metrics.Metrics.Min),
			int64(right.Metrics.Metrics.Min),
			direction,
		)
	},
	MetricAvg: func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		return compareFloatWithNoData(
			left.Metrics.Metrics.Avg,
			right.Metrics.Metrics.Avg,
			direction,
		)
	},
	MetricMed: func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		return compareIntWithNoData(
			int64(left.Metrics.Metrics.Med),
			int64(right.Metrics.Metrics.Med),
			direction,
		)
	},
	MetricMdev: func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		return compareFloatWithNoData(
			left.Metrics.Metrics.Mdev,
			right.Metrics.Metrics.Mdev,
			direction,
		)
	},
	MetricLoss: func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		return utils.CompareFloat(
			left.Metrics.Metrics.Loss,
			right.Metrics.Metrics.Loss,
			direction,
		)
	},
	MetricCount: func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		return utils.CompareInt(
			int64(left.Metrics.Metrics.Count),
			int64(right.Metrics.Metrics.Count),
			direction,
		)
	},
	MetricPckSent: func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		return utils.CompareUint(
			left.Metrics.Metrics.NumberOfSentPackets,
			right.Metrics.Metrics.NumberOfSentPackets,
			direction,
		)
	},
	MetricPckReceived: func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		return utils.CompareUint(
			left.Metrics.Metrics.NumberOfReceivedPackets,
			right.Metrics.Metrics.NumberOfReceivedPackets,
			direction,
		)
	},
	MetricNumAgent: func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		return utils.CompareInt(
			int64(left.Metrics.Metrics.NumberOfAgents),
			int64(right.Metrics.Metrics.NumberOfAgents),
			direction,
		)
	},
	MetricNumTarget: func(left *DynamicRecord, right *DynamicRecord, direction byte) int {
		return utils.CompareInt(
			int64(left.Metrics.Metrics.NumberOfTargets),
			int64(right.Metrics.Metrics.NumberOfTargets),
			direction,
		)
	},
}