package body Packrat.Graphs is



    function Leaf
           (New_Item : in Element_Array;
            Start    : in Positive;
            Finish   : in Natural)
        return Node is
    begin
        return This : Node;
    end Leaf;


    function Branch
           (Label  : in Label_Enum;
            Start  : in Positive;
            Finish : in Natural)
        return Node is
    begin
        return This : Node;
    end Branch;





    function Is_Leaf
           (This : in Node)
        return Boolean is
    begin
        return False;
    end Is_Leaf;


    function Is_Branch
           (This : in Node)
        return Boolean is
    begin
        return False;
    end Is_Branch;





    function Label
           (This : in Node)
        return Label_Enum is
    begin
        return Label_Enum'First;
    end Label;


    function Elements
           (This : in Node)
        return Element_Array
    is
        Empty : Element_Array (1 .. 0);
    begin
        return Empty;
    end Elements;


    function Start
           (This : in Node)
        return Positive is
    begin
        return 1;
    end Start;


    function Finish
           (This : in Node)
        return Natural is
    begin
        return 0;
    end Finish;





    function Is_Nothing
           (Position : in Cursor)
        return Boolean is
    begin
        return True;
    end Is_Nothing;





    function Depth
           (Position : in Cursor)
        return Natural is
    begin
        return 0;
    end Depth;


    function Is_Node
           (Position : in Cursor)
        return Boolean is
    begin
        return False;
    end Is_Node;


    function Is_Root
           (Position : in Cursor)
        return Boolean is
    begin
        return False;
    end Is_Root;


    function Is_Branch
           (Position : in Cursor)
        return Boolean is
    begin
        return False;
    end Is_Branch;


    function Is_Leaf
           (Position : in Cursor)
        return Boolean is
    begin
        return False;
    end Is_Leaf;


    function Label
           (Position : in Cursor)
        return Label_Enum is
    begin
        return Label_Enum'First;
    end Label;


    function Elements
           (Position : in Cursor)
        return Element_Array
    is
        Empty : Element_Array (1 .. 0);
    begin
        return Empty;
    end Elements;





    function Start
           (Position : in Cursor)
        return Positive is
    begin
        return 1;
    end Start;


    function Finish
           (Position : in Cursor)
        return Natural is
    begin
        return 0;
    end Finish;


    function Choices
           (Position : in Cursor)
        return Natural is
    begin
        return 0;
    end Choices;





    function Parent
           (Position : in Cursor)
        return Cursor is
    begin
        return This : Cursor;
    end Parent;


    function Child_Count
           (Position : in Cursor;
            Choice   : in Positive)
        return Natural is
    begin
        return 0;
    end Child_Count;


    function Child_Count
           (Position : in Cursor)
        return Natural is
    begin
        return 0;
    end Child_Count;


    function All_Child_Count
           (Position : in Cursor)
        return Natural is
    begin
        return 0;
    end All_Child_Count;


    function First_Child
           (Position : in Cursor;
            Choice   : in Positive)
        return Cursor is
    begin
        return This : Cursor;
    end First_Child;


    function Last_Child
           (Position : in Cursor;
            Choice   : in Positive)
        return Cursor is
    begin
        return This : Cursor;
    end Last_Child;


    function First_Child
           (Position : in Cursor)
        return Cursor is
    begin
        return This : Cursor;
    end First_Child;


    function Last_Child
           (Position : in Cursor)
        return Cursor is
    begin
        return This : Cursor;
    end Last_Child;


    function Next_Sibling
           (Position : in Cursor)
        return Cursor is
    begin
        return This : Cursor;
    end Next_Sibling;


    function Prev_Sibling
           (Position : in Cursor)
        return Cursor is
    begin
        return This : Cursor;
    end Prev_Sibling;


    procedure Delete_Children
           (Position : in out Cursor;
            Choice   : in     Positive) is
    begin
        null;
    end Delete_Children;


    procedure Delete_Children
           (Position : in out Cursor) is
    begin
        null;
    end Delete_Children;


    procedure Delete_All_Children
           (Position : in out Cursor) is
    begin
        null;
    end Delete_All_Children;





    function Equal_Subgraph
           (Left, Right : in Cursor)
        return Boolean is
    begin
        return False;
    end Equal_Subgraph;


    function Subgraph_Node_Count
           (Position : in Cursor)
        return Natural is
    begin
        return 0;
    end Subgraph_Node_Count;


    function Find_In_Subgraph
           (Position : in Cursor;
            Item     : in Element_Array)
        return Cursor is
    begin
        return This : Cursor;
    end Find_In_Subgraph;





    function Contains
           (Container : in Parse_Graph;
            Position  : in My_Interfaces.Cursor'Class)
        return Boolean is
    begin
        return False;
    end Contains;




    function Singleton
           (Input : in My_Interfaces.Node'Class)
        return Parse_Graph is
    begin
        return This : Parse_Graph;
    end Singleton;


    function Node_At
           (Container : in Parse_Graph;
            Position  : in My_Interfaces.Cursor'Class)
        return Node_Reference is
    begin
        return (Data => No_Node'Unrestricted_Access);
    end Node_At;





    function Is_Empty
           (Container : in Parse_Graph)
        return Boolean is
    begin
        return True;
    end Is_Empty;


    function Is_Ambiguous
           (Container : in Parse_Graph)
        return Boolean is
    begin
        return False;
    end Is_Ambiguous;


    function Node_Count
           (Container : in Parse_Graph)
        return Natural is
    begin
        return 0;
    end Node_Count;





    function Root_Count
           (Container : in Parse_Graph)
        return Natural is
    begin
        return 0;
    end Root_Count;


    function Root
           (Container : in Parse_Graph;
            Index     : in Positive)
        return My_Interfaces.Cursor'Class is
    begin
        return This : Cursor;
    end Root;





    procedure Append
           (Container : in out Parse_Graph;
            Addition  : in     Parse_Graph) is
    begin
        null;
    end Append;


    procedure Prepend
           (Container : in out Parse_Graph;
            Addition  : in     Parse_Graph) is
    begin
        null;
    end Prepend;


    procedure Attach_Choice
           (Container : in out Parse_Graph;
            Position  : in     My_Interfaces.Cursor'Class;
            Addition  : in     Parse_Graph) is
    begin
        null;
    end Attach_Choice;





    procedure Clear
           (Container : in out Parse_Graph) is
    begin
        null;
    end Clear;


    procedure Delete_Position
           (Container : in out Parse_Graph;
            Position  : in out My_Interfaces.Cursor'Class) is
    begin
        null;
    end Delete_Position;





    function Find
           (Container : in Parse_Graph;
            Item      : in Element_Array)
        return My_Interfaces.Cursor'Class is
    begin
        return This : Cursor;
    end Find;





    function Is_Valid_Node
           (Position : in Iter_Cursor)
        return Boolean is
    begin
        return Position.Data.Is_Node;
    end Is_Valid_Node;





    function Iterate
           (This : in Parse_Graph)
        return Graph_Iterators.Reversible_Iterator'Class is
    begin
        return Result : Reversible_Iterator do
            Result.My_Container := This'Unrestricted_Access;
            Result.My_Position := No_Position;
        end return;
    end Iterate;


    function Iterate_Subtree
           (This     : in Parse_Graph;
            Position : in My_Interfaces.Cursor'Class)
        return Graph_Iterators.Reversible_Iterator'Class is
    begin
        return Result : Reversible_Iterator do
            Result.My_Container := This'Unrestricted_Access;
            Result.My_Position := No_Position;
        end return;
    end Iterate_Subtree;


    function Iterate_Choice
           (This : in Parse_Graph;
            Func : in Choosing_Function)
        return Graph_Iterators.Forward_Iterator'Class is
    begin
        return Result : Forward_Iterator do
            Result.My_Container := This'Unrestricted_Access;
            Result.My_Position := No_Position;
        end return;
    end Iterate_Choice;





    function First
           (Object : in Forward_Iterator)
        return Iter_Cursor is
    begin
        return (Data => Object.My_Position'Unrestricted_Access);
    end First;

    function Next
           (Object : in Forward_Iterator;
            Place  : in Iter_Cursor)
        return Iter_Cursor is
    begin
        return (Data => Object.My_Position'Unrestricted_Access);
    end Next;





    function First
           (Object : in Reversible_Iterator)
        return Iter_Cursor is
    begin
        return (Data => Object.My_Position'Unrestricted_Access);
    end First;


    function Next
           (Object : in Reversible_Iterator;
            Place  : in Iter_Cursor)
        return Iter_Cursor is
    begin
        return (Data => Object.My_Position'Unrestricted_Access);
    end Next;


    function Last
           (Object : in Reversible_Iterator)
        return Iter_Cursor is
    begin
        return (Data => Object.My_Position'Unrestricted_Access);
    end Last;


    function Previous
           (Object : in Reversible_Iterator;
            Place  : in Iter_Cursor)
        return Iter_Cursor is
    begin
        return (Data => Object.My_Position'Unrestricted_Access);
    end Previous;


end Packrat.Graphs;