构建一个有向图来统一管理红点的刷新，当某个节点刷新的时候，按照有向图的走向更新所有关联的红点

function cacheRedPoint(key,redItem,checkFunc,type,groups,relations)
    self.redPoints[key] = self.redPoints[key] or {}
    self.redPoints[key].redItem = redItem
    self.redPoints[key].checkFunc = checkFunc
    self.redPoints[key].type = type
    self.redPoints[key].num = self.redPoints[key].num or 0
    self.redPoints[key].state = self.redPoints[key].state or 0
    for _, group in ipairs(groups or {}) do
        self.groups[group] = self.groups[group] or {}
        self.groups[group][key] = true
    end
    self:addRedPointRelation(key,relations)
end

function initRedPointRelation()
    for k, list in pairs(self.RED_POINT_RELATION) do
        self:addRedPointRelation(k,list)
    end
end

function addRedPointRelation(key,relations)
    if not relations then return end
    self.relationList[key] = self.relationList[key] or {}
    local relationList = self.relationList[key]
    for _,v in ipairs(relations) do
        if not table.contains(relationList,v) then
            relationList[#relationList+1] = v
        end
    end
end

--配置红点信息{type, moudle, redItem, groups, checkFunc}
--type:红点类型，MARK, NUM, BOTH三种
--module：所属模块名
--redItem: 该模块中的红点实例名
--groups：所属分组，可以不配，用于刷新红点用。 配置了分组的红点 将会在随着对应分组的刷新而统一刷新
--checkFunc：检查是否有红点的函数， 可以不配， 没配的红点可以按照 红点关联关系 来刷新。 见下方RED_POINT_RELATION 
RED_POINT_LIST = {
    HORIZ_FUNC_EXTEND = {
        type = Const.MARK, module = "horiz_menu", redItem = "extendRedPoint",
    },

    MOUNT_EQUIP_SLOT =
        {
            type = Const.MARK, module = "mount", checkFunc = "checkMountEquipRedPoint",
            groups = {RED_POINT_GROUP.ITEM},
        },
}


--红点之间的关联影响
--本质上是构建了一个有向图，当某一个节点的红点发生变更时，会同时更新它所关联的红点，并按照图的有向边扩散这个更新
--注意：构建出来的图必须是没有闭环的，否则会导致更新关联红点的时候 出现重复计算红点的情况
--若配置上导致出现了 "环"，则更新时遇到为环的节点将只计算一次红点，
--所以红点状态并不会出错，但这样的配置也是不正确的，将会抛出一个Error提示
--一个红点可以对多个红点产生关联
RED_POINT_RELATION = {
    MOUNT_EQUIP_SLOT = {"HORIZ_FUNC_EXTEND "},
}

--配置消息驱动红点分组的刷新
GROUP_BIND_MESSAGE = {
}

--配置消息 驱动单个红点刷新
Point_BIND_MESSAGE = {
}

--绑定驱动红点分组的消息
function bindGroupWithMessage()
end

--绑定驱动红点刷心的消息
function bindPointsWithMessage()
end

--动态绑定红点实例
function bindRedPoint(key,redItem)
end

--解绑红点实例
function unBindRedPoint(key)
end

--动态注册红点信息
function registerRedPoint(key,redItem,checkFunc,type,groups,relations)
end

--移除注册的红点
function unRegisterRedPoint(key)
end

--刷新一个分组的红点
function refreshGroupRedPoint(groupName)
end

--刷新单个红点
function refreshRedPoint(key)
    if not key then
        return
    end

    local redPoint = self.redPoints[key]
    if not redPoint then
        return
    end

    local num,state
    if redPoint.checkFunc then
        if redPoint.type == Const.NUM then
            num = redPoint.checkFunc()
        elseif redPoint.type == Const.MARK then
            state = redPoint.checkFunc()
            state = state and 1 or 0
        else
            num,state = redPoint.checkFunc()
            state = state and 1 or 0
        end
    else
        num,state = redPoint.num,redPoint.state
    end
    num = num or 0
    state = state or (num > 0 and 1) or 0
    local numOff,stateOff = num - (redPoint.num or 0),state - (redPoint.state or 0)
    self:refreshRedPointState(key,num,state)
    self:checkRelationRedPoint({},key,numOff,stateOff)
end

--递归遍历刷新所有有关联的红点
function checkRelationRedPoint(passedMap,key,numOff,stateOff)
    if passedMap[key] then
        print("ConfigError,Circle appeared in relation:" .. key .. "!")
        return
    end
    passedMap[key] = true
    if not self.relationList[key] then return end
    local relations = self.relationList[key]
    for _, relationKey in pairs(relations) do
        local redPoint = self.redPoints[relationKey]
        local num = (redPoint.num or 0) + numOff
        local state = (redPoint.state or 0) + stateOff
        self:refreshRedPointState(relationKey,num,state)
        self:checkRelationRedPoint(passedMap,relationKey,numOff,stateOff)
    end
end

--更新红点状态
function RedPointCtrl:refreshRedPointState( key,num,state )
end