IJPL-797 intellij.platform.vcs.log.graph.impl review internal API

Mark as internal classes which have no usages in the Marketplace and in plugins in the intellij project.

GitOrigin-RevId: 819dd3022a65b3627fc6e91be7691848f1e8c4e1

platform/vcs-log/graph/api-dump.txt

@@ -1,15 +1,3 @@
-f:com.intellij.vcs.log.graph.GraphCommitImpl
-- com.intellij.util.containers.ImmutableList
-- com.intellij.vcs.log.graph.GraphCommit
-- s:createCommit(java.lang.Object,java.util.List,J):com.intellij.vcs.log.graph.GraphCommit
-- s:createIntCommit(I,java.util.List,J):com.intellij.vcs.log.graph.GraphCommit
-- equals(java.lang.Object):Z
-- get(I):java.lang.Object
-- getId():java.lang.Object
-- getParents():java.util.List
-- getTimestamp():J
-- hashCode():I
-- size():I
 e:com.intellij.vcs.log.graph.api.EdgeFilter
 - java.lang.Enum
 - sf:ALL:com.intellij.vcs.log.graph.api.EdgeFilter
@@ -105,203 +93,6 @@ com.intellij.vcs.log.graph.api.printer.PrintElementGenerator
 com.intellij.vcs.log.graph.api.printer.PrintElementPresentationManager
 - a:getColorId(com.intellij.vcs.log.graph.api.elements.GraphElement):I
 - a:isSelected(com.intellij.vcs.log.graph.api.printer.GraphPrintElement):Z
-f:com.intellij.vcs.log.graph.collapsing.BranchFilterController
-- com.intellij.vcs.log.graph.impl.facade.CascadeController
-- <init>(com.intellij.vcs.log.graph.impl.facade.LinearGraphController,com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo,java.util.Set):V
-- getCompiledGraph():com.intellij.vcs.log.graph.api.LinearGraph
-c:com.intellij.vcs.log.graph.collapsing.CollapsedController
-- com.intellij.vcs.log.graph.impl.facade.CascadeController
-- <init>(com.intellij.vcs.log.graph.impl.facade.LinearGraphController,com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo,java.util.Set):V
-- p:convertToDelegate(com.intellij.vcs.log.graph.api.elements.GraphElement):com.intellij.vcs.log.graph.api.elements.GraphElement
-- s:convertToDelegate(com.intellij.vcs.log.graph.api.elements.GraphElement,com.intellij.vcs.log.graph.collapsing.CollapsedGraph):com.intellij.vcs.log.graph.api.elements.GraphElement
-- p:delegateGraphChanged(com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAnswer):com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAnswer
-- p:getCollapsedGraph():com.intellij.vcs.log.graph.collapsing.CollapsedGraph
-- getCompiledGraph():com.intellij.vcs.log.graph.api.LinearGraph
-- p:performAction(com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAction):com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAnswer
-f:com.intellij.vcs.log.graph.collapsing.CollapsedGraph
-- convertToDelegateNodeIndex(I):I
-- getCompiledGraph():com.intellij.vcs.log.graph.api.LinearGraph
-- getDelegatedGraph():com.intellij.vcs.log.graph.api.LinearGraph
-- getMatchedNodeId():com.intellij.vcs.log.graph.utils.UnsignedBitSet
-- isMyCollapsedEdge(I,I):Z
-- isNodeVisible(I):Z
-- s:newInstance(com.intellij.vcs.log.graph.api.LinearGraph,com.intellij.vcs.log.graph.utils.UnsignedBitSet):com.intellij.vcs.log.graph.collapsing.CollapsedGraph
-- startModification():com.intellij.vcs.log.graph.collapsing.CollapsedGraph$Modification
-- s:updateInstance(com.intellij.vcs.log.graph.collapsing.CollapsedGraph,com.intellij.vcs.log.graph.api.LinearGraph):com.intellij.vcs.log.graph.collapsing.CollapsedGraph
-c:com.intellij.vcs.log.graph.collapsing.CollapsedGraph$Modification
-- <init>(com.intellij.vcs.log.graph.collapsing.CollapsedGraph):V
-- apply():V
-- convertToDelegateNodeIndex(I):I
-- createEdge(com.intellij.vcs.log.graph.api.elements.GraphEdge):V
-- hideNode(I):V
-- removeAdditionalEdges():V
-- removeEdge(com.intellij.vcs.log.graph.api.elements.GraphEdge):V
-- resetNodesVisibility():V
-- showNode(I):V
-a:com.intellij.vcs.log.graph.collapsing.DottedFilterEdgesGenerator
-- sf:Companion:com.intellij.vcs.log.graph.collapsing.DottedFilterEdgesGenerator$Companion
-- pa:addDottedArrow(I,Z):V
-- pa:addDottedEdge(I,I):V
-- pa:hasDottedEdges(I,Z):Z
-- pa:nodeIsVisible(I):Z
-- sf:update(com.intellij.vcs.log.graph.collapsing.CollapsedGraph,I,I):V
-f:com.intellij.vcs.log.graph.collapsing.DottedFilterEdgesGenerator$Companion
-- f:hideInplace(com.intellij.vcs.log.graph.collapsing.CollapsedGraph,java.util.Set):V
-- f:update(com.intellij.vcs.log.graph.collapsing.CollapsedGraph,I,I):V
-f:com.intellij.vcs.log.graph.collapsing.DottedFilterEdgesGeneratorImpl
-- com.intellij.vcs.log.graph.collapsing.DottedFilterEdgesGenerator
-- <init>(com.intellij.vcs.log.graph.collapsing.CollapsedGraph,com.intellij.vcs.log.graph.collapsing.CollapsedGraph$Modification,I,I):V
-c:com.intellij.vcs.log.graph.collapsing.EdgeStorage
-- sf:NULL_ID:I
-- <init>():V
-- createEdge(I,I,com.intellij.vcs.log.graph.api.elements.GraphEdgeType):V
-- getEdges(I):java.util.List
-- getKnownIds():I[]
-- removeAll():V
-- removeEdge(I,I,com.intellij.vcs.log.graph.api.elements.GraphEdgeType):V
-c:com.intellij.vcs.log.graph.collapsing.EdgeStorageWrapper
-- <init>(com.intellij.vcs.log.graph.collapsing.EdgeStorage,com.intellij.vcs.log.graph.api.LinearGraph):V
-- <init>(com.intellij.vcs.log.graph.collapsing.EdgeStorage,java.util.function.Function,java.util.function.Function):V
-- createEdge(com.intellij.vcs.log.graph.api.elements.GraphEdge):V
-- s:createSimpleEdgeStorage():com.intellij.vcs.log.graph.collapsing.EdgeStorageWrapper
-- getAdjacentEdges(I,com.intellij.vcs.log.graph.api.EdgeFilter):java.util.List
-- getEdges():java.util.Set
-- hasEdge(I,I):Z
-- removeAll():V
-- removeEdge(com.intellij.vcs.log.graph.api.elements.GraphEdge):V
-c:com.intellij.vcs.log.graph.collapsing.FragmentGenerator
-- <init>(com.intellij.vcs.log.graph.api.LiteLinearGraph,com.intellij.openapi.util.Condition):V
-- getGreenFragmentForCollapse(I,I):com.intellij.vcs.log.graph.collapsing.FragmentGenerator$GreenFragment
-- getMiddleNodes(I,I,Z):java.util.Set
-- getNearRedNode(I,I,Z):java.lang.Integer
-f:com.intellij.vcs.log.graph.collapsing.FragmentGenerator$GreenFragment
-- getDownRedNode():java.lang.Integer
-- getMiddleGreenNodes():java.util.Set
-- getUpRedNode():java.lang.Integer
-f:com.intellij.vcs.log.graph.collapsing.InplaceFilterEdgesGenerator
-- com.intellij.vcs.log.graph.collapsing.DottedFilterEdgesGenerator
-- <init>(com.intellij.vcs.log.graph.collapsing.CollapsedGraph,com.intellij.vcs.log.graph.collapsing.CollapsedGraph$Modification,java.util.Set):V
-c:com.intellij.vcs.log.graph.collapsing.LinearFragmentGenerator
-- <init>(com.intellij.vcs.log.graph.api.LiteLinearGraph,java.util.Set):V
-- getDownFragment(I):com.intellij.vcs.log.graph.collapsing.LinearFragmentGenerator$GraphFragment
-- getLongDownFragment(I):com.intellij.vcs.log.graph.collapsing.LinearFragmentGenerator$GraphFragment
-- getLongFragment(com.intellij.vcs.log.graph.api.elements.GraphElement):com.intellij.vcs.log.graph.collapsing.LinearFragmentGenerator$GraphFragment
-- getPartLongFragment(com.intellij.vcs.log.graph.api.elements.GraphElement):com.intellij.vcs.log.graph.collapsing.LinearFragmentGenerator$GraphFragment
-- getRelativeFragment(com.intellij.vcs.log.graph.api.elements.GraphElement):com.intellij.vcs.log.graph.collapsing.LinearFragmentGenerator$GraphFragment
-- getUpFragment(I):com.intellij.vcs.log.graph.collapsing.LinearFragmentGenerator$GraphFragment
-c:com.intellij.vcs.log.graph.collapsing.LinearFragmentGenerator$GraphFragment
-- f:downNodeIndex:I
-- f:upNodeIndex:I
-- <init>(I,I):V
-- s:create(I,I):com.intellij.vcs.log.graph.collapsing.LinearFragmentGenerator$GraphFragment
-c:com.intellij.vcs.log.graph.impl.facade.BaseController
-- com.intellij.vcs.log.graph.impl.facade.LinearGraphController
-- <init>(com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo):V
-- getCompiledGraph():com.intellij.vcs.log.graph.api.LinearGraph
-- performLinearGraphAction(com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAction):com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAnswer
-a:com.intellij.vcs.log.graph.impl.facade.CascadeController
-- com.intellij.vcs.log.graph.impl.facade.LinearGraphController
-- sf:Companion:com.intellij.vcs.log.graph.impl.facade.CascadeController$Companion
-- p:<init>(com.intellij.vcs.log.graph.impl.facade.LinearGraphController,com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo):V
-- p:convertToDelegate(com.intellij.vcs.log.graph.api.elements.GraphElement):com.intellij.vcs.log.graph.api.elements.GraphElement
-- pa:delegateGraphChanged(com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAnswer):com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAnswer
-- pf:getDelegateController():com.intellij.vcs.log.graph.impl.facade.LinearGraphController
-- f:getPermanentGraphInfo():com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo
-- pa:performAction(com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAction):com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAnswer
-- performLinearGraphAction(com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAction):com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAnswer
-f:com.intellij.vcs.log.graph.impl.facade.CascadeController$Companion
-f:com.intellij.vcs.log.graph.impl.facade.FilteredController
-- com.intellij.vcs.log.graph.impl.facade.CascadeController
-- sf:Companion:com.intellij.vcs.log.graph.impl.facade.FilteredController$Companion
-- <init>(com.intellij.vcs.log.graph.impl.facade.LinearGraphController,com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo,kotlin.jvm.functions.Function0):V
-- f:getCollapsedGraph():com.intellij.vcs.log.graph.collapsing.CollapsedGraph
-- getCompiledGraph():com.intellij.vcs.log.graph.api.LinearGraph
-- performLinearGraphAction(com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAction):com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAnswer
-f:com.intellij.vcs.log.graph.impl.facade.FilteredController$Companion
-- f:create(com.intellij.vcs.log.graph.impl.facade.LinearGraphController,com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo,java.util.Set,java.util.Set):com.intellij.vcs.log.graph.impl.facade.FilteredController
-- bs:create$default(com.intellij.vcs.log.graph.impl.facade.FilteredController$Companion,com.intellij.vcs.log.graph.impl.facade.LinearGraphController,com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo,java.util.Set,java.util.Set,I,java.lang.Object):com.intellij.vcs.log.graph.impl.facade.FilteredController
-f:com.intellij.vcs.log.graph.impl.facade.FirstParentController
-- sf:INSTANCE:com.intellij.vcs.log.graph.impl.facade.FirstParentController
-- f:buildCollapsedGraph(com.intellij.vcs.log.graph.api.LinearGraph,java.util.Set,java.util.Set):com.intellij.vcs.log.graph.collapsing.CollapsedGraph
-- f:create(com.intellij.vcs.log.graph.impl.facade.LinearGraphController,com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo,java.util.Set,java.util.Set):com.intellij.vcs.log.graph.impl.facade.FilteredController
-- bs:create$default(com.intellij.vcs.log.graph.impl.facade.FirstParentController,com.intellij.vcs.log.graph.impl.facade.LinearGraphController,com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo,java.util.Set,java.util.Set,I,java.lang.Object):com.intellij.vcs.log.graph.impl.facade.FilteredController
-com.intellij.vcs.log.graph.impl.facade.GraphChanges
-- a:getChangedEdges():java.util.Collection
-- a:getChangedNodes():java.util.Collection
-com.intellij.vcs.log.graph.impl.facade.GraphChanges$Edge
-- a:downNodeId():java.lang.Object
-- a:removed():Z
-- a:targetId():java.lang.Object
-- a:upNodeId():java.lang.Object
-c:com.intellij.vcs.log.graph.impl.facade.GraphChanges$EdgeImpl
-- com.intellij.vcs.log.graph.impl.facade.GraphChanges$Edge
-- <init>(java.lang.Object,java.lang.Object,java.lang.Object,Z):V
-- downNodeId():java.lang.Object
-- removed():Z
-- targetId():java.lang.Object
-- upNodeId():java.lang.Object
-c:com.intellij.vcs.log.graph.impl.facade.GraphChanges$GraphChangesImpl
-- com.intellij.vcs.log.graph.impl.facade.GraphChanges
-- <init>(java.util.Collection,java.util.Collection):V
-- getChangedEdges():java.util.Collection
-- getChangedNodes():java.util.Collection
-com.intellij.vcs.log.graph.impl.facade.GraphChanges$Node
-- a:getNodeId():java.lang.Object
-- a:removed():Z
-c:com.intellij.vcs.log.graph.impl.facade.GraphChanges$NodeImpl
-- com.intellij.vcs.log.graph.impl.facade.GraphChanges$Node
-- <init>(java.lang.Object,Z):V
-- getNodeId():java.lang.Object
-- removed():Z
-f:com.intellij.vcs.log.graph.impl.facade.GraphChangesUtil
-- sf:SOME_CHANGES:com.intellij.vcs.log.graph.impl.facade.GraphChanges
-- <init>():V
-- s:edgeChanged(com.intellij.vcs.log.graph.api.elements.GraphEdge,com.intellij.vcs.log.graph.api.LinearGraph,Z):com.intellij.vcs.log.graph.impl.facade.GraphChanges$EdgeImpl
-- s:edgesReplaced(java.util.Collection,java.util.Collection,com.intellij.vcs.log.graph.api.LinearGraph):com.intellij.vcs.log.graph.impl.facade.GraphChanges
-f:com.intellij.vcs.log.graph.impl.facade.GraphModificationUtilKt
-- sf:connectRows(com.intellij.vcs.log.graph.collapsing.CollapsedGraph$Modification,I,I):V
-- sf:hideCommits(com.intellij.vcs.log.graph.impl.facade.LinearGraphController,com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo,java.util.Set):Z
-- sf:hideRow(com.intellij.vcs.log.graph.collapsing.CollapsedGraph$Modification,I):V
-- sf:modify(com.intellij.vcs.log.graph.collapsing.CollapsedGraph,kotlin.jvm.functions.Function1):V
-- sf:modifyGraph(com.intellij.vcs.log.graph.impl.facade.LinearGraphController,kotlin.jvm.functions.Function1):Z
-com.intellij.vcs.log.graph.impl.facade.LinearGraphController
-- a:getCompiledGraph():com.intellij.vcs.log.graph.api.LinearGraph
-- a:performLinearGraphAction(com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAction):com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAnswer
-com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAction
-- com.intellij.vcs.log.graph.actions.GraphAction
-- a:getAffectedElement():com.intellij.vcs.log.graph.api.printer.GraphPrintElement
-f:com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAnswer
-- <init>(com.intellij.vcs.log.graph.impl.facade.GraphChanges):V
-- <init>(com.intellij.vcs.log.graph.impl.facade.GraphChanges,java.awt.Cursor,java.util.Set,java.lang.Runnable):V
-- <init>(com.intellij.vcs.log.graph.impl.facade.GraphChanges,java.lang.Runnable):V
-- b:<init>(com.intellij.vcs.log.graph.impl.facade.GraphChanges,java.lang.Runnable,I,kotlin.jvm.internal.DefaultConstructorMarker):V
-- <init>(java.awt.Cursor,java.util.Set):V
-- f:component1():com.intellij.vcs.log.graph.impl.facade.GraphChanges
-- f:component2():java.awt.Cursor
-- f:component3():java.util.Set
-- f:component4():java.lang.Runnable
-- f:copy(com.intellij.vcs.log.graph.impl.facade.GraphChanges,java.awt.Cursor,java.util.Set,java.lang.Runnable):com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAnswer
-- bs:copy$default(com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAnswer,com.intellij.vcs.log.graph.impl.facade.GraphChanges,java.awt.Cursor,java.util.Set,java.lang.Runnable,I,java.lang.Object):com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAnswer
-- equals(java.lang.Object):Z
-- f:getCursorToSet():java.awt.Cursor
-- f:getGraphChanges():com.intellij.vcs.log.graph.impl.facade.GraphChanges
-- f:getGraphUpdater():java.lang.Runnable
-- f:getSelectedNodeIds():java.util.Set
-- hashCode():I
-c:com.intellij.vcs.log.graph.impl.facade.LinearGraphWrapper
-- com.intellij.vcs.log.graph.api.LinearGraph
-- <init>(com.intellij.vcs.log.graph.api.LinearGraph):V
-- <init>(com.intellij.vcs.log.graph.api.LinearGraph,com.intellij.vcs.log.graph.collapsing.EdgeStorageWrapper):V
-- <init>(com.intellij.vcs.log.graph.api.LinearGraph,com.intellij.vcs.log.graph.collapsing.EdgeStorageWrapper,com.intellij.vcs.log.graph.collapsing.EdgeStorageWrapper):V
-- b:<init>(com.intellij.vcs.log.graph.api.LinearGraph,com.intellij.vcs.log.graph.collapsing.EdgeStorageWrapper,com.intellij.vcs.log.graph.collapsing.EdgeStorageWrapper,I,kotlin.jvm.internal.DefaultConstructorMarker):V
-- getAdjacentEdges(I,com.intellij.vcs.log.graph.api.EdgeFilter):java.util.List
-- f:getDottedEdges():com.intellij.vcs.log.graph.collapsing.EdgeStorageWrapper
-- f:getGraph():com.intellij.vcs.log.graph.api.LinearGraph
-- getGraphNode(I):com.intellij.vcs.log.graph.api.elements.GraphNode
-- f:getHiddenEdges():com.intellij.vcs.log.graph.collapsing.EdgeStorageWrapper
-- getNodeId(I):I
-- getNodeIndex(I):java.lang.Integer
-- nodesCount():I
 f:com.intellij.vcs.log.graph.impl.facade.PermanentGraphImpl
 - com.intellij.vcs.log.graph.PermanentGraph
 - com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo
@@ -314,105 +105,9 @@ f:com.intellij.vcs.log.graph.impl.facade.PermanentGraphImpl
 - getContainedInBranchCondition(java.util.Collection):java.util.function.Predicate
 - getContainingBranches(java.lang.Object):java.util.Set
 - getLinearGraph():com.intellij.vcs.log.graph.impl.permanent.PermanentLinearGraphImpl
-- getPermanentCommitsInfo():com.intellij.vcs.log.graph.impl.permanent.PermanentCommitsInfoImpl
-- getPermanentGraphLayout():com.intellij.vcs.log.graph.impl.permanent.GraphLayoutImpl
 - sf:newInstance(java.util.List,com.intellij.vcs.log.graph.api.printer.GraphColorGetterFactory,java.util.Comparator,java.util.Set):com.intellij.vcs.log.graph.impl.facade.PermanentGraphImpl
 f:com.intellij.vcs.log.graph.impl.facade.PermanentGraphImpl$Companion
 - f:newInstance(java.util.List,com.intellij.vcs.log.graph.api.printer.GraphColorGetterFactory,java.util.Comparator,java.util.Set):com.intellij.vcs.log.graph.impl.facade.PermanentGraphImpl
-f:com.intellij.vcs.log.graph.impl.facade.ReachableNodes
-- <init>(com.intellij.vcs.log.graph.api.LiteLinearGraph):V
-- f:getContainingBranches(I,java.util.Collection):java.util.Set
-- f:walk(java.util.Collection,Z,kotlin.jvm.functions.Function1):V
-- f:walkDown(java.util.Collection,java.util.function.Consumer):V
-f:com.intellij.vcs.log.graph.impl.facade.SimpleGraphInfo
-- com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo
-- s:build(com.intellij.vcs.log.graph.api.LinearGraph,com.intellij.vcs.log.graph.api.GraphLayout,com.intellij.vcs.log.graph.api.permanent.PermanentCommitsInfo,I,java.util.Set,I,I):com.intellij.vcs.log.graph.impl.facade.SimpleGraphInfo
-- getBranchNodeIds():java.util.Set
-- getLinearGraph():com.intellij.vcs.log.graph.api.LinearGraph
-- getPermanentCommitsInfo():com.intellij.vcs.log.graph.api.permanent.PermanentCommitsInfo
-- getPermanentGraphLayout():com.intellij.vcs.log.graph.api.GraphLayout
-f:com.intellij.vcs.log.graph.impl.facade.VisibleGraphImpl
-- com.intellij.vcs.log.graph.VisibleGraph
-- <init>(com.intellij.vcs.log.graph.impl.facade.LinearGraphController,com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo,com.intellij.vcs.log.graph.api.printer.GraphColorGetter):V
-- f:buildSimpleGraphInfo(I,I):com.intellij.vcs.log.graph.impl.facade.SimpleGraphInfo
-- getActionController():com.intellij.vcs.log.graph.actions.ActionController
-- f:getLinearGraph():com.intellij.vcs.log.graph.api.LinearGraph
-- f:getPermanentGraph():com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo
-- getRecommendedWidth():I
-- getRowInfo(I):com.intellij.vcs.log.graph.RowInfo
-- getVisibleCommitCount():I
-- getVisibleRowIndex(java.lang.Object):java.lang.Integer
-- f:updatePrintElementGenerator():V
-f:com.intellij.vcs.log.graph.impl.facade.VisibleGraphImpl$LinearGraphActionImpl
-- com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAction
-- <init>(com.intellij.vcs.log.graph.api.printer.GraphPrintElement,com.intellij.vcs.log.graph.actions.GraphAction$Type):V
-- f:component1():com.intellij.vcs.log.graph.api.printer.GraphPrintElement
-- f:component2():com.intellij.vcs.log.graph.actions.GraphAction$Type
-- f:copy(com.intellij.vcs.log.graph.api.printer.GraphPrintElement,com.intellij.vcs.log.graph.actions.GraphAction$Type):com.intellij.vcs.log.graph.impl.facade.VisibleGraphImpl$LinearGraphActionImpl
-- bs:copy$default(com.intellij.vcs.log.graph.impl.facade.VisibleGraphImpl$LinearGraphActionImpl,com.intellij.vcs.log.graph.api.printer.GraphPrintElement,com.intellij.vcs.log.graph.actions.GraphAction$Type,I,java.lang.Object):com.intellij.vcs.log.graph.impl.facade.VisibleGraphImpl$LinearGraphActionImpl
-- equals(java.lang.Object):Z
-- getAffectedElement():com.intellij.vcs.log.graph.api.printer.GraphPrintElement
-- getType():com.intellij.vcs.log.graph.actions.GraphAction$Type
-- hashCode():I
-f:com.intellij.vcs.log.graph.impl.facade.sort.SortChecker
-- <init>():V
-- s:checkLinearGraph(com.intellij.vcs.log.graph.api.LinearGraph):V
-- s:findReversedEdge(com.intellij.vcs.log.graph.api.LinearGraph):com.intellij.openapi.util.Pair
-com.intellij.vcs.log.graph.impl.facade.sort.SortIndexMap
-- s:createFromSortedList(java.util.List):com.intellij.vcs.log.graph.impl.facade.sort.SortIndexMap
-- a:getSortedIndex(I):I
-- a:getUsualIndex(I):I
-- a:size():I
-c:com.intellij.vcs.log.graph.impl.facade.sort.SortedBaseController
-- com.intellij.vcs.log.graph.impl.facade.LinearGraphController
-- <init>(com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo,com.intellij.vcs.log.graph.impl.facade.sort.SortIndexMap):V
-- getBekIntMap():com.intellij.vcs.log.graph.impl.facade.sort.SortIndexMap
-- getCompiledGraph():com.intellij.vcs.log.graph.api.LinearGraph
-- performLinearGraphAction(com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAction):com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAnswer
-c:com.intellij.vcs.log.graph.impl.facade.sort.SortedBaseController$SortedLinearGraph
-- com.intellij.vcs.log.graph.api.LinearGraph
-- <init>(com.intellij.vcs.log.graph.impl.facade.sort.SortIndexMap,com.intellij.vcs.log.graph.api.LinearGraph):V
-- getAdjacentEdges(I,com.intellij.vcs.log.graph.api.EdgeFilter):java.util.List
-- getGraphNode(I):com.intellij.vcs.log.graph.api.elements.GraphNode
-- getNodeId(I):I
-- getNodeIndex(I):java.lang.Integer
-- nodesCount():I
-f:com.intellij.vcs.log.graph.impl.facade.sort.bek.BekSorter
-- <init>():V
-- s:createBekMap(com.intellij.vcs.log.graph.api.LinearGraph,com.intellij.vcs.log.graph.impl.permanent.GraphLayoutImpl,com.intellij.vcs.log.graph.utils.TimestampGetter):com.intellij.vcs.log.graph.impl.facade.sort.SortIndexMap
-f:com.intellij.vcs.log.graph.impl.permanent.DuplicateParentFixer
-- <init>():V
-- s:fixDuplicateParentCommits(java.util.List):java.util.AbstractList
-f:com.intellij.vcs.log.graph.impl.permanent.GraphLayoutBuilder
-- sf:INSTANCE:com.intellij.vcs.log.graph.impl.permanent.GraphLayoutBuilder
-- sf:build(com.intellij.vcs.log.graph.api.LinearGraph,it.unimi.dsi.fastutil.ints.IntComparator):com.intellij.vcs.log.graph.impl.permanent.GraphLayoutImpl
-- sf:build(com.intellij.vcs.log.graph.api.LinearGraph,java.util.Set,it.unimi.dsi.fastutil.ints.IntComparator):com.intellij.vcs.log.graph.impl.permanent.GraphLayoutImpl
-f:com.intellij.vcs.log.graph.impl.permanent.GraphLayoutImpl
-- com.intellij.vcs.log.graph.api.GraphLayout
-- <init>(I[],it.unimi.dsi.fastutil.ints.IntList):V
-- getHeadNodeIndex():it.unimi.dsi.fastutil.ints.IntList
-- getLayoutIndex(I):I
-- getOneOfHeadNodeIndex(I):I
-f:com.intellij.vcs.log.graph.impl.permanent.PermanentCommitsInfoImpl
-- com.intellij.vcs.log.graph.api.permanent.PermanentCommitsInfo
-- sf:Companion:com.intellij.vcs.log.graph.impl.permanent.PermanentCommitsInfoImpl$Companion
-- f:containsAll(java.util.Collection):Z
-- f:convertToCommitIdList(java.util.Collection):java.util.List
-- f:convertToCommitIdSet(java.util.Collection):java.util.Set
-- convertToNodeIds(java.util.Collection):java.util.Set
-- sf:createTimestampGetter(java.util.List):com.intellij.vcs.log.graph.utils.impl.IntTimestampGetter
-- getCommitId(I):java.lang.Object
-- getNodeId(java.lang.Object):I
-- getTimestamp(I):J
-- f:getTimestampGetter():com.intellij.vcs.log.graph.utils.TimestampGetter
-- sf:newInstance(java.util.List,it.unimi.dsi.fastutil.ints.Int2ObjectMap):com.intellij.vcs.log.graph.impl.permanent.PermanentCommitsInfoImpl
-f:com.intellij.vcs.log.graph.impl.permanent.PermanentCommitsInfoImpl$Companion
-- f:createTimestampGetter(java.util.List):com.intellij.vcs.log.graph.utils.impl.IntTimestampGetter
-- f:newInstance(java.util.List,it.unimi.dsi.fastutil.ints.Int2ObjectMap):com.intellij.vcs.log.graph.impl.permanent.PermanentCommitsInfoImpl
-f:com.intellij.vcs.log.graph.impl.permanent.PermanentLinearGraphBuilder
-- build():com.intellij.vcs.log.graph.impl.permanent.PermanentLinearGraphImpl
-- build(java.util.function.Function):com.intellij.vcs.log.graph.impl.permanent.PermanentLinearGraphImpl
-- s:newInstance(java.util.List):com.intellij.vcs.log.graph.impl.permanent.PermanentLinearGraphBuilder
 c:com.intellij.vcs.log.graph.impl.permanent.PermanentLinearGraphImpl
 - com.intellij.vcs.log.graph.api.LinearGraph
 - getAdjacentEdges(I,com.intellij.vcs.log.graph.api.EdgeFilter):java.util.List
@@ -420,39 +115,10 @@ c:com.intellij.vcs.log.graph.impl.permanent.PermanentLinearGraphImpl
 - getNodeId(I):I
 - getNodeIndex(I):java.lang.Integer
 - nodesCount():I
-f:com.intellij.vcs.log.graph.impl.print.GraphColorGetterByHeadFactory
-- com.intellij.vcs.log.graph.api.printer.GraphColorGetterFactory
-- <init>(com.intellij.vcs.log.graph.GraphColorManager):V
-- createColorGetter(com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo):com.intellij.vcs.log.graph.api.printer.GraphColorGetter
 f:com.intellij.vcs.log.graph.impl.print.GraphColorGetterByNodeFactory
 - com.intellij.vcs.log.graph.api.printer.GraphColorGetterFactory
 - <init>(kotlin.jvm.functions.Function2):V
 - createColorGetter(com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo):com.intellij.vcs.log.graph.api.printer.GraphColorGetter
-f:com.intellij.vcs.log.graph.linearBek.LinearBekController
-- com.intellij.vcs.log.graph.impl.facade.CascadeController
-- sf:Companion:com.intellij.vcs.log.graph.linearBek.LinearBekController$Companion
-- <init>(com.intellij.vcs.log.graph.impl.facade.sort.SortedBaseController,com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo):V
-- getCompiledGraph():com.intellij.vcs.log.graph.linearBek.LinearBekGraph
-f:com.intellij.vcs.log.graph.linearBek.LinearBekController$Companion
-c:com.intellij.vcs.log.graph.linearBek.LinearBekGraph
-- com.intellij.vcs.log.graph.impl.facade.LinearGraphWrapper
-- <init>(com.intellij.vcs.log.graph.api.LinearGraph):V
-- expandEdge(com.intellij.vcs.log.graph.api.elements.GraphEdge):java.util.Collection
-c:com.intellij.vcs.log.graph.linearBek.LinearBekGraph$WorkingLinearBekGraph
-- com.intellij.vcs.log.graph.linearBek.LinearBekGraph
-- <init>(com.intellij.vcs.log.graph.linearBek.LinearBekGraph):V
-- applyChanges():V
-- getAddedEdges():java.util.Collection
-- getRemovedEdges():java.util.Collection
-c:com.intellij.vcs.log.graph.utils.BfsSearch
-- com.intellij.vcs.log.graph.utils.BfsWalk
-- <init>(I,com.intellij.vcs.log.graph.api.LiteLinearGraph,com.intellij.vcs.log.graph.utils.Flags,Z,I):V
-- b:<init>(I,com.intellij.vcs.log.graph.api.LiteLinearGraph,com.intellij.vcs.log.graph.utils.Flags,Z,I,I,kotlin.jvm.internal.DefaultConstructorMarker):V
-- f:find(kotlin.jvm.functions.Function1):java.lang.Object
-- f:getCount():I
-- f:getResult():java.lang.Object
-- isFinished():Z
-- f:setCount(I):V
 c:com.intellij.vcs.log.graph.utils.BfsWalk
 - <init>(I,com.intellij.vcs.log.graph.api.LiteLinearGraph):V
 - <init>(I,com.intellij.vcs.log.graph.api.LiteLinearGraph,com.intellij.vcs.log.graph.utils.Flags,Z):V
@@ -465,14 +131,6 @@ c:com.intellij.vcs.log.graph.utils.BfsWalk
 - bs:step$default(com.intellij.vcs.log.graph.utils.BfsWalk,kotlin.jvm.functions.Function1,I,java.lang.Object):java.util.List
 - f:walk(kotlin.jvm.functions.Function1):V
 - bs:walk$default(com.intellij.vcs.log.graph.utils.BfsWalk,kotlin.jvm.functions.Function1,I,java.lang.Object):V
-f:com.intellij.vcs.log.graph.utils.Dfs
-- sf:INSTANCE:com.intellij.vcs.log.graph.utils.Dfs
-f:com.intellij.vcs.log.graph.utils.Dfs$NextNode
-- sf:EXIT:I
-- sf:INSTANCE:com.intellij.vcs.log.graph.utils.Dfs$NextNode
-- sf:NODE_NOT_FOUND:I
-f:com.intellij.vcs.log.graph.utils.DfsUtilKt
-- sf:walk(I,kotlin.jvm.functions.Function1):V
 f:com.intellij.vcs.log.graph.utils.DfsWalk
 - <init>(java.util.Collection,com.intellij.vcs.log.graph.api.LinearGraph):V
 - <init>(java.util.Collection,com.intellij.vcs.log.graph.api.LiteLinearGraph,com.intellij.vcs.log.graph.utils.Flags):V
@@ -482,48 +140,11 @@ com.intellij.vcs.log.graph.utils.Flags
 - a:set(I,Z):V
 - a:setAll(Z):V
 - a:size():I
-f:com.intellij.vcs.log.graph.utils.GraphUtilKt
-- sf:exclusiveNodes(com.intellij.vcs.log.graph.api.LinearGraph,I,kotlin.jvm.functions.Function1):it.unimi.dsi.fastutil.ints.IntSet
-- sf:exclusiveNodes(com.intellij.vcs.log.graph.api.LiteLinearGraph,I,kotlin.jvm.functions.Function1):it.unimi.dsi.fastutil.ints.IntSet
-- bs:exclusiveNodes$default(com.intellij.vcs.log.graph.api.LinearGraph,I,kotlin.jvm.functions.Function1,I,java.lang.Object):it.unimi.dsi.fastutil.ints.IntSet
-- bs:exclusiveNodes$default(com.intellij.vcs.log.graph.api.LiteLinearGraph,I,kotlin.jvm.functions.Function1,I,java.lang.Object):it.unimi.dsi.fastutil.ints.IntSet
-- sf:getCorrespondingParent(com.intellij.vcs.log.graph.api.LiteLinearGraph,I,I,com.intellij.vcs.log.graph.utils.Flags):I
-- sf:isAncestor(com.intellij.vcs.log.graph.api.LiteLinearGraph,I,I):Z
-- sf:subgraphDifference(com.intellij.vcs.log.graph.api.LinearGraph,I,I):it.unimi.dsi.fastutil.ints.IntSet
-c:com.intellij.vcs.log.graph.utils.IntHashSetFlags
-- com.intellij.vcs.log.graph.utils.Flags
-- <init>(I):V
-- get(I):Z
-- f:getData():it.unimi.dsi.fastutil.ints.IntOpenHashSet
-- set(I,Z):V
-- setAll(Z):V
-- size():I
-f:com.intellij.vcs.log.graph.utils.IntIntMultiMap
-- <init>():V
-- clear():V
-- containsKey(I):Z
-- get(I):java.util.Collection
-- getAsArray(I):I[]
-- isEmpty():Z
-- keys():I[]
-- putValue(I,I):V
-- remove(I,I):V
-com.intellij.vcs.log.graph.utils.IntList
-- a:get(I):I
-- a:size():I
-com.intellij.vcs.log.graph.utils.IntToIntMap
-- a:getLongIndex(I):I
-- a:getShortIndex(I):I
-- a:longSize():I
-- a:shortSize():I
 f:com.intellij.vcs.log.graph.utils.LinearGraphUtils
-- sf:DEFAULT_GRAPH_ANSWER:com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAnswer
 - <init>():V
 - s:asLiteLinearGraph(com.intellij.vcs.log.graph.api.LinearGraph):com.intellij.vcs.log.graph.api.LiteLinearGraph
-- s:asNormalEdge(com.intellij.vcs.log.graph.api.elements.GraphEdge):com.intellij.vcs.log.graph.utils.NormalEdge
 - s:convertIdsToNodeIndexes(com.intellij.vcs.log.graph.api.LinearGraph,java.util.Collection):java.util.Set
 - s:convertNodeIndexesToIds(com.intellij.vcs.log.graph.api.LinearGraph,java.util.Collection):java.util.Set
-- s:createSelectedAnswer(com.intellij.vcs.log.graph.api.LinearGraph,java.util.Collection):com.intellij.vcs.log.graph.impl.facade.LinearGraphController$LinearGraphAnswer
 - s:getCursor(Z):java.awt.Cursor
 - s:getDownNodes(com.intellij.vcs.log.graph.api.LinearGraph,I):java.util.List
 - s:getDownNodesIncludeNotLoad(com.intellij.vcs.log.graph.api.LinearGraph,I):java.util.List
@@ -534,36 +155,6 @@ f:com.intellij.vcs.log.graph.utils.LinearGraphUtils
 - s:isEdgeDown(com.intellij.vcs.log.graph.api.elements.GraphEdge,I):Z
 - s:isEdgeUp(com.intellij.vcs.log.graph.api.elements.GraphEdge,I):Z
 - s:isNormalEdge(com.intellij.vcs.log.graph.api.elements.GraphEdge):Z
-c:com.intellij.vcs.log.graph.utils.NormalEdge
-- f:down:I
-- f:up:I
-- <init>(I,I):V
-- s:create(I,I):com.intellij.vcs.log.graph.utils.NormalEdge
-- equals(java.lang.Object):Z
-- getDown():I
-- getUp():I
-- hashCode():I
-com.intellij.vcs.log.graph.utils.TimestampGetter
-- a:getTimestamp(I):J
-- a:size():I
-c:com.intellij.vcs.log.graph.utils.UnsignedBitSet
-- java.lang.Cloneable
-- <init>():V
-- <init>(java.util.BitSet,java.util.BitSet):V
-- clone():com.intellij.vcs.log.graph.utils.UnsignedBitSet
-- get(I):Z
-- set(I,I,Z):V
-- set(I,Z):V
-com.intellij.vcs.log.graph.utils.UpdatableIntToIntMap
-- com.intellij.vcs.log.graph.utils.IntToIntMap
-- a:update(I,I):V
-a:com.intellij.vcs.log.graph.utils.impl.AbstractIntToIntMap
-- com.intellij.vcs.log.graph.utils.IntToIntMap
-- <init>():V
-- p:checkLongIndex(I):V
-- p:checkShortIndex(I):V
-- p:checkUpdateParameters(I,I):V
-- getShortIndex(I):I
 c:com.intellij.vcs.log.graph.utils.impl.BitSetFlags
 - com.intellij.vcs.log.graph.utils.Flags
 - <init>(I):V
@@ -574,73 +165,3 @@ c:com.intellij.vcs.log.graph.utils.impl.BitSetFlags
 - set(I,Z):V
 - setAll(Z):V
 - size():I
-f:com.intellij.vcs.log.graph.utils.impl.CompressedIntList
-- com.intellij.vcs.log.graph.utils.IntList
-- sf:DEFAULT_BLOCK_SIZE:I
-- get(I):I
-- s:newInstance(com.intellij.vcs.log.graph.utils.IntList,I):com.intellij.vcs.log.graph.utils.IntList
-- s:newInstance(java.util.List):com.intellij.vcs.log.graph.utils.IntList
-- s:newInstance(I[]):com.intellij.vcs.log.graph.utils.IntList
-- s:newInstance(I[],I):com.intellij.vcs.log.graph.utils.IntList
-- size():I
-c:com.intellij.vcs.log.graph.utils.impl.FullIntList
-- com.intellij.vcs.log.graph.utils.IntList
-- <init>(I[]):V
-- get(I):I
-- s:newInstance(com.intellij.vcs.log.graph.utils.IntList):com.intellij.vcs.log.graph.utils.impl.FullIntList
-- size():I
-c:com.intellij.vcs.log.graph.utils.impl.IDIntToIntMap
-- com.intellij.vcs.log.graph.utils.IntToIntMap
-- sf:EMPTY:com.intellij.vcs.log.graph.utils.UpdatableIntToIntMap
-- <init>(I):V
-- getLongIndex(I):I
-- getShortIndex(I):I
-- longSize():I
-- shortSize():I
-f:com.intellij.vcs.log.graph.utils.impl.IntTimestampGetter
-- com.intellij.vcs.log.graph.utils.TimestampGetter
-- getTimestamp(I):J
-- s:newInstance(com.intellij.vcs.log.graph.utils.TimestampGetter):com.intellij.vcs.log.graph.utils.impl.IntTimestampGetter
-- s:newInstance(com.intellij.vcs.log.graph.utils.TimestampGetter,I):com.intellij.vcs.log.graph.utils.impl.IntTimestampGetter
-- size():I
-f:com.intellij.vcs.log.graph.utils.impl.ListIntToIntMap
-- com.intellij.vcs.log.graph.utils.impl.AbstractIntToIntMap
-- com.intellij.vcs.log.graph.utils.UpdatableIntToIntMap
-- sf:DEFAULT_BLOCK_SIZE:I
-- getLongIndex(I):I
-- getShortIndex(I):I
-- longSize():I
-- s:newInstance(com.intellij.vcs.log.graph.utils.Flags):com.intellij.vcs.log.graph.utils.UpdatableIntToIntMap
-- s:newInstance(com.intellij.vcs.log.graph.utils.Flags,I):com.intellij.vcs.log.graph.utils.UpdatableIntToIntMap
-- s:newInstance(java.util.function.Predicate,I):com.intellij.vcs.log.graph.utils.UpdatableIntToIntMap
-- shortSize():I
-- update(I,I):V
-f:com.intellij.vcs.log.graph.utils.impl.PermanentListIntToIntMap
-- com.intellij.vcs.log.graph.utils.impl.AbstractIntToIntMap
-- com.intellij.vcs.log.graph.utils.IntToIntMap
-- sf:DEFAULT_BLOCK_SIZE:I
-- getLongIndex(I):I
-- longSize():I
-- s:newInstance(com.intellij.vcs.log.graph.utils.Flags,I):com.intellij.vcs.log.graph.utils.IntToIntMap
-- s:newInstance(com.intellij.vcs.log.graph.utils.Flags,I,I):com.intellij.vcs.log.graph.utils.IntToIntMap
-- shortSize():I
-c:com.intellij.vcs.log.graph.utils.impl.PredicateFlags
-- com.intellij.vcs.log.graph.utils.Flags
-- <init>(java.util.function.Predicate,I):V
-- get(I):Z
-- set(I,Z):V
-- setAll(Z):V
-- size():I
-f:com.intellij.vcs.log.graph.utils.impl.SmartDeltaCompressor
-- com.intellij.vcs.log.graph.utils.IntList
-- get(I):I
-- s:newInstance(com.intellij.vcs.log.graph.utils.IntList):com.intellij.vcs.log.graph.utils.impl.SmartDeltaCompressor
-- size():I
-f:com.intellij.vcs.log.graph.utils.impl.TreeIntToIntMap
-- com.intellij.vcs.log.graph.utils.impl.AbstractIntToIntMap
-- com.intellij.vcs.log.graph.utils.UpdatableIntToIntMap
-- getLongIndex(I):I
-- longSize():I
-- s:newInstance(java.util.function.Predicate,I):com.intellij.vcs.log.graph.utils.UpdatableIntToIntMap
-- shortSize():I
-- update(I,I):V

platform/vcs-log/graph/exposed-third-party-api.txt

@@ -1,6 +1 @@
-it/unimi/dsi/fastutil/ints/Int2ObjectMap
-it/unimi/dsi/fastutil/ints/IntComparator
-it/unimi/dsi/fastutil/ints/IntList
-it/unimi/dsi/fastutil/ints/IntOpenHashSet
-it/unimi/dsi/fastutil/ints/IntSet
 kotlin/jvm/internal/DefaultConstructorMarker

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/GraphCommitImpl.java

@@ -3,10 +3,12 @@ package com.intellij.vcs.log.graph;
 
 import com.google.common.primitives.Ints;
 import com.intellij.util.ArrayUtilRt;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
 
+@ApiStatus.Internal
 public final class GraphCommitImpl<CommitId> extends AbstractGraphCommit<CommitId> {
   @NotNull private final CommitId myId;
   @NotNull private final Object myParents;

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/collapsing/package-info.java

@@ -0,0 +1,4 @@
+@Internal
+package com.intellij.vcs.log.graph.collapsing;
+
+import org.jetbrains.annotations.ApiStatus.Internal;

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/BaseController.java

@@ -4,8 +4,10 @@ package com.intellij.vcs.log.graph.impl.facade;
 import com.intellij.vcs.log.graph.api.LinearGraph;
 import com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo;
 import com.intellij.vcs.log.graph.utils.LinearGraphUtils;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
+@ApiStatus.Internal
 public class BaseController implements LinearGraphController {
   @NotNull private final PermanentGraphInfo<?> myPermanentGraphInfo;
 

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/CascadeController.kt

@@ -4,7 +4,9 @@ package com.intellij.vcs.log.graph.impl.facade
 import com.intellij.vcs.log.graph.api.elements.GraphElement
 import com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo
 import com.intellij.vcs.log.graph.api.printer.GraphPrintElement
+import org.jetbrains.annotations.ApiStatus
 
+@ApiStatus.Internal
 abstract class CascadeController protected constructor(protected val delegateController: LinearGraphController,
                                                        val permanentGraphInfo: PermanentGraphInfo<*>) : LinearGraphController {
   override fun performLinearGraphAction(action: LinearGraphController.LinearGraphAction): LinearGraphController.LinearGraphAnswer {

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/FilteredController.kt

@@ -8,7 +8,9 @@ import com.intellij.vcs.log.graph.collapsing.CollapsedGraph
 import com.intellij.vcs.log.graph.collapsing.DottedFilterEdgesGenerator
 import com.intellij.vcs.log.graph.utils.LinearGraphUtils
 import com.intellij.vcs.log.graph.utils.getReachableMatchingNodes
+import org.jetbrains.annotations.ApiStatus
 
+@ApiStatus.Internal
 class FilteredController(delegateLinearGraphController: LinearGraphController, permanentGraphInfo: PermanentGraphInfo<*>,
                          buildCollapsedGraph: () -> CollapsedGraph) :
   CascadeController(delegateLinearGraphController, permanentGraphInfo) {

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/FirstParentController.kt

@@ -11,8 +11,10 @@ import com.intellij.vcs.log.graph.impl.permanent.GraphLayoutBuilder.getHeads
 import com.intellij.vcs.log.graph.utils.Dfs
 import com.intellij.vcs.log.graph.utils.UnsignedBitSet
 import com.intellij.vcs.log.graph.utils.impl.BitSetFlags
+import org.jetbrains.annotations.ApiStatus
 import org.jetbrains.annotations.VisibleForTesting
 
+@ApiStatus.Internal
 object FirstParentController {
   fun create(delegateController: LinearGraphController, permanentGraphInfo: PermanentGraphInfo<*>,
              matchedIds: Set<Int>?, visibleHeadsIds: Set<Int>? = null): FilteredController {

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/GraphChanges.java

@@ -15,11 +15,13 @@
  */
 package com.intellij.vcs.log.graph.impl.facade;
 
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Collection;
 
+@ApiStatus.Internal
 public interface GraphChanges<NodeId> {
 
   @NotNull

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/GraphChangesUtil.java

@@ -4,6 +4,7 @@ package com.intellij.vcs.log.graph.impl.facade;
 import com.intellij.vcs.log.graph.api.LinearGraph;
 import com.intellij.vcs.log.graph.api.elements.GraphEdge;
 import com.intellij.vcs.log.graph.impl.facade.GraphChanges.EdgeImpl;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Collection;
@@ -11,6 +12,7 @@ import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
 
+@ApiStatus.Internal
 public final class GraphChangesUtil {
   public static final GraphChanges<Integer> SOME_CHANGES = new GraphChanges<>() {
     @NotNull

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/GraphModificationUtil.kt

@@ -1,4 +1,6 @@
 // Copyright 2000-2024 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+@file:ApiStatus.Internal
+
 package com.intellij.vcs.log.graph.impl.facade
 
 import com.intellij.vcs.log.graph.api.elements.GraphEdge
@@ -7,6 +9,7 @@ import com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo
 import com.intellij.vcs.log.graph.collapsing.CollapsedGraph
 import com.intellij.vcs.log.graph.collapsing.DottedFilterEdgesGenerator
 import com.intellij.vcs.log.graph.impl.facade.CascadeController.Companion.performActionRecursively
+import org.jetbrains.annotations.ApiStatus
 
 fun <CommitId> hideCommits(graphController: LinearGraphController,
                            permanentGraphInfo: PermanentGraphInfo<CommitId>,

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/LinearGraphController.kt

@@ -4,8 +4,10 @@ package com.intellij.vcs.log.graph.impl.facade
 import com.intellij.vcs.log.graph.actions.GraphAction
 import com.intellij.vcs.log.graph.api.LinearGraph
 import com.intellij.vcs.log.graph.api.printer.GraphPrintElement
+import org.jetbrains.annotations.ApiStatus
 import java.awt.Cursor
 
+@ApiStatus.Internal
 interface LinearGraphController {
   val compiledGraph: LinearGraph
 

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/LinearGraphWrapper.kt

@@ -5,7 +5,9 @@ import com.intellij.vcs.log.graph.api.EdgeFilter
 import com.intellij.vcs.log.graph.api.LinearGraph
 import com.intellij.vcs.log.graph.api.elements.GraphEdge
 import com.intellij.vcs.log.graph.collapsing.EdgeStorageWrapper
+import org.jetbrains.annotations.ApiStatus
 
+@ApiStatus.Internal
 open class LinearGraphWrapper @JvmOverloads constructor(val graph: LinearGraph,
                                                         val hiddenEdges: EdgeStorageWrapper = EdgeStorageWrapper.createSimpleEdgeStorage(),
                                                         val dottedEdges: EdgeStorageWrapper = EdgeStorageWrapper.createSimpleEdgeStorage()) : LinearGraph {

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/PermanentGraphImpl.kt

@@ -19,6 +19,7 @@ import it.unimi.dsi.fastutil.ints.Int2ObjectMap
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap
 import it.unimi.dsi.fastutil.ints.IntOpenHashSet
 import it.unimi.dsi.fastutil.ints.IntSet
+import org.jetbrains.annotations.ApiStatus
 import java.util.*
 import java.util.function.BiConsumer
 import java.util.function.Function
@@ -119,9 +120,14 @@ class PermanentGraphImpl<CommitId : Any> private constructor(private val permane
     return ContainedInBranchCondition(branchNodes)
   }
 
+  @ApiStatus.Internal
   override fun getPermanentCommitsInfo(): PermanentCommitsInfoImpl<CommitId> = permanentCommitsInfo
+  
   override fun getLinearGraph(): PermanentLinearGraphImpl = permanentLinearGraph
+  
+  @ApiStatus.Internal
   override fun getPermanentGraphLayout(): GraphLayoutImpl = permanentGraphLayout
+  
   override fun getBranchNodeIds(): Set<Int> = branchNodeIds
 
   private class NotLoadedCommitsIdsGenerator<CommitId> : Function<CommitId, Int> {

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/ReachableNodes.kt

@@ -6,8 +6,10 @@ import com.intellij.vcs.log.graph.api.LiteLinearGraph
 import com.intellij.vcs.log.graph.utils.DfsWalk
 import com.intellij.vcs.log.graph.utils.Flags
 import com.intellij.vcs.log.graph.utils.impl.BitSetFlags
+import org.jetbrains.annotations.ApiStatus
 import java.util.function.Consumer
 
+@ApiStatus.Internal
 class ReachableNodes(private val graph: LiteLinearGraph) {
   private val visited: Flags = BitSetFlags(graph.nodesCount())
 

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/SimpleGraphInfo.java

@@ -22,6 +22,7 @@ import com.intellij.vcs.log.graph.utils.impl.IntTimestampGetter;
 import it.unimi.dsi.fastutil.ints.IntArrayList;
 import it.unimi.dsi.fastutil.objects.Object2IntMap;
 import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.*;
@@ -29,6 +30,7 @@ import java.util.function.Function;
 
 import static com.intellij.vcs.log.graph.utils.LinearGraphUtils.asLiteLinearGraph;
 
+@ApiStatus.Internal
 public final class SimpleGraphInfo<CommitId> implements PermanentGraphInfo<CommitId> {
   private final @NotNull LinearGraph myLinearGraph;
   private final @NotNull GraphLayout myGraphLayout;

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/VisibleGraphImpl.kt

@@ -17,8 +17,10 @@ import com.intellij.vcs.log.graph.impl.facade.LinearGraphController.LinearGraphA
 import com.intellij.vcs.log.graph.impl.print.GraphElementComparatorByLayoutIndex
 import com.intellij.vcs.log.graph.impl.print.PrintElementGeneratorImpl
 import com.intellij.vcs.log.graph.utils.LinearGraphUtils
+import org.jetbrains.annotations.ApiStatus
 import java.awt.Cursor
 
+@ApiStatus.Internal
 class VisibleGraphImpl<CommitId : Any>(private val graphController: LinearGraphController,
                                        val permanentGraph: PermanentGraphInfo<CommitId>,
                                        private val colorGenerator: GraphColorGetter) : VisibleGraph<CommitId> {

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/sort/bek/package-info.java

@@ -0,0 +1,4 @@
+@Internal
+package com.intellij.vcs.log.graph.impl.facade.sort.bek;
+
+import org.jetbrains.annotations.ApiStatus.Internal;

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/facade/sort/package-info.java

@@ -0,0 +1,4 @@
+@Internal
+package com.intellij.vcs.log.graph.impl.facade.sort;
+
+import org.jetbrains.annotations.ApiStatus.Internal;

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/permanent/DuplicateParentFixer.java

@@ -4,10 +4,12 @@ package com.intellij.vcs.log.graph.impl.permanent;
 
 
 import com.intellij.vcs.log.graph.GraphCommit;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.*;
 
+@ApiStatus.Internal
 public final class DuplicateParentFixer {
 
   public static <CommitId> AbstractList<? extends GraphCommit<CommitId>> fixDuplicateParentCommits(final List<? extends GraphCommit<CommitId>> finalCommits) {

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/permanent/GraphLayoutBuilder.kt

@@ -10,7 +10,9 @@ import com.intellij.vcs.log.graph.utils.walk
 import it.unimi.dsi.fastutil.ints.IntArrayList
 import it.unimi.dsi.fastutil.ints.IntComparator
 import it.unimi.dsi.fastutil.ints.IntList
+import org.jetbrains.annotations.ApiStatus
 
+@ApiStatus.Internal
 object GraphLayoutBuilder {
   private val LOG = Logger.getInstance(GraphLayoutBuilder::class.java)
 

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/permanent/GraphLayoutImpl.kt

@@ -4,9 +4,11 @@ package com.intellij.vcs.log.graph.impl.permanent
 import com.intellij.vcs.log.graph.api.GraphLayout
 import com.intellij.vcs.log.graph.utils.impl.CompressedIntList
 import it.unimi.dsi.fastutil.ints.IntList
+import org.jetbrains.annotations.ApiStatus
 import java.util.*
 import kotlin.math.max
 
+@ApiStatus.Internal
 class GraphLayoutImpl(layoutIndex: IntArray, private val headNodes: IntList) : GraphLayout {
   private val layoutIndexForHeadNodes = getLayoutIndexesForHeads(layoutIndex, headNodes)
   private val layoutIndex = CompressedIntList.newInstance(layoutIndex)

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/permanent/PermanentCommitsInfoImpl.kt

@@ -10,9 +10,11 @@ import com.intellij.vcs.log.graph.utils.impl.IntTimestampGetter
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap
 import it.unimi.dsi.fastutil.ints.IntOpenHashSet
 import it.unimi.dsi.fastutil.ints.IntSet
+import org.jetbrains.annotations.ApiStatus
 import java.util.*
 
-class PermanentCommitsInfoImpl<CommitId : Any> private constructor(val timestampGetter: TimestampGetter,
+@ApiStatus.Internal
+class PermanentCommitsInfoImpl<CommitId : Any> private constructor(internal val timestampGetter: TimestampGetter,
                                                                    private val commitIdIndexes: List<CommitId>,
                                                                    private val notLoadedCommits: Int2ObjectMap<CommitId>) : PermanentCommitsInfo<CommitId> {
   override fun getCommitId(nodeId: Int): CommitId {

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/permanent/PermanentLinearGraphBuilder.java

@@ -7,6 +7,7 @@ import com.intellij.util.containers.ContainerUtil;
 import com.intellij.vcs.log.graph.GraphCommit;
 import com.intellij.vcs.log.graph.utils.Flags;
 import com.intellij.vcs.log.graph.utils.impl.BitSetFlags;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -15,6 +16,7 @@ import java.util.function.Function;
 
 import static com.intellij.vcs.log.graph.impl.permanent.DuplicateParentFixer.fixDuplicateParentCommits;
 
+@ApiStatus.Internal
 public final class PermanentLinearGraphBuilder<CommitId> {
 
   @NotNull private final List<? extends GraphCommit<CommitId>> myCommits;

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/impl/print/GraphColorGetterByHead.kt

@@ -5,6 +5,7 @@ import com.intellij.vcs.log.graph.GraphColorManager
 import com.intellij.vcs.log.graph.api.permanent.PermanentGraphInfo
 import com.intellij.vcs.log.graph.api.printer.GraphColorGetter
 import com.intellij.vcs.log.graph.api.printer.GraphColorGetterFactory
+import org.jetbrains.annotations.ApiStatus
 
 private class GraphColorGetterByHead<CommitId : Any>(private val permanentGraphInfo: PermanentGraphInfo<CommitId>,
                                                      private val colorManager: GraphColorManager<CommitId>) : GraphColorGetter {
@@ -21,6 +22,7 @@ private class GraphColorGetterByHead<CommitId : Any>(private val permanentGraphI
  * @property colorManager a [GraphColorManager] implementation to get colors by head commit of the main branch
  *                        and by head commit and layout index of the fragment.
  */
+@ApiStatus.Internal
 class GraphColorGetterByHeadFactory<CommitId : Any>(private val colorManager: GraphColorManager<CommitId>) : GraphColorGetterFactory<CommitId> {
   override fun createColorGetter(permanentGraphInfo: PermanentGraphInfo<CommitId>): GraphColorGetter {
     return GraphColorGetterByHead(permanentGraphInfo, colorManager)

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/linearBek/package-info.java

@@ -0,0 +1,4 @@
+@Internal
+package com.intellij.vcs.log.graph.linearBek;
+
+import org.jetbrains.annotations.ApiStatus.Internal;

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/BfsUtil.kt

@@ -18,6 +18,7 @@ package com.intellij.vcs.log.graph.utils
 import com.intellij.util.containers.ContainerUtil
 import com.intellij.vcs.log.graph.api.LiteLinearGraph
 import com.intellij.vcs.log.graph.utils.impl.BitSetFlags
+import org.jetbrains.annotations.ApiStatus
 import java.util.*
 
 open class BfsWalk(val start: Int, private val graph: LiteLinearGraph, private val visited: Flags, private val down: Boolean = true) {
@@ -55,6 +56,7 @@ open class BfsWalk(val start: Int, private val graph: LiteLinearGraph, private v
   }
 }
 
+@ApiStatus.Internal
 open class BfsSearch<T>(start: Int, graph: LiteLinearGraph, visited: Flags, down: Boolean = true,
                         private val limit: Int = graph.nodesCount()) : BfsWalk(start, graph, visited, down) {
   var result: T? = null

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/DfsUtil.kt

@@ -6,7 +6,9 @@ import com.intellij.vcs.log.graph.api.LinearGraph
 import com.intellij.vcs.log.graph.api.LiteLinearGraph
 import com.intellij.vcs.log.graph.utils.impl.BitSetFlags
 import it.unimi.dsi.fastutil.ints.IntArrayList
+import org.jetbrains.annotations.ApiStatus
 
+@ApiStatus.Internal
 object Dfs {
   object NextNode {
     const val NODE_NOT_FOUND = -1
@@ -30,6 +32,7 @@ private fun walk(start: Int, stack: IntArrayList, nextNodeFun: (Int) -> Int) {
   stack.clear()
 }
 
+@ApiStatus.Internal
 fun walk(start: Int, nextNodeFun: (Int) -> Int) {
   walk(start, IntArrayList(), nextNodeFun)
 }

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/GraphUtil.kt

@@ -7,6 +7,7 @@ import com.intellij.vcs.log.graph.api.LiteLinearGraph
 import com.intellij.vcs.log.graph.utils.impl.BitSetFlags
 import it.unimi.dsi.fastutil.ints.IntOpenHashSet
 import it.unimi.dsi.fastutil.ints.IntSet
+import org.jetbrains.annotations.ApiStatus
 import kotlin.math.max
 
 /**
@@ -43,6 +44,7 @@ internal fun LinearGraph.getReachableMatchingNodes(startNodes: Set<Int>?, matche
 /**
  * Check whether lowerNode is an ancestor of the upperNode.
  */
+@ApiStatus.Internal
 fun LiteLinearGraph.isAncestor(lowerNode: Int, upperNode: Int): Boolean {
   val visited = BitSetFlags(nodesCount(), false)
 
@@ -72,6 +74,7 @@ fun LiteLinearGraph.isAncestor(lowerNode: Int, upperNode: Int): Boolean {
  * Find a parent of the startNode which is on the path to the endNode.
  * Fails when there is no path from startNode to endNode.
  */
+@ApiStatus.Internal
 fun LiteLinearGraph.getCorrespondingParent(startNode: Int, endNode: Int, visited: Flags): Int {
   val candidates = getNodes(startNode, LiteLinearGraph.NodeFilter.DOWN)
   if (candidates.size == 1) return candidates[0]
@@ -96,6 +99,7 @@ fun LiteLinearGraph.getCorrespondingParent(startNode: Int, endNode: Int, visited
 /**
  * Return a set of nodes that are reachable from the first node, but not from the second.
  */
+@ApiStatus.Internal
 fun LinearGraph.subgraphDifference(node1: Int, node2: Int): IntSet {
   val liteLinearGraph = LinearGraphUtils.asLiteLinearGraph(this)
 
@@ -134,6 +138,7 @@ private fun Iterable<Int>.maxOrDefault(): Int {
 /**
  * Returns a set of nodes in the graph that are reachable only from the specified head node and not from others.
  */
+@ApiStatus.Internal
 fun LiteLinearGraph.exclusiveNodes(headNode: Int, isHead: (Int) -> Boolean = { false }): IntSet {
   val result = IntOpenHashSet()
   BfsWalk(headNode, this).walk { it ->
@@ -153,6 +158,7 @@ fun LiteLinearGraph.exclusiveNodes(headNode: Int, isHead: (Int) -> Boolean = { f
 /**
  * Returns a set of nodes in the graph that are reachable only from the specified head node and not from others.
  */
+@ApiStatus.Internal
 fun LinearGraph.exclusiveNodes(headNode: Int, isHead: (Int) -> Boolean = { false }): IntSet {
   return LinearGraphUtils.asLiteLinearGraph(this).exclusiveNodes(headNode, isHead)
 }

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/IntHashSetFlags.kt

@@ -2,7 +2,9 @@
 package com.intellij.vcs.log.graph.utils
 
 import it.unimi.dsi.fastutil.ints.IntOpenHashSet
+import org.jetbrains.annotations.ApiStatus
 
+@ApiStatus.Internal
 open class IntHashSetFlags(private val size: Int) : Flags {
   val data = IntOpenHashSet()
 

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/IntIntMultiMap.java

@@ -3,11 +3,13 @@ package com.intellij.vcs.log.graph.utils;
 
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.AbstractList;
 import java.util.Collection;
 
+@ApiStatus.Internal
 public final class IntIntMultiMap {
   private final static int[] EMPTY = new int[0];
   private final Int2ObjectMap<int[]> myKeyToArrayMap = new Int2ObjectOpenHashMap<>();

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/IntList.java

@@ -15,9 +15,12 @@
  */
 package com.intellij.vcs.log.graph.utils;
 
+import org.jetbrains.annotations.ApiStatus;
+
 /**
  * @author erokhins
  */
+@ApiStatus.Internal
 public interface IntList {
   int size();
 

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/IntToIntMap.java

@@ -15,9 +15,12 @@
  */
 package com.intellij.vcs.log.graph.utils;
 
+import org.jetbrains.annotations.ApiStatus;
+
 /**
  * @author erokhins
  */
+@ApiStatus.Internal
 public interface IntToIntMap {
   int shortSize();
 

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/LinearGraphUtils.java

@@ -8,6 +8,7 @@ import com.intellij.vcs.log.graph.api.LiteLinearGraph;
 import com.intellij.vcs.log.graph.api.elements.GraphEdge;
 import com.intellij.vcs.log.graph.api.elements.GraphEdgeType;
 import com.intellij.vcs.log.graph.impl.facade.LinearGraphController;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -18,6 +19,7 @@ import java.util.List;
 import java.util.Set;
 
 public final class LinearGraphUtils {
+  @ApiStatus.Internal
   public static final LinearGraphController.LinearGraphAnswer DEFAULT_GRAPH_ANSWER =
     new LinearGraphController.LinearGraphAnswer(Cursor.getDefaultCursor(), null);
 
@@ -41,6 +43,7 @@ public final class LinearGraphUtils {
     return false;
   }
 
+  @ApiStatus.Internal
   @Nullable
   public static NormalEdge asNormalEdge(@Nullable GraphEdge edge) {
     if (isNormalEdge(edge)) {
@@ -108,6 +111,7 @@ public final class LinearGraphUtils {
     }
   }
 
+  @ApiStatus.Internal
   public static LinearGraphController.LinearGraphAnswer createSelectedAnswer(@NotNull LinearGraph linearGraph,
                                                                              @NotNull Collection<Integer> selectedNodeIndexes) {
     Set<Integer> selectedIds = new HashSet<>();

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/NormalEdge.java

@@ -15,6 +15,9 @@
  */
 package com.intellij.vcs.log.graph.utils;
 
+import org.jetbrains.annotations.ApiStatus;
+
+@ApiStatus.Internal
 public class NormalEdge {
   public final int up;
   public final int down;

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/TimestampGetter.java

@@ -15,9 +15,12 @@
  */
 package com.intellij.vcs.log.graph.utils;
 
+import org.jetbrains.annotations.ApiStatus;
+
 /**
  * @author erokhins
  */
+@ApiStatus.Internal
 public interface TimestampGetter {
 
   int size();

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/UnsignedBitSet.java

@@ -15,10 +15,12 @@
  */
 package com.intellij.vcs.log.graph.utils;
 
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.BitSet;
 
+@ApiStatus.Internal
 public class UnsignedBitSet implements Cloneable {
   @NotNull private final BitSet myPositiveSet;
   @NotNull private final BitSet myNegativeSet;

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/UpdatableIntToIntMap.java

@@ -15,9 +15,12 @@
  */
 package com.intellij.vcs.log.graph.utils;
 
+import org.jetbrains.annotations.ApiStatus;
+
 /**
  * @author erokhins
  */
+@ApiStatus.Internal
 public interface UpdatableIntToIntMap extends IntToIntMap {
   void update(int startLongIndex, int endLongIndex);
 }

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/impl/AbstractIntToIntMap.java

@@ -17,7 +17,9 @@
 package com.intellij.vcs.log.graph.utils.impl;
 
 import com.intellij.vcs.log.graph.utils.IntToIntMap;
+import org.jetbrains.annotations.ApiStatus;
 
+@ApiStatus.Internal
 public abstract class AbstractIntToIntMap implements IntToIntMap {
 
   @Override

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/impl/CompressedIntList.java

@@ -2,10 +2,12 @@
 package com.intellij.vcs.log.graph.utils.impl;
 
 import com.intellij.vcs.log.graph.utils.IntList;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
 
+@ApiStatus.Internal
 public final class CompressedIntList implements IntList {
   public static final int DEFAULT_BLOCK_SIZE = 30;
 

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/impl/FullIntList.java

@@ -17,8 +17,10 @@
 package com.intellij.vcs.log.graph.utils.impl;
 
 import com.intellij.vcs.log.graph.utils.IntList;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
+@ApiStatus.Internal
 public class FullIntList implements IntList {
 
   public static FullIntList newInstance(@NotNull IntList delegateList) {

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/impl/IDIntToIntMap.java

@@ -17,8 +17,10 @@ package com.intellij.vcs.log.graph.utils.impl;
 
 import com.intellij.vcs.log.graph.utils.IntToIntMap;
 import com.intellij.vcs.log.graph.utils.UpdatableIntToIntMap;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
+@ApiStatus.Internal
 public class IDIntToIntMap implements IntToIntMap {
   @NotNull public static final UpdatableIntToIntMap EMPTY = new EmptyIDIntToIntMap();
 

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/impl/IntTimestampGetter.java

@@ -6,8 +6,10 @@ import com.intellij.vcs.log.graph.utils.IntList;
 import com.intellij.vcs.log.graph.utils.TimestampGetter;
 import it.unimi.dsi.fastutil.ints.Int2LongMap;
 import it.unimi.dsi.fastutil.ints.Int2LongOpenHashMap;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
+@ApiStatus.Internal
 public final class IntTimestampGetter implements TimestampGetter {
   private static final int DEFAULT_BLOCK_SIZE = 30;
 

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/impl/ListIntToIntMap.java

@@ -4,10 +4,12 @@ package com.intellij.vcs.log.graph.utils.impl;
 
 import com.intellij.vcs.log.graph.utils.Flags;
 import com.intellij.vcs.log.graph.utils.UpdatableIntToIntMap;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.function.Predicate;
 
+@ApiStatus.Internal
 public final class ListIntToIntMap extends AbstractIntToIntMap implements UpdatableIntToIntMap {
   public static final int DEFAULT_BLOCK_SIZE = 30;
 

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/impl/PermanentListIntToIntMap.java

@@ -3,8 +3,10 @@ package com.intellij.vcs.log.graph.utils.impl;
 
 import com.intellij.vcs.log.graph.utils.Flags;
 import com.intellij.vcs.log.graph.utils.IntToIntMap;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
+@ApiStatus.Internal
 public final class PermanentListIntToIntMap extends AbstractIntToIntMap implements IntToIntMap {
   public static final int DEFAULT_BLOCK_SIZE = 30;
 

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/impl/PredicateFlags.java

@@ -2,10 +2,12 @@
 package com.intellij.vcs.log.graph.utils.impl;
 
 import com.intellij.vcs.log.graph.utils.Flags;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.function.Predicate;
 
+@ApiStatus.Internal
 public class PredicateFlags implements Flags {
   private final @NotNull Predicate<? super Integer> myVisible;
   private final int mySize;

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/impl/SmartDeltaCompressor.java

@@ -2,10 +2,12 @@
 package com.intellij.vcs.log.graph.utils.impl;
 
 import com.intellij.vcs.log.graph.utils.IntList;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
 import static com.intellij.vcs.log.graph.utils.impl.ByteArrayUtils.*;
 
+@ApiStatus.Internal
 public final class SmartDeltaCompressor implements IntList {
 
   @NotNull

platform/vcs-log/graph/src/com/intellij/vcs/log/graph/utils/impl/TreeIntToIntMap.java

@@ -3,10 +3,12 @@
 package com.intellij.vcs.log.graph.utils.impl;
 
 import com.intellij.vcs.log.graph.utils.UpdatableIntToIntMap;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.function.Predicate;
 
+@ApiStatus.Internal
 public final class TreeIntToIntMap extends AbstractIntToIntMap implements UpdatableIntToIntMap {
 
   public static UpdatableIntToIntMap newInstance(@NotNull final Predicate<? super Integer> thisIsVisible, final int longSize) {