@dstanesc/o-o-o-o-o-o-o/dist/graph.d.ts

O-O-O-O-O-O-O is a collection of content addressed persistent data structures

import { Vertex, Edge, Prop, Offset, VertexRef, EdgeRef, PropRef, VertexType, EdgeType, PropType, KeyType, PropValue, Link, Block, RootIndex, IndexedValue, Index, IndexRef, IndexType, Version, Comment, Tag } from './types';
import { IndexStore } from './index-store';
import { PropPredicate } from './navigate';
import { Signer } from './trust';
interface ElementAccessor {
    getVertex: (ref: VertexRef) => Promise<Vertex>;
    getEdge: (ref: EdgeRef) => Promise<Edge>;
    getProp: (ref: PropRef) => Promise<Prop>;
}
declare class Graph implements ElementAccessor {
    vertices: Map<number, Vertex>;
    edges: Map<number, Edge>;
    props: Map<number, Prop>;
    indices: Map<number, Index>;
    versionSet: ({ version, index, }: {
        version: Version;
        index: RootIndex;
    }) => Promise<Link>;
    rootGet: () => Promise<{
        root: Link;
        index: RootIndex;
    }>;
    vertexGet: ({ root, index }: {
        root: Link;
        index: RootIndex;
    }, offset: number) => Promise<Vertex>;
    vertexRange: ({ root, index }: {
        root: Link;
        index: RootIndex;
    }, offset: number, count: number) => Promise<Vertex[]>;
    edgeGet: ({ root, index }: {
        root: Link;
        index: RootIndex;
    }, offset: number) => Promise<Edge>;
    edgeRange: ({ root, index }: {
        root: Link;
        index: RootIndex;
    }, offset: number, count: number) => Promise<Edge[]>;
    propGet: ({ root, index }: {
        root: Link;
        index: RootIndex;
    }, offset: number) => Promise<Prop>;
    propRange: ({ root, index }: {
        root: Link;
        index: RootIndex;
    }, offset: number, count: number) => Promise<Prop[]>;
    indexGet: ({ root, index }: {
        root: Link;
        index: RootIndex;
    }, offset: number) => Promise<Index>;
    offsetsGet: ({ root, index }: {
        root: Link;
        index: RootIndex;
    }) => Promise<{
        vertexOffset: Offset;
        edgeOffset: Offset;
        propOffset: Offset;
        indexOffset: Offset;
    }>;
    verticesAll: ({ root, index, }: {
        root: Link;
        index: RootIndex;
    }) => Promise<Vertex[]>;
    edgesAll: ({ root, index, }: {
        root: Link;
        index: RootIndex;
    }) => Promise<Edge[]>;
    propsAll: ({ root, index, }: {
        root: Link;
        index: RootIndex;
    }) => Promise<Prop[]>;
    commit: ({ root, index }: {
        root: Link;
        index: RootIndex;
    }, { vertices, edges, props, }: {
        vertices: {
            added: Map<number, Vertex>;
            updated: Map<number, Vertex>;
        };
        edges: {
            added: Map<number, Edge>;
            updated: Map<number, Edge>;
        };
        props: {
            added: Map<number, Prop>;
            updated: Map<number, Prop>;
        };
        indices: {
            added: Map<number, Index>;
            updated: Map<number, Index>;
        };
    }) => Promise<{
        root: Link;
        index: RootIndex;
        blocks: Block[];
    }>;
    packGraph: (versionRoot: Link) => Promise<Block>;
    packComputed: (versionRoot: Link, vertexOffsetStart: number, vertexCount: number, graphDepth: number) => Promise<Block>;
    indexCreate: (values: IndexedValue[]) => Promise<Link>;
    indexSearch: (link: Link, value: any) => Promise<IndexedValue>;
    constructor({ versionSet, rootGet, }: {
        versionSet: ({ version, index, }: {
            version: Version;
            index: RootIndex;
        }) => Promise<Link>;
        rootGet: () => Promise<{
            root: Link;
            index: RootIndex;
        }>;
    }, { vertexGet, vertexRange, edgeGet, edgeRange, propGet, propRange, indexGet, offsetsGet, verticesAll, edgesAll, propsAll, commit, packGraph, packComputed, }: {
        vertexGet: ({ root, index }: {
            root: Link;
            index: RootIndex;
        }, offset: number) => Promise<Vertex>;
        vertexRange: ({ root, index }: {
            root: Link;
            index: RootIndex;
        }, offset: number, vertexCount: number) => Promise<Vertex[]>;
        edgeGet: ({ root, index }: {
            root: Link;
            index: RootIndex;
        }, offset: number) => Promise<Edge>;
        edgeRange: ({ root, index }: {
            root: Link;
            index: RootIndex;
        }, offset: number, edgeCount: number) => Promise<Edge[]>;
        propGet: ({ root, index }: {
            root: Link;
            index: RootIndex;
        }, offset: number) => Promise<Prop>;
        propRange: ({ root, index }: {
            root: Link;
            index: RootIndex;
        }, offset: number, propCount: number) => Promise<Prop[]>;
        indexGet: ({ root, index }: {
            root: Link;
            index: RootIndex;
        }, offset: number) => Promise<Index>;
        offsetsGet: ({ root, index, }: {
            root: Link;
            index: RootIndex;
        }) => Promise<{
            vertexOffset: Offset;
            edgeOffset: Offset;
            propOffset: Offset;
            indexOffset: Offset;
        }>;
        verticesAll: ({ root, index, }: {
            root: Link;
            index: RootIndex;
        }) => Promise<Vertex[]>;
        edgesAll: ({ root, index, }: {
            root: Link;
            index: RootIndex;
        }) => Promise<Edge[]>;
        propsAll: ({ root, index, }: {
            root: Link;
            index: RootIndex;
        }) => Promise<Prop[]>;
        commit: ({ root, index }: {
            root: Link;
            index: RootIndex;
        }, { vertices, edges, props, }: {
            vertices: {
                added: Map<number, Vertex>;
                updated: Map<number, Vertex>;
            };
            edges: {
                added: Map<number, Edge>;
                updated: Map<number, Edge>;
            };
            props: {
                added: Map<number, Prop>;
                updated: Map<number, Prop>;
            };
            indices: {
                added: Map<number, Index>;
                updated: Map<number, Index>;
            };
        }) => Promise<{
            root: Link;
            index: RootIndex;
            blocks: Block[];
        }>;
        packGraph: (versionRoot: Link) => Promise<Block>;
        packComputed: (versionRoot: Link, vertexOffsetStart: number, vertexCount: number, graphDepth: number) => Promise<Block>;
    }, { indexCreate, indexSearch }?: IndexStore);
    getVertex(ref: VertexRef): Promise<Vertex>;
    getVertexRange(startRef: VertexRef, vertexCount: number): Promise<Vertex[]>;
    getEdge(ref: EdgeRef): Promise<Edge>;
    getEdgeRange(startRef: EdgeRef, edgeCount: number): Promise<Edge[]>;
    getProp(ref: PropRef): Promise<Prop>;
    getPropRange(startRef: PropRef, propCount: number): Promise<Prop[]>;
    getIndex(ref: IndexRef): Promise<Index>;
    allVertices(): Promise<Vertex[]>;
    allEdges(): Promise<Edge[]>;
    allProps(): Promise<Prop[]>;
    matchAnyEdgeProp(edge: Edge, predicate: PropPredicate): Promise<boolean>;
    matchAnyVertexProp(vertex: Vertex, predicate: PropPredicate): Promise<boolean>;
    matchNextProp(ref: PropRef, predicate: PropPredicate): Promise<boolean>;
    matchAnyIndex(vertex: Vertex, key: KeyType): Promise<Index>;
    matchNextIndex(ref: IndexRef, key: KeyType): Promise<Index | undefined>;
    searchIndex(index: Index, predicate: PropPredicate): Promise<IndexedValue>;
    getVertexEdges(vertex: Vertex): Promise<Edge[]>;
    getNextEdges(ref: EdgeRef, edges: Edge[]): Promise<void>;
    getVertexProps(vertex: Vertex): Promise<Prop[]>;
    getEdgeProps(edge: Edge): Promise<Prop[]>;
    getNextProps(ref: PropRef, props: Prop[]): Promise<void>;
    tx(): Tx;
    /**
     * Pack a complete graph
     * @param versionRoot - the version root
     * @returns - a block containing the packed graph
     */
    packGraphVersion(versionRoot?: Link): Promise<Block>;
    /**
     * Pack a graph fragment
     *
     * @param vertexOffsetStart - the offset of the first vertex
     * @param vertexCount - the number of vertices, counting from the first vertex
     * @param graphDepth - the depth of the fragment
     * @param versionRoot - the version root
     * @returns - a block containing the packed graph fragment
     */
    packGraphFragment(vertexOffsetStart: number, vertexCount: number, graphDepth: number, versionRoot?: Link): Promise<Block>;
}
declare class Tx implements ElementAccessor {
    graph: Graph;
    vertices: {
        added: Map<number, Vertex>;
        updated: Map<number, Vertex>;
    };
    edges: {
        added: Map<number, Edge>;
        updated: Map<number, Edge>;
    };
    props: {
        added: Map<number, Prop>;
        updated: Map<number, Prop>;
    };
    indices: {
        added: Map<number, Index>;
        updated: Map<number, Index>;
    };
    vertexOffsetInit: number;
    edgeOffsetInit: number;
    propOffsetInit: number;
    indexOffsetInit: number;
    vertexOffset: number;
    edgeOffset: number;
    propOffset: number;
    indexOffset: number;
    constructor(graph: Graph);
    start(): Promise<Tx>;
    nextVertexOffset(): Offset;
    nextEdgeOffset(): Offset;
    nextPropOffset(): Offset;
    nextIndexOffset(): Offset;
    getVertex(ref: VertexRef): Promise<Vertex>;
    getEdge(ref: EdgeRef): Promise<Edge>;
    getProp(ref: PropRef): Promise<Prop>;
    getIndex(ref: IndexRef): Promise<Index>;
    notifyVertexUpdate(vertex: Vertex): void;
    notifyEdgeUpdate(edge: Edge): void;
    notifyPropUpdate(prop: Prop): void;
    notifyIndexUpdate(index: Index): void;
    addVertex(type?: VertexType): Vertex;
    addEdge(source: Vertex, target: Vertex, type?: EdgeType): Promise<Edge>;
    linkVertexEdge(source: Vertex, edgeRef: EdgeRef): Promise<void>;
    addVertexProp(vertex: Vertex, key: KeyType, value: PropValue, type?: PropType): Promise<Prop>;
    linkVertexProp(source: Vertex, propRef: PropRef): Promise<void>;
    addVertexIndex(vertex: Vertex, key: KeyType, value: Link, type?: IndexType): Promise<Index>;
    addEdgeProp(edge: Edge, key: KeyType, value: PropValue, type?: PropType): Promise<Prop>;
    linkEdgeProp(edge: Edge, propRef: PropRef): Promise<void>;
    linkEdge(currentEdge: Edge, edgeRef: EdgeRef): Promise<void>;
    appendEdge(currentEdge: Edge, newEdge: Edge): Promise<void>;
    linkProp(currentProp: Prop, propRef: PropRef): Promise<void>;
    appendProp(currentProp: Prop, newProp: Prop): Promise<void>;
    appendVertexIndex(currentRef: IndexRef, newIndex: Index): Promise<void>;
    uniqueIndex(outgoingFrom: Vertex, key: KeyType, type?: IndexType): Promise<Index | undefined>;
    commit({ comment, tags, signer, }: {
        comment?: Comment;
        tags?: Tag[];
        signer?: Signer;
    }): Promise<{
        root: Link;
        index: RootIndex;
        blocks: Block[];
    }>;
    fillTargetLinks(refs: Iterable<VertexRef>): Promise<void>;
}
export { Graph, Tx, ElementAccessor };
//# sourceMappingURL=graph.d.ts.map